Update app.py

app.py

@@ -2,7 +2,6 @@ import json
 import math
 import os
 import time
-import base64
 import random
 import tempfile
 import urllib.request
@@ -20,22 +19,11 @@ import gradio as gr
 # ============================================================
 # ZEN Orchestrator Sandbox — Business-grade Agent Simulation
 # ============================================================
-# What this is:
-# - An office-world simulator that looks/feels like a "game" (SVG arena)
-# - Agents move through an environment while executing task backlogs
-# - You can speed time up/down (ticks represent hours/days/weeks)
-# - Everything logs into "Run Data" at the bottom + CSV download
-# - Optional: connect agents to an OpenAI-compatible endpoint via API key
-#
-# Constraints:
-# - Only uses: gradio, numpy, pillow, pandas (+ stdlib)
-# - No hidden modules, no missing files, no broken imports
+# Fixes in this regen:
+# - Removes unsupported gr.Dataframe(height=...) for Gradio 5.49.1
+# - Uses a scroll container via HTML/CSS around the dataframe
 # ============================================================
 
-
-# -----------------------------
-# Visual Config
-# -----------------------------
 GRID_W, GRID_H = 32, 20
 TILE = 22
 HUD_H = 70
@@ -48,7 +36,6 @@ COL_GRID = "rgba(255,255,255,0.06)"
 COL_TEXT = "rgba(235,240,255,0.92)"
 COL_TEXT_DIM = "rgba(235,240,255,0.72)"
 
-# Tile types
 EMPTY = 0
 WALL = 1
 DESK = 2
@@ -57,16 +44,6 @@ SERVER = 4
 INCIDENT = 5
 TASK_NODE = 6
 
-TILE_NAME = {
-    EMPTY: "Empty",
-    WALL: "Wall",
-    DESK: "Desk",
-    MEETING: "Meeting Room",
-    SERVER: "Server Rack",
-    INCIDENT: "Incident",
-    TASK_NODE: "Task Node",
-}
-
 TILE_COL = {
     EMPTY: "#162044",
     WALL: "#cdd2e6",
@@ -82,25 +59,16 @@ AGENT_COLORS = [
     "#ff9b6b", "#c7d2fe", "#a0ffd9", "#ffb0b0",
 ]
 
-
-# -----------------------------
-# Model Pricing (editable defaults)
-# -----------------------------
 DEFAULT_MODEL_PRICING = {
-    # dollars per 1M tokens
     "Simulated-Local": {"in": 0.00, "out": 0.00},
     "gpt-4o-mini": {"in": 0.15, "out": 0.60},
     "gpt-4o": {"in": 5.00, "out": 15.00},
-    "gpt-5": {"in": 5.00, "out": 15.00},  # placeholder
+    "gpt-5": {"in": 5.00, "out": 15.00},
 }
 
-# OpenAI compatible default base URL
 DEFAULT_OAI_BASE = "https://api.openai.com/v1"
 
 
-# -----------------------------
-# Helpers
-# -----------------------------
 def clamp(v, lo, hi):
     return lo if v < lo else hi if v > hi else v
 
@@ -113,7 +81,6 @@ def now_iso():
     return time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime())
 
 def est_tokens(text: str) -> int:
-    # crude but stable estimate: ~4 chars per token
     if not text:
         return 0
     return max(1, int(len(text) / 4))
@@ -130,77 +97,61 @@ def to_csv_download(df: pd.DataFrame) -> str:
     return tmp.name
 
 
-# -----------------------------
-# Data Models
-# -----------------------------
 @dataclass
 class Task:
     id: str
     title: str
     description: str
-    priority: int = 3  # 1-5
-    difficulty: int = 3  # 1-5
+    priority: int = 3
+    difficulty: int = 3
     est_hours: float = 8.0
     created_step: int = 0
-    status: str = "backlog"  # backlog|in_progress|blocked|done
+    status: str = "backlog"
     assigned_to: Optional[str] = None
-    progress: float = 0.0  # 0..1
+    progress: float = 0.0
     blockers: List[str] = field(default_factory=list)
 
 @dataclass
 class Agent:
     name: str
     model: str
-    key_group: str  # "none" or "key1" etc
+    key_group: str
     x: int
     y: int
     energy: float = 100.0
     role: str = "Generalist"
-    state: str = "idle"  # idle|working|moving|blocked
+    state: str = "idle"
     current_task_id: Optional[str] = None
     thoughts: str = ""
     last_action: str = ""
     tokens_in: int = 0
     tokens_out: int = 0
     cost_usd: float = 0.0
-    compute_s: float = 0.0  # wallclock spent "thinking"
+    compute_s: float = 0.0
 
 @dataclass
 class World:
     seed: int = 1337
     step: int = 0
     sim_time_hours: float = 0.0
-
-    # time controls
-    tick_hours: float = 4.0  # each tick advances this many simulated hours
-    difficulty: int = 3      # 1-5 global difficulty
-    incident_rate: float = 0.07  # per tick
-
-    # environment
+    tick_hours: float = 4.0
+    difficulty: int = 3
+    incident_rate: float = 0.07
     grid: List[List[int]] = field(default_factory=list)
     agents: Dict[str, Agent] = field(default_factory=dict)
     tasks: Dict[str, Task] = field(default_factory=dict)
-
-    # logging
     events: List[str] = field(default_factory=list)
     runlog: List[Dict[str, Any]] = field(default_factory=list)
-
-    # KPI counters
     incidents_open: int = 0
     incidents_resolved: int = 0
     tasks_done: int = 0
-
     done: bool = False
 
 
-# -----------------------------
-# Environment Builder
-# -----------------------------
 def build_office(seed: int) -> List[List[int]]:
     r = make_rng(seed)
     g = [[EMPTY for _ in range(GRID_W)] for _ in range(GRID_H)]
 
-    # border walls
     for x in range(GRID_W):
         g[0][x] = WALL
         g[GRID_H - 1][x] = WALL
@@ -208,36 +159,27 @@ def build_office(seed: int) -> List[List[int]]:
         g[y][0] = WALL
         g[y][GRID_W - 1] = WALL
 
-    # rooms blocks
     def rect(x0, y0, x1, y1, tile):
         for y in range(y0, y1 + 1):
             for x in range(x0, x1 + 1):
                 if 1 <= x < GRID_W - 1 and 1 <= y < GRID_H - 1:
                     g[y][x] = tile
 
-    # main open office
     rect(2, 2, GRID_W - 3, GRID_H - 3, EMPTY)
-
-    # meeting rooms
     rect(3, 3, 10, 7, MEETING)
     rect(GRID_W - 11, 3, GRID_W - 4, 7, MEETING)
-
-    # server room
     rect(GRID_W - 10, GRID_H - 8, GRID_W - 4, GRID_H - 3, SERVER)
 
-    # desks grid
     for y in range(9, GRID_H - 10):
         for x in range(4, GRID_W - 12):
             if (x % 3 == 1) and (y % 2 == 0):
                 g[y][x] = DESK
 
-    # task nodes (places where work happens)
     nodes = [(6, GRID_H - 5), (GRID_W // 2, GRID_H // 2), (GRID_W - 14, 10)]
     for (x, y) in nodes:
         if 1 <= x < GRID_W - 1 and 1 <= y < GRID_H - 1:
             g[y][x] = TASK_NODE
 
-    # random inner walls for navigation texture
     for _ in range(22):
         x = r.randint(3, GRID_W - 4)
         y = r.randint(8, GRID_H - 9)
@@ -254,10 +196,6 @@ def random_walkable_cell(g: List[List[int]], r: random.Random) -> Tuple[int, int
                 opts.append((x, y))
     return r.choice(opts) if opts else (2, 2)
 
-
-# -----------------------------
-# Initialization
-# -----------------------------
 def init_world(seed: int) -> World:
     seed = int(seed)
     g = build_office(seed)
@@ -268,13 +206,7 @@ def init_world(seed: int) -> World:
 def add_agent(w: World, name: str, model: str, key_group: str, role: str, seed_bump: int = 0):
     r = make_rng(w.seed + w.step * 17 + seed_bump)
     x, y = random_walkable_cell(w.grid, r)
-    w.agents[name] = Agent(
-        name=name,
-        model=model,
-        key_group=key_group,
-        x=x, y=y,
-        role=role
-    )
+    w.agents[name] = Agent(name=name, model=model, key_group=key_group, x=x, y=y, role=role)
     w.events.append(f"[t={w.step}] Agent added: {name} | model={model} | key_group={key_group} | role={role}")
 
 def add_task(w: World, title: str, description: str, priority: int, difficulty: int, est_hours: float):
@@ -292,9 +224,6 @@ def add_task(w: World, title: str, description: str, priority: int, difficulty:
     return tid
 
 
-# -----------------------------
-# Pathing (simple BFS)
-# -----------------------------
 DIRS4 = [(1,0), (0,1), (-1,0), (0,-1)]
 
 def in_bounds(x, y):
@@ -331,10 +260,6 @@ def bfs_next_step(grid: List[List[int]], start: Tuple[int,int], goal: Tuple[int,
     return cur
 
 
-# -----------------------------
-# OpenAI-Compatible Call (optional)
-# - Uses urllib from stdlib; no new deps
-# -----------------------------
 def oai_chat_completion(base_url: str, api_key: str, model: str, messages: List[Dict[str,str]], timeout_s: int = 25) -> Dict[str, Any]:
     url = base_url.rstrip("/") + "/chat/completions"
     payload = json.dumps({
@@ -346,10 +271,7 @@ def oai_chat_completion(base_url: str, api_key: str, model: str, messages: List[
     req = urllib.request.Request(
         url,
         data=payload,
-        headers={
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {api_key}",
-        },
+        headers={"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"},
         method="POST",
     )
     try:
@@ -365,22 +287,12 @@ def oai_chat_completion(base_url: str, api_key: str, model: str, messages: List[
     except Exception as e:
         return {"error": {"message": str(e)}}
 
-
-# -----------------------------
-# Costing
-# - "Accurate" if provider returns usage tokens
-# - Otherwise estimate tokens from strings
-# -----------------------------
 def price_for(model_pricing: Dict[str, Dict[str,float]], model: str, tokens_in: int, tokens_out: int) -> float:
     p = model_pricing.get(model) or model_pricing.get("Simulated-Local") or {"in":0.0, "out":0.0}
     return (tokens_in / 1_000_000.0) * float(p.get("in", 0.0)) + (tokens_out / 1_000_000.0) * float(p.get("out", 0.0))
 
 
-# -----------------------------
-# Agent Policy
-# -----------------------------
 def choose_task_for_agent(w: World, agent: Agent) -> Optional[str]:
-    # pick highest priority backlog task; tie-breaker: oldest created_step
     backlog = [t for t in w.tasks.values() if t.status in ("backlog", "blocked")]
     if not backlog:
         return None
@@ -388,16 +300,13 @@ def choose_task_for_agent(w: World, agent: Agent) -> Optional[str]:
     return backlog[0].id
 
 def maybe_generate_incident(w: World, r: random.Random):
-    # more difficulty => more incidents
     rate = w.incident_rate * (0.6 + 0.25 * w.difficulty)
     if r.random() < rate:
-        # drop incident tile somewhere
         x, y = random_walkable_cell(w.grid, r)
         if w.grid[y][x] != WALL:
             w.grid[y][x] = INCIDENT
             w.incidents_open += 1
             w.events.append(f"[t={w.step}] INCIDENT spawned at ({x},{y})")
-            # incidents also create a task
             add_task(
                 w,
                 title="Handle incident",
@@ -427,74 +336,32 @@ def nearest_task_node(w: World, ax: int, ay: int) -> Tuple[int,int]:
     return nodes[0]
 
 
-# -----------------------------
-# "Thinking" / Action
-# -----------------------------
 def simulated_reasoning(agent: Agent, task: Task, w: World) -> Tuple[str, str, int, int, float]:
-    """
-    Returns: (thoughts, action_summary, tokens_in, tokens_out, compute_s)
-    """
-    # pretend compute grows with difficulty and task difficulty
     base = 0.08 + 0.04 * w.difficulty + 0.03 * task.difficulty
     compute_s = clamp(base, 0.05, 0.6)
-
-    # craft stable pseudo-thoughts
     thoughts = (
-        f"Assessing '{task.title}'. Priority={task.priority}, difficulty={task.difficulty}. "
-        f"Plan: break into steps, execute, verify, document."
-    )
-    action = (
-        f"Worked on {task.id}: progressed implementation, wrote notes, checked blockers."
+        f"Assess '{task.title}'. Priority={task.priority} difficulty={task.difficulty}. "
+        f"Plan: decompose, execute, verify, document."
     )
-
+    action = f"Progressed {task.id}. Updated notes, checked blockers, validated output."
     tin = est_tokens(task.title + " " + task.description) + 30
     tout = est_tokens(thoughts + " " + action) + 40
     return thoughts, action, tin, tout, compute_s
 
-def api_reasoning(
-    agent: Agent,
-    task: Task,
-    w: World,
-    base_url: str,
-    api_key: str,
-    model: str,
-    context_prompt: str
-) -> Tuple[str, str, int, int, float, Optional[str]]:
-    """
-    Returns: thoughts, action, tokens_in, tokens_out, compute_s, error
-    """
+def api_reasoning(agent: Agent, task: Task, w: World, base_url: str, api_key: str, model: str, context_prompt: str):
     t0 = time.time()
-
     sys = (
         "You are an autonomous business operations agent in a multi-agent simulation. "
         "Return a JSON object with keys: thoughts, action, blockers (list), progress_delta (0..1). "
         "Keep thoughts short and action concrete."
     )
     user = {
-        "simulation": {
-            "step": w.step,
-            "sim_time_hours": w.sim_time_hours,
-            "global_difficulty": w.difficulty,
-            "open_incidents": w.incidents_open,
-        },
-        "agent": {
-            "name": agent.name,
-            "role": agent.role,
-            "energy": agent.energy,
-        },
+        "simulation": {"step": w.step, "sim_time_hours": w.sim_time_hours, "difficulty": w.difficulty, "incidents_open": w.incidents_open},
+        "agent": {"name": agent.name, "role": agent.role, "energy": agent.energy},
         "task": asdict(task),
-        "context": context_prompt[:1400] if context_prompt else "",
+        "context": (context_prompt or "")[:1400],
     }
-
-    resp = oai_chat_completion(
-        base_url=base_url,
-        api_key=api_key,
-        model=model,
-        messages=[
-            {"role": "system", "content": sys},
-            {"role": "user", "content": json.dumps(user)},
-        ]
-    )
+    resp = oai_chat_completion(base_url, api_key, model, [{"role":"system","content":sys},{"role":"user","content":json.dumps(user)}])
     compute_s = float(time.time() - t0)
 
     if "error" in resp:
@@ -514,7 +381,6 @@ def api_reasoning(
 
     obj = safe_json(content, fallback=None)
     if not isinstance(obj, dict):
-        # fallback parse: treat raw as action
         thoughts = "Provider returned non-JSON; using fallback."
         action = content[:400]
         tin = usage_in if isinstance(usage_in, int) else est_tokens(sys + json.dumps(user))
@@ -526,7 +392,6 @@ def api_reasoning(
     blockers = obj.get("blockers", [])
     progress_delta = obj.get("progress_delta", 0.0)
 
-    # Apply structured results
     if isinstance(blockers, list) and blockers:
         task.blockers = [str(b)[:80] for b in blockers][:5]
         task.status = "blocked"
@@ -536,8 +401,7 @@ def api_reasoning(
             task.status = "in_progress"
 
     try:
-        pdlt = float(progress_delta)
-        task.progress = clamp(task.progress + pdlt, 0.0, 1.0)
+        task.progress = clamp(task.progress + float(progress_delta), 0.0, 1.0)
     except Exception:
         pass
 
@@ -546,24 +410,12 @@ def api_reasoning(
     return thoughts, action, tin, tout, compute_s, None
 
 
-# -----------------------------
-# Core Tick
-# -----------------------------
-def step_agent(
-    w: World,
-    agent: Agent,
-    r: random.Random,
-    model_pricing: Dict[str, Dict[str, float]],
-    keyrings: Dict[str, str],
-    base_url: str,
-    context_prompt: str
-):
+def step_agent(w: World, agent: Agent, r: random.Random, model_pricing: Dict[str, Dict[str, float]], keyrings: Dict[str, str], base_url: str, context_prompt: str):
     if agent.energy <= 0:
         agent.state = "blocked"
         agent.last_action = "Out of energy"
         return
 
-    # assign task if none
     if agent.current_task_id is None or agent.current_task_id not in w.tasks:
         tid = choose_task_for_agent(w, agent)
         if tid is None:
@@ -578,11 +430,9 @@ def step_agent(
 
     task = w.tasks[agent.current_task_id]
 
-    # movement target: incidents -> server room -> meeting -> task node
     incs = incident_positions(w)
-    target = None
     if incs and task.priority >= 5:
-        incs.sort(key=lambda p: abs(p[0]-agent.x) + abs(p[1]-agent.y))
+        incs.sort(key=lambda p: abs(p[0]-agent.x)+abs(p[1]-agent.y))
         target = incs[0]
     else:
         target = nearest_task_node(w, agent.x, agent.y)
@@ -595,46 +445,32 @@ def step_agent(
         agent.energy = max(0.0, agent.energy - 0.8)
         return
 
-    # do work
     agent.state = "working"
 
     if agent.model == "Simulated-Local" or agent.key_group == "none":
         thoughts, action, tin, tout, compute_s = simulated_reasoning(agent, task, w)
         err = None
-    else:
-        key = keyrings.get(agent.key_group, "")
-        if not key:
-            thoughts, action, tin, tout, compute_s = simulated_reasoning(agent, task, w)
-            err = f"No key found for group '{agent.key_group}', used local simulation."
-        else:
-            thoughts, action, tin, tout, compute_s, err = api_reasoning(
-                agent=agent,
-                task=task,
-                w=w,
-                base_url=base_url,
-                api_key=key,
-                model=agent.model,
-                context_prompt=context_prompt
-            )
-
-    # apply progress if local sim
-    if agent.model == "Simulated-Local" or agent.key_group == "none":
-        # harder tasks progress slower; difficulty scales
         speed = 0.08 / (0.6 + 0.25 * w.difficulty + 0.30 * task.difficulty)
         task.progress = clamp(task.progress + speed, 0.0, 1.0)
         if task.progress < 1.0:
             task.status = "in_progress"
+    else:
+        key = (keyrings or {}).get(agent.key_group, "")
+        if not key:
+            thoughts, action, tin, tout, compute_s = simulated_reasoning(agent, task, w)
+            err = f"No key for group '{agent.key_group}', used local simulation."
+            speed = 0.08 / (0.6 + 0.25 * w.difficulty + 0.30 * task.difficulty)
+            task.progress = clamp(task.progress + speed, 0.0, 1.0)
+        else:
+            thoughts, action, tin, tout, compute_s, err = api_reasoning(agent, task, w, base_url, key, agent.model, context_prompt)
 
-    # complete
     if task.progress >= 1.0 and task.status != "done":
         task.status = "done"
         w.tasks_done += 1
         w.events.append(f"[t={w.step}] DONE {task.id}: {task.title}")
         agent.current_task_id = None
 
-        # resolve incident if task was incident-related
         if "incident" in task.title.lower():
-            # remove one incident tile if any
             incs = incident_positions(w)
             if incs:
                 x, y = incs[0]
@@ -643,18 +479,14 @@ def step_agent(
                 w.incidents_resolved += 1
                 w.events.append(f"[t={w.step}] Incident resolved at ({x},{y})")
 
-    # update tokens/cost/compute
     agent.thoughts = thoughts
     agent.last_action = action if action else agent.last_action
     agent.tokens_in += int(tin)
     agent.tokens_out += int(tout)
     agent.compute_s += float(compute_s)
     agent.cost_usd += price_for(model_pricing, agent.model, int(tin), int(tout))
-
-    # energy drain
     agent.energy = max(0.0, agent.energy - (0.8 + 0.15 * w.difficulty + 0.12 * task.difficulty))
 
-    # runlog row
     w.runlog.append({
         "step": w.step,
         "sim_time_hours": round(w.sim_time_hours, 2),
@@ -675,57 +507,33 @@ def step_agent(
     })
 
 
-def tick(
-    w: World,
-    r: random.Random,
-    model_pricing: Dict[str, Dict[str, float]],
-    keyrings: Dict[str, str],
-    base_url: str,
-    context_prompt: str,
-    max_log: int = 4000,
-):
+def tick(w: World, r: random.Random, model_pricing: Dict[str, Dict[str, float]], keyrings: Dict[str, str], base_url: str, context_prompt: str, max_log: int = 4000):
     if w.done:
         return
-
-    # incidents
     maybe_generate_incident(w, r)
-
-    # agent step order: low energy last
     agents = list(w.agents.values())
     agents.sort(key=lambda a: (a.energy, a.name))
-
     for ag in agents:
         step_agent(w, ag, r, model_pricing, keyrings, base_url, context_prompt)
-
-    # advance time
     w.step += 1
     w.sim_time_hours += float(w.tick_hours)
-
-    # prune logs
     if len(w.events) > 250:
         w.events = w.events[-250:]
     if len(w.runlog) > max_log:
         w.runlog = w.runlog[-max_log:]
 
 
-# -----------------------------
-# KPIs
-# -----------------------------
 def compute_kpis(w: World) -> Dict[str, Any]:
     backlog = sum(1 for t in w.tasks.values() if t.status == "backlog")
     inprog = sum(1 for t in w.tasks.values() if t.status == "in_progress")
     blocked = sum(1 for t in w.tasks.values() if t.status == "blocked")
     done = sum(1 for t in w.tasks.values() if t.status == "done")
-
     total_cost = sum(a.cost_usd for a in w.agents.values())
     total_tokens_in = sum(a.tokens_in for a in w.agents.values())
     total_tokens_out = sum(a.tokens_out for a in w.agents.values())
     total_compute = sum(a.compute_s for a in w.agents.values())
-
-    # throughput: tasks done per simulated day
     days = max(1e-6, w.sim_time_hours / 24.0)
     tpd = done / days
-
     return {
         "sim_time_days": round(w.sim_time_hours / 24.0, 2),
         "agents": len(w.agents),
@@ -744,20 +552,14 @@ def compute_kpis(w: World) -> Dict[str, Any]:
     }
 
 
-# -----------------------------
-# SVG Renderer
-# -----------------------------
 def svg_render(w: World) -> str:
     k = compute_kpis(w)
-
     headline = (
         f"ZEN Orchestrator Sandbox • step={w.step} • sim_days={k['sim_time_days']} • "
         f"agents={k['agents']} • done={k['tasks_done']} • backlog={k['tasks_backlog']} • "
         f"incidents_open={k['incidents_open']} • cost=${k['cost_usd_total']}"
     )
-    detail = (
-        f"tick_hours={w.tick_hours} • difficulty={w.difficulty} • incident_rate={round(w.incident_rate,3)}"
-    )
+    detail = f"tick_hours={w.tick_hours} • difficulty={w.difficulty} • incident_rate={round(w.incident_rate,3)}"
 
     css = f"""
     <style>
@@ -791,17 +593,12 @@ def svg_render(w: World) -> str:
         50% {{ transform: scale(1.15); opacity: 0.26; }}
         100% {{ transform: scale(1.0); opacity: 0.14; }}
       }}
-      .badge {{
-        fill: rgba(15,23,51,0.72);
-        stroke: rgba(170,195,255,0.16);
-        stroke-width: 1;
+      .tag {{
+        fill: rgba(0,0,0,0.38);
       }}
       .tile {{
         shape-rendering: crispEdges;
       }}
-      .tag {{
-        fill: rgba(0,0,0,0.38);
-      }}
     </style>
     """
 
@@ -815,7 +612,6 @@ def svg_render(w: World) -> str:
       <text class="hud hudSmall" x="16" y="52" font-size="12">{detail}</text>
     """]
 
-    # tiles
     for y in range(GRID_H):
         for x in range(GRID_W):
             t = w.grid[y][x]
@@ -823,17 +619,10 @@ def svg_render(w: World) -> str:
             px = x * TILE
             py = HUD_H + y * TILE
             parts.append(f'<rect class="tile" x="{px}" y="{py}" width="{TILE}" height="{TILE}" fill="{col}"/>')
-
-            # tile glyphs
-            if t == SERVER:
-                parts.append(f'<rect x="{px+6}" y="{py+5}" width="{TILE-12}" height="{TILE-10}" rx="4" fill="rgba(0,0,0,0.28)"/>')
-            if t == MEETING:
-                parts.append(f'<circle cx="{px+TILE/2}" cy="{py+TILE/2}" r="5" fill="rgba(0,0,0,0.28)"/>')
             if t == INCIDENT:
                 parts.append(f'<circle cx="{px+TILE/2}" cy="{py+TILE/2}" r="7" fill="rgba(0,0,0,0.25)"/>')
                 parts.append(f'<circle cx="{px+TILE/2}" cy="{py+TILE/2}" r="4" fill="rgba(255,255,255,0.65)"/>')
 
-    # gridlines subtle
     for x in range(GRID_W + 1):
         px = x * TILE
         parts.append(f'<line class="gridline" x1="{px}" y1="{HUD_H}" x2="{px}" y2="{SVG_H}"/>')
@@ -841,7 +630,6 @@ def svg_render(w: World) -> str:
         py = HUD_H + y * TILE
         parts.append(f'<line class="gridline" x1="0" y1="{py}" x2="{SVG_W}" y2="{py}"/>')
 
-    # agents
     for i, ag in enumerate(w.agents.values()):
         col = AGENT_COLORS[i % len(AGENT_COLORS)]
         px = ag.x * TILE
@@ -850,28 +638,21 @@ def svg_render(w: World) -> str:
           <g class="agent" style="transform: translate({px}px, {py}px);">
             <circle class="pulse" cx="{TILE/2}" cy="{TILE/2}" r="{TILE*0.48}" fill="{col}"></circle>
             <circle cx="{TILE/2}" cy="{TILE/2}" r="{TILE*0.34}" fill="{col}" opacity="0.98"></circle>
+            <rect class="tag" x="{TILE*0.10}" y="{TILE*0.08}" width="{TILE*0.80}" height="14" rx="7"/>
+            <text x="{TILE/2}" y="{TILE*0.08 + 11}" text-anchor="middle" font-size="9"
+              fill="rgba(235,240,255,0.90)" font-family="ui-sans-serif, system-ui">{ag.name}</text>
         """)
-
-        # state tag
-        parts.append(f'<rect class="tag" x="{TILE*0.10}" y="{TILE*0.08}" width="{TILE*0.80}" height="14" rx="7"/>')
-        parts.append(f'<text x="{TILE/2}" y="{TILE*0.08 + 11}" text-anchor="middle" font-size="9" fill="rgba(235,240,255,0.90)" font-family="ui-sans-serif, system-ui">{ag.name}</text>')
-
-        # energy bar
         bar_w = TILE * 0.80
         bx = TILE/2 - bar_w/2
         by = TILE * 0.82
         parts.append(f'<rect x="{bx}" y="{by}" width="{bar_w}" height="6" rx="4" fill="rgba(255,255,255,0.12)"/>')
         parts.append(f'<rect x="{bx}" y="{by}" width="{bar_w*(clamp(ag.energy,0,100)/100.0)}" height="6" rx="4" fill="rgba(122,255,200,0.85)"/>')
-
         parts.append("</g>")
 
     parts.append("</svg></div>")
     return "".join(parts)
 
 
-# -----------------------------
-# UI Helpers
-# -----------------------------
 def agents_text(w: World) -> str:
     lines = []
     for ag in w.agents.values():
@@ -884,7 +665,6 @@ def agents_text(w: World) -> str:
     return "\n".join(lines) if lines else "(no agents yet)"
 
 def tasks_text(w: World) -> str:
-    # show top tasks by priority and status
     tasks = list(w.tasks.values())
     tasks.sort(key=lambda t: (t.status != "done", -t.priority, t.created_step))
     out = []
@@ -900,8 +680,7 @@ def events_text(w: World) -> str:
     return "\n".join(w.events[-20:]) if w.events else ""
 
 def kpis_text(w: World) -> str:
-    k = compute_kpis(w)
-    return json.dumps(k, indent=2)
+    return json.dumps(compute_kpis(w), indent=2)
 
 def run_data_df(w: World, rows: int) -> pd.DataFrame:
     rows = int(max(10, rows))
@@ -910,35 +689,43 @@ def run_data_df(w: World, rows: int) -> pd.DataFrame:
             "step","sim_time_hours","agent","role","model","key_group","task_id","task_status","task_progress",
             "action","thoughts","tokens_in","tokens_out","cost_usd","compute_s","error"
         ])
-    data = w.runlog[-rows:]
-    return pd.DataFrame(data)
+    return pd.DataFrame(w.runlog[-rows:])
 
 def ui_refresh(w: World, run_rows: int):
-    arena = svg_render(w)
-    agents_box = agents_text(w)
-    tasks_box = tasks_text(w)
-    events_box = events_text(w)
-    kpi_box = kpis_text(w)
-    df = run_data_df(w, run_rows)
-    return arena, agents_box, tasks_box, events_box, kpi_box, df
-
-
-# -----------------------------
-# Gradio App
-# -----------------------------
+    return (
+        svg_render(w),
+        agents_text(w),
+        tasks_text(w),
+        events_text(w),
+        kpis_text(w),
+        run_data_df(w, run_rows),
+    )
+
+
 TITLE = "ZEN Orchestrator Sandbox — Business-grade Agent Orchestra Simulator"
 
 with gr.Blocks(title=TITLE) as demo:
     gr.Markdown(
         f"## {TITLE}\n"
-        "A **business-oriented multi-agent simulation** with **game-like visuals**, time controls, run logging, and optional model keys.\n"
-        "You can run fully **without keys** (local simulation), or attach an **OpenAI-compatible endpoint** for live model calls."
+        "Business-oriented multi-agent simulation with game-like visuals, time controls, run logging, and optional model keys."
     )
 
+    # CSS scroll wrapper for the dataframe (Gradio 5.49.1-safe)
+    gr.HTML("""
+    <style>
+      .zen-scroll {
+        max-height: 320px;
+        overflow: auto;
+        border-radius: 12px;
+        border: 1px solid rgba(255,255,255,0.10);
+        background: rgba(255,255,255,0.03);
+        padding: 10px;
+      }
+    </style>
+    """)
+
     w_state = gr.State(init_world(1337))
     autoplay_on = gr.State(False)
-
-    # keyring and pricing live state as JSON text fields
     keyrings_state = gr.State({"none": ""})
     pricing_state = gr.State(DEFAULT_MODEL_PRICING)
 
@@ -956,14 +743,19 @@ with gr.Blocks(title=TITLE) as demo:
     with gr.Row():
         runlog_rows = gr.Slider(50, 1500, value=250, step=50, label="Run Data rows to display")
         download_btn = gr.Button("Download Run Data CSV")
-    run_data = gr.Dataframe(label="Run Data", interactive=False, wrap=True, height=320)
+
+    # Scroll wrapper around dataframe
+    gr.HTML('<div class="zen-scroll">')
+    run_data = gr.Dataframe(label="Run Data", interactive=False, wrap=True)  # ✅ no height kwarg
+    gr.HTML('</div>')
+
     download_file = gr.File(label="CSV Download", interactive=False)
 
     gr.Markdown("### Scenario + Orchestration Controls")
     with gr.Row():
         seed_in = gr.Number(value=1337, precision=0, label="Seed")
-        tick_hours = gr.Slider(0.5, 168.0, value=4.0, step=0.5, label="Simulated hours per tick (speed of time)")
-        difficulty = gr.Slider(1, 5, value=3, step=1, label="Global difficulty (more friction)")
+        tick_hours = gr.Slider(0.5, 168.0, value=4.0, step=0.5, label="Simulated hours per tick")
+        difficulty = gr.Slider(1, 5, value=3, step=1, label="Global difficulty")
         incident_rate = gr.Slider(0.0, 0.35, value=0.07, step=0.01, label="Incident rate per tick")
 
     with gr.Row():
@@ -981,46 +773,38 @@ with gr.Blocks(title=TITLE) as demo:
         task_est = gr.Slider(0.25, 200.0, value=16.0, step=0.25, label="Estimated hours")
         btn_add_task = gr.Button("Add Task")
 
-    gr.Markdown("### Add Agents (unlimited)")
+    gr.Markdown("### Add Agents")
     with gr.Row():
         agent_name = gr.Textbox(label="Agent name", value="Agent-01")
         agent_role = gr.Dropdown(
             choices=["Generalist", "Ops", "HR Automation", "Engineer", "Analyst", "Incident Response", "PM"],
             value="Engineer",
-            label="Role"
+            label="Role",
         )
     with gr.Row():
         model_choice = gr.Dropdown(
             choices=["Simulated-Local", "gpt-4o-mini", "gpt-4o", "gpt-5"],
             value="Simulated-Local",
-            label="Model"
+            label="Model",
         )
         key_group = gr.Dropdown(
             choices=["none", "key1", "key2", "key3"],
             value="none",
-            label="Key group (1 key can power up to 10 agents)"
+            label="Key group",
         )
         btn_add_agent = gr.Button("Add Agent")
 
     gr.Markdown("### Model Keys + Pricing (Optional)")
     with gr.Row():
         oai_base = gr.Textbox(label="OpenAI-compatible base URL", value=DEFAULT_OAI_BASE)
-        context_prompt = gr.Textbox(
-            label="Global Context Prompt (gives the orchestra mission + culture)",
-            value="You are simulating a business ops team executing tasks with auditability and cost tracking.",
-            lines=3
-        )
+        context_prompt = gr.Textbox(label="Global Context Prompt", value="Simulate a business ops team with auditability and cost tracking.", lines=3)
 
     with gr.Row():
         key1 = gr.Textbox(label="API Key (key1)", type="password")
         key2 = gr.Textbox(label="API Key (key2)", type="password")
         key3 = gr.Textbox(label="API Key (key3)", type="password")
 
-    pricing_json = gr.Textbox(
-        label="Model pricing JSON (USD per 1M tokens)",
-        value=json.dumps(DEFAULT_MODEL_PRICING, indent=2),
-        lines=8
-    )
+    pricing_json = gr.Textbox(label="Model pricing JSON (USD per 1M tokens)", value=json.dumps(DEFAULT_MODEL_PRICING, indent=2), lines=8)
     btn_apply_keys = gr.Button("Apply Keys + Pricing")
 
     gr.Markdown("### Autoplay")
@@ -1031,25 +815,8 @@ with gr.Blocks(title=TITLE) as demo:
 
     timer = gr.Timer(value=0.18, active=False)
 
-    # -----------------------------
-    # Events
-    # -----------------------------
-    def on_load(w: World, rows: int):
-        return (*ui_refresh(w, rows), w)
-
-    demo.load(
-        on_load,
-        inputs=[w_state, runlog_rows],
-        outputs=[arena, agents_box, tasks_box, events_box, kpi_box, run_data, w_state],
-        queue=True,
-    )
-
-    def reset_world(seed: int):
-        w = init_world(int(seed))
-        return w
-
     def do_reset(seed: int, rows: int):
-        w = reset_world(seed)
+        w = init_world(int(seed))
         return (*ui_refresh(w, rows), w)
 
     btn_reset.click(
@@ -1059,13 +826,6 @@ with gr.Blocks(title=TITLE) as demo:
         queue=True,
     )
 
-    def apply_scenario(w: World, th: float, diff: int, ir: float):
-        w.tick_hours = float(th)
-        w.difficulty = int(diff)
-        w.incident_rate = float(ir)
-        w.events.append(f"[t={w.step}] Scenario updated: tick_hours={w.tick_hours}, difficulty={w.difficulty}, incident_rate={w.incident_rate}")
-        return w
-
     def add_task_clicked(w: World, rows: int, title: str, desc: str, p: int, d: int, est: float):
         add_task(w, title, desc, p, d, est)
         return (*ui_refresh(w, rows), w)
@@ -1078,12 +838,10 @@ with gr.Blocks(title=TITLE) as demo:
     )
 
     def add_agent_clicked(w: World, rows: int, name: str, role: str, model: str, kg: str):
-        name = (name or "").strip()
-        if not name:
-            name = f"Agent-{len(w.agents)+1:02d}"
+        name = (name or "").strip() or f"Agent-{len(w.agents)+1:02d}"
         if name in w.agents:
             name = f"{name}-{len(w.agents)+1}"
-        add_agent(w, name=name, model=model, key_group=kg, role=role, seed_bump=len(w.agents)*19)
+        add_agent(w, name=name, model=model, key_group=kg, role=role, seed_bump=len(w.agents) * 19)
         return (*ui_refresh(w, rows), w)
 
     btn_add_agent.click(
@@ -1093,32 +851,32 @@ with gr.Blocks(title=TITLE) as demo:
         queue=True,
     )
 
-    def apply_keys_pricing(keys_state: Dict[str,str], pricing_state_obj: Dict[str,Any], base_url: str, k1: str, k2: str, k3: str, pricing_txt: str):
-        # update keyrings
+    def apply_keys_pricing(keys_state: Dict[str, str], pricing_state_obj: Dict[str, Any], k1: str, k2: str, k3: str, pricing_txt: str):
         keys_state = dict(keys_state) if isinstance(keys_state, dict) else {"none": ""}
         keys_state["none"] = ""
         if k1: keys_state["key1"] = k1.strip()
         if k2: keys_state["key2"] = k2.strip()
         if k3: keys_state["key3"] = k3.strip()
 
-        # update pricing
         pj = safe_json(pricing_txt, fallback=None)
         if isinstance(pj, dict):
             pricing_state_obj = pj
 
-        # base_url is stored in UI directly; we just return states
         return keys_state, pricing_state_obj
 
     btn_apply_keys.click(
         apply_keys_pricing,
-        inputs=[keyrings_state, pricing_state, oai_base, key1, key2, key3, pricing_json],
+        inputs=[keyrings_state, pricing_state, key1, key2, key3, pricing_json],
         outputs=[keyrings_state, pricing_state],
         queue=True,
     )
 
     def run_clicked(w: World, rows: int, n: int, th: float, diff: int, ir: float,
-                    keys_state: Dict[str,str], pricing_obj: Dict[str,Any], base_url: str, ctx: str):
-        w = apply_scenario(w, th, diff, ir)
+                    keys_state: Dict[str, str], pricing_obj: Dict[str, Any], base_url: str, ctx: str):
+        w.tick_hours = float(th)
+        w.difficulty = int(diff)
+        w.incident_rate = float(ir)
+        w.events.append(f"[t={w.step}] Scenario updated: tick_hours={w.tick_hours}, difficulty={w.difficulty}, incident_rate={w.incident_rate}")
         n = int(max(1, n))
         r = make_rng(w.seed + w.step * 101)
         for _ in range(n):
@@ -1133,7 +891,7 @@ with gr.Blocks(title=TITLE) as demo:
     )
 
     def download_run_data(w: World, rows: int):
-        df = run_data_df(w, rows=50000)  # export a lot
+        df = run_data_df(w, rows=50000)
         path = to_csv_download(df)
         return path
 
@@ -1144,38 +902,25 @@ with gr.Blocks(title=TITLE) as demo:
         queue=True,
     )
 
-    # -----------------------------
-    # Autoplay (FIXED — no starred tuple nesting bug)
-    # -----------------------------
     def autoplay_start(interval: float):
-        interval = float(interval)
-        return gr.update(value=interval, active=True), True
+        return gr.update(value=float(interval), active=True), True
 
     def autoplay_stop():
         return gr.update(active=False), False
 
-    btn_play.click(
-        autoplay_start,
-        inputs=[autoplay_speed],
-        outputs=[timer, autoplay_on],
-        queue=True,
-    )
-    btn_pause.click(
-        autoplay_stop,
-        inputs=[],
-        outputs=[timer, autoplay_on],
-        queue=True,
-    )
+    btn_play.click(autoplay_start, inputs=[autoplay_speed], outputs=[timer, autoplay_on], queue=True)
+    btn_pause.click(autoplay_stop, inputs=[], outputs=[timer, autoplay_on], queue=True)
 
     def autoplay_tick(w: World, is_on: bool, rows: int, th: float, diff: int, ir: float,
-                     keys_state: Dict[str,str], pricing_obj: Dict[str,Any], base_url: str, ctx: str):
+                     keys_state: Dict[str, str], pricing_obj: Dict[str, Any], base_url: str, ctx: str):
         if not is_on:
             return (*ui_refresh(w, rows), w, is_on, gr.update())
 
-        w = apply_scenario(w, th, diff, ir)
+        w.tick_hours = float(th)
+        w.difficulty = int(diff)
+        w.incident_rate = float(ir)
         r = make_rng(w.seed + w.step * 101)
         tick(w, r, pricing_obj, keys_state, base_url, ctx)
-
         return (*ui_refresh(w, rows), w, True, gr.update())
 
     timer.tick(
@@ -1185,4 +930,15 @@ with gr.Blocks(title=TITLE) as demo:
         queue=True,
     )
 
+    # initial render
+    def on_load(w: World, rows: int):
+        return (*ui_refresh(w, rows), w)
+
+    demo.load(
+        on_load,
+        inputs=[w_state, runlog_rows],
+        outputs=[arena, agents_box, tasks_box, events_box, kpi_box, run_data, w_state],
+        queue=True,
+    )
+
 demo.queue().launch(ssr_mode=False)