Update app.py

app.py

@@ -5,26 +5,28 @@ import csv
 import io
 import json
 import math
+import os
 import random
+import tempfile
 import time
+import uuid
 from dataclasses import dataclass, field
 from typing import Dict, List, Any, Optional, Tuple
 
 import numpy as np
+import pandas as pd
 import gradio as gr
 
 from core.kpi import compute_kpis
 
 # ============================================================
-# ZEN Orchestrator Arena — Visual Agent Orchestra + Business KPIs
-# ============================================================
-# What you get:
-# - Animated SVG environment (smooth movement)
-# - Optional pseudo-3D POV panel (lightweight raycaster)
-# - Business backlog: tasks distributed across the map as "task nodes"
-# - Live logs: action + thought + tokens + cost + wall + sim time
-# - Incidents: inject blockers, regress progress, force reroutes
-# - Exports: JSONL run log + CSV finance ledger
+# ZEN Orchestrator Arena — Visual Agent Orchestra + Run Data Table
+# - Run log is always visible + scrollable in-app
+# - Downloads use real files on disk via DownloadButton
+# - Add unlimited agents (Sim or API-driven)
+# - 1 API key slot can power up to 10 agents
+# - Scenario prompt + per-agent behavior prompt
+# - Regenerate map + regenerate tasks with controls
 # ============================================================
 
 # -----------------------------
@@ -36,6 +38,7 @@ DEFAULT_MODEL_PROFILES = {
     "Sim-Claude": {"in_per_1m": 3.00, "out_per_1m": 15.00, "tps": 90.0},
     "Sim-Gemini": {"in_per_1m": 1.50, "out_per_1m": 6.00, "tps": 200.0},
     "Sim-Local": {"in_per_1m": 0.20, "out_per_1m": 0.20, "tps": 300.0},
+    "API-LLM": {"in_per_1m": 5.00, "out_per_1m": 15.00, "tps": 120.0},  # default placeholder
 }
 
 SIM_TIME_PRESETS = {
@@ -78,7 +81,7 @@ TILE_NAMES = {
     RESOURCE: "Resource",
 }
 
-# Palette (readable, “ops dashboard night mode”)
+# Palette
 COL_BG = "#0b1020"
 COL_PANEL = "#0f1733"
 COL_GRIDLINE = "#121a3b"
@@ -115,8 +118,15 @@ def fmt_duration(seconds: float) -> str:
     s = float(max(0.0, seconds))
     if s < 1:
         return f"{s:.3f}s"
-    # pick a scale
-    units = [("seconds", 1), ("minutes", 60), ("hours", 3600), ("days", 86400), ("weeks", 604800), ("months(30d)", 2592000), ("years(365d)", 31536000)]
+    units = [
+        ("seconds", 1),
+        ("minutes", 60),
+        ("hours", 3600),
+        ("days", 86400),
+        ("weeks", 604800),
+        ("months(30d)", 2592000),
+        ("years(365d)", 31536000),
+    ]
     unit, scale = "seconds", 1
     for name, sc in units:
         if s >= sc:
@@ -137,8 +147,8 @@ def is_blocking(tile: int) -> bool:
     return tile == WALL
 
 
-def manhattan(a: Tuple[int, int], b: Tuple[int, int]) -> int:
-    return abs(a[0]-b[0]) + abs(a[1]-b[1])
+def neighbors4(x: int, y: int) -> List[Tuple[int, int]]:
+    return [(x + 1, y), (x, y + 1), (x - 1, y), (x, y - 1)]
 
 
 def make_rng(seed: int) -> random.Random:
@@ -147,10 +157,6 @@ def make_rng(seed: int) -> random.Random:
     return r
 
 
-def neighbors4(x: int, y: int) -> List[Tuple[int, int]]:
-    return [(x+1,y), (x,y+1), (x-1,y), (x,y-1)]
-
-
 def bfs_next_step(grid: List[List[int]], start: Tuple[int, int], goal: Tuple[int, int]) -> Optional[Tuple[int, int]]:
     if start == goal:
         return None
@@ -201,6 +207,19 @@ class Task:
     notes: str = ""
 
 
+@dataclass
+class ApiKeySlot:
+    slot_name: str
+    provider: str = "OpenAI-compatible"
+    base_url: str = "https://api.openai.com/v1"
+    api_key: str = ""  # keep in memory/state only
+    model: str = "gpt-4o-mini"
+    temperature: float = 0.3
+    max_output_tokens: int = 220
+    system_prompt: str = "You are an agent in a multi-agent office simulation. Be concise, action-oriented, and realistic."
+    agents_using: int = 0  # enforced <= 10
+
+
 @dataclass
 class Agent:
     name: str
@@ -214,6 +233,9 @@ class Agent:
     fatigue: float = 0.0
     skill: Dict[str, float] = field(default_factory=dict)
     target_task_id: Optional[str] = None
+    behavior_prompt: str = ""
+    engine: str = "sim"  # "sim" or "api"
+    api_slot: Optional[str] = None  # slot_name
 
 
 @dataclass
@@ -235,24 +257,29 @@ class World:
     overlay: bool = True
     auto_camera: bool = True
 
+    scenario_prompt: str = "Run a realistic office execution cycle: prioritize critical work, mitigate incidents, and finish tasks."
+
     model_profiles: Dict[str, Dict[str, float]] = field(default_factory=dict)
 
-    # logs
+    api_slots: Dict[str, ApiKeySlot] = field(default_factory=dict)
+
     run_log: List[Dict[str, Any]] = field(default_factory=list)
     events: List[str] = field(default_factory=list)
 
     done: bool = False
 
 
-def default_agents_positions() -> Dict[str, Tuple[int,int]]:
-    # spawn points
+# -----------------------------
+# Defaults
+# -----------------------------
+def default_agents_positions() -> Dict[str, Tuple[int, int]]:
     return {
         "PM": (2, 2),
-        "ENG": (GRID_W-3, 2),
-        "DATA": (2, GRID_H-3),
-        "OPS": (GRID_W-3, GRID_H-3),
-        "SEC": (GRID_W//2, 2),
-        "DES": (GRID_W//2, GRID_H-3),
+        "ENG": (GRID_W - 3, 2),
+        "DATA": (2, GRID_H - 3),
+        "OPS": (GRID_W - 3, GRID_H - 3),
+        "SEC": (GRID_W // 2, 2),
+        "DES": (GRID_W // 2, GRID_H - 3),
     }
 
 
@@ -260,54 +287,92 @@ def default_agents() -> Dict[str, Agent]:
     sp = default_agents_positions()
     return {
         "PM": Agent("PM", "Product Manager", "Sim-GPT-4o", *sp["PM"], focus=0.80, reliability=0.90,
-                    skill={"product": 0.95, "ops": 0.70, "design": 0.55, "engineering": 0.35}),
+                   skill={"product": 0.95, "ops": 0.70, "design": 0.55, "engineering": 0.35},
+                   behavior_prompt="Drive priority clarity, reduce scope creep, keep tasks unblocked."),
         "ENG": Agent("ENG", "Engineer", "Sim-GPT-5", *sp["ENG"], focus=0.82, reliability=0.86,
-                     skill={"engineering": 0.95, "data": 0.70, "security": 0.55, "ops": 0.55}),
+                    skill={"engineering": 0.95, "data": 0.70, "security": 0.55, "ops": 0.55},
+                    behavior_prompt="Build pragmatic solutions, unblock dependencies, keep shipping."),
         "DATA": Agent("DATA", "Data Scientist", "Sim-Gemini", *sp["DATA"], focus=0.78, reliability=0.84,
-                      skill={"data": 0.92, "engineering": 0.55, "product": 0.45}),
+                     skill={"data": 0.92, "engineering": 0.55, "product": 0.45},
+                     behavior_prompt="Measure outcomes, validate metrics, improve decision quality."),
         "OPS": Agent("OPS", "Ops Lead", "Sim-Claude", *sp["OPS"], focus=0.76, reliability=0.88,
-                     skill={"ops": 0.92, "security": 0.65, "product": 0.55, "engineering": 0.45}),
+                    skill={"ops": 0.92, "security": 0.65, "product": 0.55, "engineering": 0.45},
+                    behavior_prompt="Keep systems stable, respond to incidents, reduce friction."),
         "SEC": Agent("SEC", "Security", "Sim-Local", *sp["SEC"], focus=0.70, reliability=0.93,
-                     skill={"security": 0.92, "ops": 0.62, "engineering": 0.55}),
+                    skill={"security": 0.92, "ops": 0.62, "engineering": 0.55},
+                    behavior_prompt="Minimize risk, enforce secure defaults, fail safely."),
         "DES": Agent("DES", "Designer", "Sim-GPT-4o", *sp["DES"], focus=0.74, reliability=0.87,
-                     skill={"design": 0.92, "product": 0.65}),
+                    skill={"design": 0.92, "product": 0.65},
+                    behavior_prompt="Increase usability, reduce cognitive load, ship coherent UX."),
     }
 
 
 # -----------------------------
-# Map builder (office / maze hybrid)
+# Map builder (customizable)
 # -----------------------------
-def build_office_map(seed: int) -> List[List[int]]:
+def build_map(seed: int, preset: str, wall_density: float, resource_density: float) -> List[List[int]]:
     r = make_rng(seed)
+    wall_density = clamp(float(wall_density), 0.05, 0.85)
+    resource_density = clamp(float(resource_density), 0.0, 0.25)
+
     g = [[EMPTY for _ in range(GRID_W)] for _ in range(GRID_H)]
 
     # borders
     for x in range(GRID_W):
         g[0][x] = WALL
-        g[GRID_H-1][x] = WALL
+        g[GRID_H - 1][x] = WALL
     for y in range(GRID_H):
         g[y][0] = WALL
-        g[y][GRID_W-1] = WALL
-
-    # add internal walls (corridors)
-    for x in range(3, GRID_W-3):
-        if x % 3 == 0:
-            for y in range(2, GRID_H-2):
-                if r.random() < 0.65:
+        g[y][GRID_W - 1] = WALL
+
+    if preset == "Office Corridors":
+        for x in range(3, GRID_W - 3):
+            if x % 3 == 0:
+                for y in range(2, GRID_H - 2):
+                    if r.random() < (0.45 + 0.4 * wall_density):
+                        g[y][x] = WALL
+        # carve openings
+        for _ in range(int(22 + 30 * (1 - wall_density))):
+            x = r.randint(2, GRID_W - 3)
+            y = r.randint(2, GRID_H - 3)
+            g[y][x] = EMPTY
+
+    elif preset == "Open Office":
+        # sparse walls
+        for _ in range(int((GRID_W * GRID_H) * (0.08 + 0.35 * wall_density))):
+            x = r.randint(2, GRID_W - 3)
+            y = r.randint(2, GRID_H - 3)
+            g[y][x] = WALL
+        # carve a few rooms
+        for _ in range(3):
+            x0 = r.randint(2, GRID_W - 10)
+            y0 = r.randint(2, GRID_H - 7)
+            w = r.randint(5, 9)
+            h = r.randint(4, 6)
+            for y in range(y0, y0 + h):
+                for x in range(x0, x0 + w):
+                    if x in (x0, x0 + w - 1) or y in (y0, y0 + h - 1):
+                        g[y][x] = WALL
+                    else:
+                        g[y][x] = EMPTY
+            # door
+            g[y0 + h // 2][x0] = EMPTY
+
+    else:  # "Warehouse Grid"
+        for y in range(2, GRID_H - 2):
+            for x in range(2, GRID_W - 2):
+                if (x % 4 == 0 and y % 2 == 0) and r.random() < (0.55 + 0.35 * wall_density):
                     g[y][x] = WALL
+        for _ in range(30):
+            x = r.randint(2, GRID_W - 3)
+            y = r.randint(2, GRID_H - 3)
+            g[y][x] = EMPTY
 
-    # carve some openings
-    for _ in range(28):
-        x = r.randint(2, GRID_W-3)
-        y = r.randint(2, GRID_H-3)
-        g[y][x] = EMPTY
-
-    # resource patches (like “data sources / infra nodes”)
-    for _ in range(10):
-        x = r.randint(2, GRID_W-3)
-        y = r.randint(2, GRID_H-3)
-        if g[y][x] == EMPTY:
-            g[y][x] = RESOURCE
+    # resources
+    for y in range(2, GRID_H - 2):
+        for x in range(2, GRID_W - 2):
+            if g[y][x] == EMPTY and r.random() < resource_density:
+                g[y][x] = RESOURCE
 
     return g
 
@@ -325,14 +390,23 @@ def tile_color(tile: int) -> str:
 # -----------------------------
 # Backlog -> task nodes on map
 # -----------------------------
-def generate_backlog(seed: int, n: int, difficulty: float, grid: List[List[int]]) -> List[Task]:
+def generate_backlog(seed: int, n: int, difficulty: float, grid: List[List[int]], skill_mix: str) -> List[Task]:
     r = make_rng(seed + 999)
-    skill_buckets = ["product", "engineering", "data", "ops", "security", "design"]
+
+    all_skills = ["product", "engineering", "data", "ops", "security", "design"]
+    if skill_mix == "Engineering-heavy":
+        skill_buckets = ["engineering", "engineering", "engineering", "data", "ops", "security"]
+    elif skill_mix == "Ops-heavy":
+        skill_buckets = ["ops", "ops", "ops", "security", "engineering", "product"]
+    elif skill_mix == "Balanced":
+        skill_buckets = all_skills
+    else:  # "Product-heavy"
+        skill_buckets = ["product", "product", "product", "design", "engineering", "ops"]
+
     verbs = ["Ship", "Audit", "Refactor", "Launch", "Scale", "Integrate", "Automate", "Harden", "Migrate", "Validate"]
     nouns = ["pipeline", "dashboard", "agent", "workflow", "integration", "report", "system", "KB", "API", "ledger"]
 
-    # choose empty cells to place task nodes
-    empties = [(x,y) for y in range(1, GRID_H-1) for x in range(1, GRID_W-1) if grid[y][x] == EMPTY]
+    empties = [(x, y) for y in range(1, GRID_H - 1) for x in range(1, GRID_W - 1) if grid[y][x] == EMPTY]
     r.shuffle(empties)
     nodes = empties[: max(n, 1)]
 
@@ -342,8 +416,8 @@ def generate_backlog(seed: int, n: int, difficulty: float, grid: List[List[int]]
         title = f"{r.choice(verbs)} {r.choice(nouns)} ({skill})"
         complexity = clamp(r.uniform(0.25, 1.25) * (0.85 + 0.6 * difficulty), 0.15, 2.0)
         risk = clamp(r.uniform(0.05, 0.35) * (0.7 + 0.8 * difficulty), 0.03, 0.75)
-
         xy = nodes[i] if i < len(nodes) else (2, 2)
+
         tasks.append(Task(
             id=f"T{i+1:03d}",
             title=title,
@@ -356,20 +430,26 @@ def generate_backlog(seed: int, n: int, difficulty: float, grid: List[List[int]]
 
 
 def place_task_nodes(grid: List[List[int]], tasks: List[Task]):
+    # clear old nodes/blockers
+    for y in range(GRID_H):
+        for x in range(GRID_W):
+            if grid[y][x] in (TASKNODE, BLOCKER):
+                grid[y][x] = EMPTY
+
     for t in tasks:
-        x,y = t.node_xy
-        if in_bounds(x,y) and grid[y][x] == EMPTY:
+        x, y = t.node_xy
+        if in_bounds(x, y) and grid[y][x] == EMPTY:
             grid[y][x] = TASKNODE
 
 
 # -----------------------------
-# Economics: tokens/cost/time
+# Economics
 # -----------------------------
 def agent_skill_score(a: Agent, skill: str) -> float:
     return float(a.skill.get(skill, 0.15))
 
 
-def estimate_tokens(task: Task, agent: Agent, difficulty: float, r: random.Random) -> Tuple[int,int]:
+def estimate_tokens(task: Task, agent: Agent, difficulty: float, r: random.Random) -> Tuple[int, int]:
     base = 900 + 2200 * task.complexity * (0.8 + 0.6 * difficulty)
     fit = agent_skill_score(agent, task.required_skill)
     efficiency = clamp(1.15 - 0.55 * fit, 0.55, 1.25)
@@ -377,31 +457,29 @@ def estimate_tokens(task: Task, agent: Agent, difficulty: float, r: random.Rando
     total = base * efficiency * noise
     tin = int(total * r.uniform(0.40, 0.55))
     tout = int(total - tin)
-    return max(1,tin), max(1,tout)
+    return max(1, tin), max(1, tout)
 
 
-def cost_from_tokens(model_profiles: Dict[str, Dict[str,float]], model: str, tin: int, tout: int) -> float:
+def cost_from_tokens(model_profiles: Dict[str, Dict[str, float]], model: str, tin: int, tout: int) -> float:
     prof = model_profiles.get(model, {"in_per_1m": 2.0, "out_per_1m": 6.0, "tps": 100.0})
-    return (tin/1_000_000.0)*float(prof["in_per_1m"]) + (tout/1_000_000.0)*float(prof["out_per_1m"])
+    return (tin / 1_000_000.0) * float(prof["in_per_1m"]) + (tout / 1_000_000.0) * float(prof["out_per_1m"])
 
 
-def wall_seconds_from_tokens(model_profiles: Dict[str, Dict[str,float]], model: str, tin: int, tout: int) -> float:
+def wall_seconds_from_tokens(model_profiles: Dict[str, Dict[str, float]], model: str, tin: int, tout: int) -> float:
     prof = model_profiles.get(model, {"tps": 100.0})
     tps = float(prof.get("tps", 100.0))
-    return float((tin+tout)/max(tps,1.0))
+    return float((tin + tout) / max(tps, 1.0))
 
 
 # -----------------------------
 # Task selection & progress
 # -----------------------------
 def pick_task_for_agent(w: World, agent: Agent) -> Optional[Task]:
-    # Keep current target if still relevant
     if agent.target_task_id:
         t = next((x for x in w.tasks if x.id == agent.target_task_id), None)
-        if t and t.status in ("todo","doing","blocked"):
+        if t and t.status in ("todo", "doing", "blocked"):
             return t
 
-    # Prefer doing owned
     doing_owned = [t for t in w.tasks if t.status == "doing" and t.owner == agent.name]
     if doing_owned:
         agent.target_task_id = doing_owned[0].id
@@ -425,12 +503,12 @@ def progress_delta(task: Task, agent: Agent, difficulty: float, r: random.Random
     base *= (0.75 + 0.5 * agent.focus)
     base *= (0.95 - 0.35 * clamp(agent.fatigue, 0.0, 1.0))
     base *= (1.05 - 0.55 * difficulty)
-    return clamp(base * r.uniform(0.85,1.15), 0.01, 0.28)
+    return clamp(base * r.uniform(0.85, 1.15), 0.01, 0.28)
 
 
 def maybe_incident(w: World, task: Task, agent: Agent, r: random.Random) -> Optional[str]:
-    p = task.risk * (0.6 + 0.9*w.incident_rate) * (0.75 + 0.9*(1.0-agent.reliability))
-    p *= (0.85 + 0.5*w.difficulty)
+    p = task.risk * (0.6 + 0.9 * w.incident_rate) * (0.75 + 0.9 * (1.0 - agent.reliability))
+    p *= (0.85 + 0.5 * w.difficulty)
     if r.random() < clamp(p, 0.01, 0.85):
         return r.choice([
             "Scope creep discovered",
@@ -448,20 +526,19 @@ def maybe_incident(w: World, task: Task, agent: Agent, r: random.Random) -> Opti
 # -----------------------------
 # Movement + environment effects
 # -----------------------------
-def move_step(w: World, a: Agent, target_xy: Tuple[int,int]):
-    tx,ty = target_xy
-    nxt = bfs_next_step(w.grid, (a.x,a.y), (tx,ty))
+def move_step(w: World, a: Agent, target_xy: Tuple[int, int]):
+    tx, ty = target_xy
+    nxt = bfs_next_step(w.grid, (a.x, a.y), (tx, ty))
     if nxt is None:
         return
-    nx,ny = nxt
-    a.ori = face_towards(a.x,a.y,a.ori,nx,ny)
-    if in_bounds(nx,ny) and not is_blocking(w.grid[ny][nx]):
-        a.x,a.y = nx,ny
+    nx, ny = nxt
+    a.ori = face_towards(a.x, a.y, a.ori, nx, ny)
+    if in_bounds(nx, ny) and not is_blocking(w.grid[ny][nx]):
+        a.x, a.y = nx, ny
 
 
 def apply_env_tile_effects(w: World, a: Agent):
     tile = w.grid[a.y][a.x]
-    # stepping on BLOCKER tile increases fatigue slightly (it’s “friction”)
     if tile == BLOCKER:
         a.fatigue = clamp(a.fatigue + 0.04, 0.0, 1.0)
         w.events.append(f"t={w.step}: {a.name} hit a blocker zone (+fatigue).")
@@ -504,7 +581,10 @@ def within_fov(ax: int, ay: int, ori: int, tx: int, ty: int, fov_deg: float = FO
 
 
 def raycast_pov(w: World, who: str) -> np.ndarray:
+    if who not in w.agents:
+        who = next(iter(w.agents.keys()))
     a = w.agents[who]
+
     img = np.zeros((VIEW_H, VIEW_W, 3), dtype=np.uint8)
     img[:, :] = SKY
     for y in range(VIEW_H // 2, VIEW_H):
@@ -548,7 +628,6 @@ def raycast_pov(w: World, who: str) -> np.ndarray:
 
         depth *= math.cos(ang - base)
         depth = max(depth, 0.001)
-
         h = int((VIEW_H * 0.92) / depth)
         y0 = max(0, VIEW_H // 2 - h // 2)
         y1 = min(VIEW_H - 1, VIEW_H // 2 + h // 2)
@@ -564,7 +643,7 @@ def raycast_pov(w: World, who: str) -> np.ndarray:
         col = (col * dim).astype(np.uint8)
         img[y0:y1, rx:rx + 1] = col
 
-    # show other agents as blocks if visible
+    # other agents as blocks
     for nm, other in w.agents.items():
         if nm == who:
             continue
@@ -590,7 +669,7 @@ def raycast_pov(w: World, who: str) -> np.ndarray:
         y1 = int(clamp(ymid + size // 2, 0, VIEW_H - 1))
 
         hexcol = AGENT_COLORS.get(nm, "#ffd17a").lstrip("#")
-        rgb = np.array([int(hexcol[i:i+2], 16) for i in (0,2,4)], dtype=np.uint8)
+        rgb = np.array([int(hexcol[i:i + 2], 16) for i in (0, 2, 4)], dtype=np.uint8)
         img[y0:y1, x0:x1] = rgb
 
     if w.overlay:
@@ -602,16 +681,14 @@ def raycast_pov(w: World, who: str) -> np.ndarray:
 
 
 # -----------------------------
-# SVG renderer (animated, smooth)
+# SVG renderer
 # -----------------------------
-def svg_render(w: World, highlight: Optional[Tuple[int,int]] = None) -> str:
-    # HUD summary
+def svg_render(w: World, highlight: Optional[Tuple[int, int]] = None) -> str:
     k = compute_kpis(w.run_log)
     done = sum(1 for t in w.tasks if t.status == "done")
-    doing = sum(1 for t in w.tasks if t.status == "doing")
     blocked = sum(1 for t in w.tasks if t.status == "blocked")
     headline = f"ZEN Orchestrator Arena • step={w.step} • sim={fmt_duration(w.sim_elapsed_seconds)} • done={done}/{len(w.tasks)} • blocked={blocked} • cost=${k.total_cost_usd:,.2f}"
-    detail = f"time/tick={fmt_duration(w.sim_seconds_per_tick)} • difficulty={w.difficulty:.2f} • incident_rate={w.incident_rate:.2f} • pov={w.pov_agent}"
+    detail = f"time/tick={fmt_duration(w.sim_seconds_per_tick)} • difficulty={w.difficulty:.2f} • incident_rate={w.incident_rate:.2f} • agents={len(w.agents)} • pov={w.pov_agent}"
 
     css = f"""
     <style>
@@ -650,7 +727,6 @@ def svg_render(w: World, highlight: Optional[Tuple[int,int]] = None) -> str:
         stroke: rgba(170,195,255,0.16);
         stroke-width: 1;
       }}
-      .dead {{ opacity: 0.22; filter: none; }}
       .banner {{ fill: rgba(255,255,255,0.08); }}
     </style>
     """
@@ -665,7 +741,6 @@ def svg_render(w: World, highlight: Optional[Tuple[int,int]] = None) -> str:
       <text class="hud hudSmall" x="18" y="50" font-size="12">{detail}</text>
     """]
 
-    # tiles
     for y in range(GRID_H):
         for x in range(GRID_W):
             t = w.grid[y][x]
@@ -673,23 +748,21 @@ def svg_render(w: World, highlight: Optional[Tuple[int,int]] = None) -> str:
             py = HUD_H + y * TILE
             svg.append(f'<rect class="tile" x="{px}" y="{py}" width="{TILE}" height="{TILE}" fill="{tile_color(t)}"/>')
 
-            # overlay glyphs
             if t == TASKNODE:
-                cx = px + TILE*0.5
-                cy = py + TILE*0.5
+                cx = px + TILE * 0.5
+                cy = py + TILE * 0.5
                 svg.append(f'<circle cx="{cx}" cy="{cy}" r="6" fill="rgba(0,0,0,0.35)"/>')
                 svg.append(f'<circle cx="{cx}" cy="{cy}" r="4" fill="{COL_TASK}"/>')
             elif t == RESOURCE:
-                cx = px + TILE*0.5
-                cy = py + TILE*0.5
+                cx = px + TILE * 0.5
+                cy = py + TILE * 0.5
                 svg.append(f'<rect x="{cx-5}" y="{cy-5}" width="10" height="10" rx="3" fill="{COL_RES}" opacity="0.95"/>')
             elif t == BLOCKER:
-                cx = px + TILE*0.5
-                cy = py + TILE*0.5
+                cx = px + TILE * 0.5
+                cy = py + TILE * 0.5
                 svg.append(f'<line x1="{cx-6}" y1="{cy-6}" x2="{cx+6}" y2="{cy+6}" stroke="rgba(0,0,0,0.45)" stroke-width="3"/>')
                 svg.append(f'<line x1="{cx-6}" y1="{cy+6}" x2="{cx+6}" y2="{cy-6}" stroke="rgba(0,0,0,0.45)" stroke-width="3"/>')
 
-    # gridlines
     for x in range(GRID_W + 1):
         px = x * TILE
         svg.append(f'<line class="gridline" x1="{px}" y1="{HUD_H}" x2="{px}" y2="{SVG_H}"/>')
@@ -697,7 +770,6 @@ def svg_render(w: World, highlight: Optional[Tuple[int,int]] = None) -> str:
         py = HUD_H + y * TILE
         svg.append(f'<line class="gridline" x1="0" y1="{py}" x2="{SVG_W}" y2="{py}"/>')
 
-    # highlight
     if highlight:
         hx, hy = highlight
         if in_bounds(hx, hy):
@@ -718,16 +790,18 @@ def svg_render(w: World, highlight: Optional[Tuple[int,int]] = None) -> str:
         """)
 
         dx, dy = DIRS[a.ori]
-        x2 = TILE/2 + dx*(TILE*0.32)
-        y2 = TILE/2 + dy*(TILE*0.32)
+        x2 = TILE / 2 + dx * (TILE * 0.32)
+        y2 = TILE / 2 + dy * (TILE * 0.32)
         svg.append(f'<line x1="{TILE/2}" y1="{TILE/2}" x2="{x2}" y2="{y2}" stroke="rgba(10,10,14,0.85)" stroke-width="4" stroke-linecap="round"/>')
 
-        badge_w = max(46, 10 * len(nm) * 0.62)
+        label = nm
+        badge_w = max(56, 8 * len(label) + 24)
         svg.append(f'<rect class="badge" x="{TILE/2 - badge_w/2}" y="{TILE*0.05}" rx="10" width="{badge_w}" height="16"/>')
-        svg.append(f'<text x="{TILE/2}" y="{TILE*0.05 + 12}" text-anchor="middle" font-size="10" fill="rgba(235,240,255,0.92)" font-family="ui-sans-serif, system-ui">{nm}</text>')
+        svg.append(f'<text x="{TILE/2}" y="{TILE*0.05 + 12}" text-anchor="middle" font-size="10" fill="rgba(235,240,255,0.92)" font-family="ui-sans-serif, system-ui">{label}</text>')
 
-        # tiny task indicator
-        if a.target_task_id:
+        if a.engine == "api":
+            svg.append(f'<circle cx="{TILE*0.86}" cy="{TILE*0.18}" r="5" fill="rgba(255,110,110,0.95)"/>')  # red dot = API agent
+        elif a.target_task_id:
             svg.append(f'<circle cx="{TILE*0.86}" cy="{TILE*0.18}" r="5" fill="rgba(110,180,255,0.95)"/>')
 
         svg.append("</g>")
@@ -737,7 +811,7 @@ def svg_render(w: World, highlight: Optional[Tuple[int,int]] = None) -> str:
 
 
 # -----------------------------
-# Business render (text panels)
+# Business render
 # -----------------------------
 def status_summary(w: World) -> str:
     k = compute_kpis(w.run_log)
@@ -748,7 +822,7 @@ def status_summary(w: World) -> str:
     return (
         f"step={w.step} | sim_elapsed={fmt_duration(w.sim_elapsed_seconds)} | tick={fmt_duration(w.sim_seconds_per_tick)}\n"
         f"tasks: done={done}/{len(w.tasks)} | doing={doing} | blocked={blocked} | todo={todo}\n"
-        f"ledger: actions={k.total_actions} | cost=${k.total_cost_usd:,.2f} | in={k.total_tokens_in:,} | out={k.total_tokens_out:,}"
+        f"agents={len(w.agents)} | actions={k.total_actions} | cost=${k.total_cost_usd:,.2f} | in={k.total_tokens_in:,} | out={k.total_tokens_out:,}"
     )
 
 
@@ -773,22 +847,22 @@ def kpi_text(w: World) -> str:
 
 
 def agents_table(w: World) -> str:
-    cols = ["name", "role", "model", "fatigue", "target"]
+    cols = ["name", "engine", "role", "model", "fatigue", "target", "api_slot"]
     rows = [cols]
     for a in w.agents.values():
-        rows.append([a.name, a.role, a.model, f"{a.fatigue:.2f}", a.target_task_id or "-"])
+        rows.append([a.name, a.engine, a.role, a.model, f"{a.fatigue:.2f}", a.target_task_id or "-", a.api_slot or "-"])
     widths = [max(len(str(r[i])) for r in rows) for i in range(len(cols))]
     out = []
     for i, r in enumerate(rows):
         out.append(" | ".join(str(r[j]).ljust(widths[j]) for j in range(len(cols))))
         if i == 0:
-            out.append("-+-".join("-"*w for w in widths))
+            out.append("-+-".join("-" * w for w in widths))
     return "\n".join(out)
 
 
 def tasks_table(w: World, limit: int = 24) -> str:
     order = {"blocked": 0, "doing": 1, "todo": 2, "done": 3}
-    ts = sorted(w.tasks, key=lambda t: (order.get(t.status,9), t.id))
+    ts = sorted(w.tasks, key=lambda t: (order.get(t.status, 9), t.id))
     cols = ["id", "status", "owner", "progress", "skill", "xy", "title"]
     rows = [cols]
     for t in ts[:limit]:
@@ -796,7 +870,7 @@ def tasks_table(w: World, limit: int = 24) -> str:
             t.id,
             t.status,
             t.owner or "-",
-            f"{t.progress*100:5.1f}%",
+            f"{t.progress * 100:5.1f}%",
             t.required_skill,
             f"({t.node_xy[0]},{t.node_xy[1]})",
             (t.title[:55] + "…") if len(t.title) > 56 else t.title,
@@ -806,55 +880,175 @@ def tasks_table(w: World, limit: int = 24) -> str:
     for i, r in enumerate(rows):
         out.append(" | ".join(str(r[j]).ljust(widths[j]) for j in range(len(cols))))
         if i == 0:
-            out.append("-+-".join("-"*w for w in widths))
+            out.append("-+-".join("-" * w for w in widths))
     return "\n".join(out)
 
 
 # -----------------------------
-# Exports
+# RUN DATA TABLE (in-app)
 # -----------------------------
-def export_jsonl(w: World) -> Tuple[str, bytes]:
-    buf = io.StringIO()
-    for e in w.run_log:
-        buf.write(json.dumps(e, ensure_ascii=False) + "\n")
-    return "zen_orchestrator_runlog.jsonl", buf.getvalue().encode("utf-8")
+RUNLOG_COLUMNS = [
+    "t", "agent", "engine", "role", "model", "action", "task_id",
+    "tokens_in", "tokens_out", "cost_usd", "wall_seconds", "sim_seconds",
+    "thought", "incident", "task_progress"
+]
 
 
-def export_csv(w: World) -> Tuple[str, bytes]:
+def runlog_df(w: World, last_n: int = 400) -> pd.DataFrame:
     if not w.run_log:
-        return "zen_orchestrator_ledger.csv", b""
-    fields = ["t","agent","role","model","action","task_id","task_title","tokens_in","tokens_out","cost_usd","wall_seconds","sim_seconds","difficulty"]
-    buf = io.StringIO()
-    wri = csv.DictWriter(buf, fieldnames=fields)
-    wri.writeheader()
-    for e in w.run_log:
-        wri.writerow({k: e.get(k) for k in fields})
-    return "zen_orchestrator_ledger.csv", buf.getvalue().encode("utf-8")
+        return pd.DataFrame(columns=RUNLOG_COLUMNS)
+
+    tail = w.run_log[-int(max(1, last_n)):]
+    rows = []
+    for e in tail:
+        row = {c: e.get(c) for c in RUNLOG_COLUMNS}
+        # cost format
+        if row.get("cost_usd") is not None:
+            try:
+                row["cost_usd"] = float(row["cost_usd"])
+            except Exception:
+                pass
+        rows.append(row)
+
+    df = pd.DataFrame(rows, columns=RUNLOG_COLUMNS)
+    if not df.empty:
+        df["cost_usd"] = df["cost_usd"].fillna(0.0).astype(float).round(6)
+    return df
+
+
+# -----------------------------
+# File exports (disk files -> DownloadButton)
+# -----------------------------
+def write_runlog_jsonl_file(w: World) -> str:
+    fd, path = tempfile.mkstemp(prefix="zen_runlog_", suffix=".jsonl")
+    os.close(fd)
+    with open(path, "w", encoding="utf-8") as f:
+        for e in w.run_log:
+            f.write(json.dumps(e, ensure_ascii=False) + "\n")
+    return path
+
+
+def write_ledger_csv_file(w: World) -> str:
+    fd, path = tempfile.mkstemp(prefix="zen_ledger_", suffix=".csv")
+    os.close(fd)
+    fields = ["t", "agent", "engine", "role", "model", "action", "task_id", "task_title",
+              "tokens_in", "tokens_out", "cost_usd", "wall_seconds", "sim_seconds", "difficulty"]
+    with open(path, "w", newline="", encoding="utf-8") as f:
+        wri = csv.DictWriter(f, fieldnames=fields)
+        wri.writeheader()
+        for e in w.run_log:
+            wri.writerow({k: e.get(k) for k in fields})
+    return path
+
+
+# -----------------------------
+# API Agent support (OpenAI-compatible, stdlib only)
+# Note: Uses urllib to avoid adding dependencies.
+# -----------------------------
+def openai_compat_chat(slot: ApiKeySlot, messages: List[Dict[str, str]]) -> Tuple[str, int, int]:
+    """
+    Returns: (assistant_text, tokens_in_est, tokens_out_est)
+    Token counts are approximate (we don't have tiktoken); good enough for sim.
+    """
+    import urllib.request
+
+    url = slot.base_url.rstrip("/") + "/chat/completions"
+    payload = {
+        "model": slot.model,
+        "messages": messages,
+        "temperature": float(slot.temperature),
+        "max_tokens": int(slot.max_output_tokens),
+    }
+    data = json.dumps(payload).encode("utf-8")
+
+    req = urllib.request.Request(url, data=data, method="POST")
+    req.add_header("Content-Type", "application/json")
+    if slot.api_key:
+        req.add_header("Authorization", f"Bearer {slot.api_key}")
+
+    try:
+        with urllib.request.urlopen(req, timeout=25) as resp:
+            raw = resp.read().decode("utf-8", errors="replace")
+        j = json.loads(raw)
+        text = j["choices"][0]["message"]["content"]
+    except Exception as ex:
+        text = f"[API_ERROR] {type(ex).__name__}: {ex}"
+
+    # crude token est: ~4 chars/token (varies by language); good enough for billing estimates
+    joined_in = " ".join(m.get("content", "") for m in messages)
+    tin = max(1, int(len(joined_in) / 4))
+    tout = max(1, int(len(text) / 4))
+    return text, tin, tout
+
+
+def make_agent_decision_with_api(w: World, a: Agent, task: Task) -> Tuple[str, str]:
+    """
+    Uses scenario_prompt + agent.behavior_prompt + task details.
+    Returns: (action, thought)
+    """
+    slot = w.api_slots.get(a.api_slot or "")
+    if not slot:
+        return "work", "No API slot configured; falling back."
+
+    sys = slot.system_prompt.strip() or "You are an agent in a simulation."
+    scenario = w.scenario_prompt.strip()
+    beh = a.behavior_prompt.strip()
+    task_desc = (
+        f"Task: {task.id} | {task.title}\n"
+        f"Required skill: {task.required_skill}\n"
+        f"Status: {task.status} | Progress: {task.progress:.2f}\n"
+        f"Notes: {task.notes or 'None'}\n"
+        f"Difficulty: {w.difficulty:.2f} | IncidentRate: {w.incident_rate:.2f}\n"
+    )
+
+    user = (
+        f"Scenario Context:\n{scenario}\n\n"
+        f"Agent Role: {a.role} ({a.name})\n"
+        f"Agent Behavior:\n{beh or '(none)'}\n\n"
+        f"{task_desc}\n"
+        "Return JSON with keys: action (move|work|unblock|idle), thought (short).\n"
+        "Be realistic and concise."
+    )
+
+    messages = [
+        {"role": "system", "content": sys},
+        {"role": "user", "content": user},
+    ]
+    txt, tin, tout = openai_compat_chat(slot, messages)
+
+    # parse JSON if possible
+    action = "work"
+    thought = txt.strip()
+    try:
+        j = json.loads(txt)
+        action = str(j.get("action", "work")).strip()
+        thought = str(j.get("thought", "")).strip() or thought
+    except Exception:
+        # keep raw
+        pass
+
+    # store token estimates to world event? we’ll return them via caller’s log fields
+    return action, thought
 
 
 # -----------------------------
-# Core sim tick (movement + work)
+# Core sim tick
 # -----------------------------
 def tick(w: World, r: random.Random):
     if w.done:
         return
 
-    # Stop condition
     if all(t.status == "done" for t in w.tasks):
         w.done = True
         w.events.append(f"t={w.step}: DONE — all tasks completed.")
         return
 
-    t0 = time.perf_counter()
-
-    # Each agent: move toward task node; if on node, work / unblock / incident
-    for name, a in w.agents.items():
+    for name, a in list(w.agents.items()):
         task = pick_task_for_agent(w, a)
 
         if task is None:
-            # idle
             w.run_log.append({
-                "t": w.step, "agent": name, "role": a.role, "model": a.model,
+                "t": w.step, "agent": name, "engine": a.engine, "role": a.role, "model": a.model,
                 "action": "idle",
                 "thought": "No task available; monitoring and waiting.",
                 "task_id": None, "task_title": None,
@@ -866,23 +1060,45 @@ def tick(w: World, r: random.Random):
             })
             continue
 
-        # Start
+        # start
         if task.status == "todo":
             task.status = "doing"
             task.owner = name
             w.events.append(f"t={w.step}: {name} started {task.id} — {task.title}")
 
-        # Move toward the task node
         tx, ty = task.node_xy
+
+        # decide (api agents can suggest intent; sim agents follow deterministic logic)
+        desired = None
+        api_thought = None
+        api_tokens = (0, 0)
+        if a.engine == "api" and a.api_slot:
+            action, thought = make_agent_decision_with_api(w, a, task)
+            api_thought = thought
+            desired = action
+
+        # movement: if not on node, always move (unless API insists idle)
         if (a.x, a.y) != (tx, ty):
+            if desired == "idle":
+                w.run_log.append({
+                    "t": w.step, "agent": name, "engine": a.engine, "role": a.role, "model": a.model,
+                    "action": "idle",
+                    "thought": api_thought or f"Waiting before moving toward {task.id}.",
+                    "task_id": task.id, "task_title": task.title,
+                    "tokens_in": 12, "tokens_out": 8,
+                    "cost_usd": cost_from_tokens(w.model_profiles, a.model, 12, 8),
+                    "wall_seconds": 0.01,
+                    "sim_seconds": w.sim_seconds_per_tick,
+                    "difficulty": w.difficulty,
+                })
+                continue
+
             move_step(w, a, (tx, ty))
             apply_env_tile_effects(w, a)
-
-            # movement log (cheap)
             w.run_log.append({
-                "t": w.step, "agent": name, "role": a.role, "model": a.model,
+                "t": w.step, "agent": name, "engine": a.engine, "role": a.role, "model": a.model,
                 "action": "move",
-                "thought": f"Navigating toward {task.id} node at ({tx},{ty}).",
+                "thought": api_thought or f"Navigating toward {task.id} at ({tx},{ty}).",
                 "task_id": task.id, "task_title": task.title,
                 "tokens_in": 10, "tokens_out": 5,
                 "cost_usd": cost_from_tokens(w.model_profiles, a.model, 10, 5),
@@ -892,61 +1108,66 @@ def tick(w: World, r: random.Random):
             })
             continue
 
-        # On node: do work
+        # on node: handle blocked/unblock, incidents, work
         incident = maybe_incident(w, task, a, r)
+
+        # token/cost estimate
         tin, tout = estimate_tokens(task, a, w.difficulty, r)
         wall_s = wall_seconds_from_tokens(w.model_profiles, a.model, tin, tout)
         cost = cost_from_tokens(w.model_profiles, a.model, tin, tout)
 
-        if task.status == "blocked":
-            # unblock attempt
-            unblock = clamp(0.03 + 0.10*agent_skill_score(a, task.required_skill), 0.02, 0.18) * r.uniform(0.85, 1.1)
+        # if api agent, treat its response as “more expensive” by default (still uses our pricing profile)
+        thought = api_thought or f"Advancing {task.id}: execute, validate, document."
+        action = desired or "work"
+
+        if task.status == "blocked" or action == "unblock":
+            unblock = clamp(0.03 + 0.10 * agent_skill_score(a, task.required_skill), 0.02, 0.18) * r.uniform(0.85, 1.1)
             task.progress = clamp(task.progress + unblock, 0.0, 1.0)
             if task.progress >= 0.35:
                 task.status = "doing"
                 task.notes = ""
-                # clear blocker tile visually
-                x,y = task.node_xy
+                x, y = task.node_xy
                 if w.grid[y][x] == BLOCKER:
                     w.grid[y][x] = TASKNODE
                 w.events.append(f"t={w.step}: {name} unblocked {task.id}")
 
             w.run_log.append({
-                "t": w.step, "agent": name, "role": a.role, "model": a.model,
+                "t": w.step, "agent": name, "engine": a.engine, "role": a.role, "model": a.model,
                 "action": "unblock",
-                "thought": f"Resolving blocker on {task.id}: clarify deps, reduce ambiguity, reroute plan.",
+                "thought": thought,
                 "task_id": task.id, "task_title": task.title,
                 "tokens_in": tin, "tokens_out": tout,
                 "cost_usd": cost,
                 "wall_seconds": wall_s,
                 "sim_seconds": w.sim_seconds_per_tick,
                 "difficulty": w.difficulty,
+                "task_progress": task.progress,
             })
             a.fatigue = clamp(a.fatigue + 0.03, 0.0, 1.0)
             continue
 
         if incident is not None:
-            regress = clamp(r.uniform(0.04, 0.16) * (0.7 + 0.8*w.difficulty), 0.02, 0.22)
+            regress = clamp(r.uniform(0.04, 0.16) * (0.7 + 0.8 * w.difficulty), 0.02, 0.22)
             task.progress = clamp(task.progress - regress, 0.0, 1.0)
             if r.random() < 0.50:
                 task.status = "blocked"
                 task.notes = incident
-                # mark blocker visually at node
-                x,y = task.node_xy
+                x, y = task.node_xy
                 w.grid[y][x] = BLOCKER
 
             w.events.append(f"t={w.step}: INCIDENT on {task.id} ({name}) — {incident}")
             w.run_log.append({
-                "t": w.step, "agent": name, "role": a.role, "model": a.model,
+                "t": w.step, "agent": name, "engine": a.engine, "role": a.role, "model": a.model,
                 "action": "incident_response",
-                "thought": f"Incident '{incident}' detected. Triaging, mitigating, and adjusting plan.",
+                "thought": thought if api_thought else f"Incident '{incident}' detected. Triaging + mitigating.",
                 "task_id": task.id, "task_title": task.title,
-                "tokens_in": int(tin*1.05), "tokens_out": int(tout*1.05),
-                "cost_usd": float(cost*1.08),
-                "wall_seconds": float(wall_s*1.10),
+                "tokens_in": int(tin * 1.05), "tokens_out": int(tout * 1.05),
+                "cost_usd": float(cost * 1.08),
+                "wall_seconds": float(wall_s * 1.10),
                 "sim_seconds": w.sim_seconds_per_tick,
                 "difficulty": w.difficulty,
                 "incident": incident,
+                "task_progress": task.progress,
             })
             a.fatigue = clamp(a.fatigue + 0.06, 0.0, 1.0)
             continue
@@ -957,14 +1178,13 @@ def tick(w: World, r: random.Random):
         if task.progress >= 1.0:
             task.status = "done"
             w.events.append(f"t={w.step}: ✅ {task.id} completed by {name}")
-            # remove node visually after completion for “clearing the board”
-            x,y = task.node_xy
+            x, y = task.node_xy
             w.grid[y][x] = EMPTY
 
         w.run_log.append({
-            "t": w.step, "agent": name, "role": a.role, "model": a.model,
+            "t": w.step, "agent": name, "engine": a.engine, "role": a.role, "model": a.model,
             "action": "work",
-            "thought": f"Advancing {task.id}: execute, validate, document.",
+            "thought": thought,
             "task_id": task.id, "task_title": task.title,
             "tokens_in": tin, "tokens_out": tout,
             "cost_usd": cost,
@@ -973,46 +1193,37 @@ def tick(w: World, r: random.Random):
             "difficulty": w.difficulty,
             "task_progress": task.progress,
         })
-        a.fatigue = clamp(a.fatigue + 0.02*(0.7 + 0.6*w.difficulty), 0.0, 1.0)
+        a.fatigue = clamp(a.fatigue + 0.02 * (0.7 + 0.6 * w.difficulty), 0.0, 1.0)
 
     # camera cuts
-    if w.auto_camera:
-        # choose “most interesting” = highest fatigue or currently blocked task owner
+    if w.auto_camera and w.agents:
         best, best_score = w.pov_agent, -1e9
         blocked_owners = set(t.owner for t in w.tasks if t.status == "blocked" and t.owner)
         for nm, a in w.agents.items():
-            score = 0.0
-            score += a.fatigue * 10.0
-            if nm in blocked_owners:
-                score += 4.0
+            score = a.fatigue * 10.0 + (4.0 if nm in blocked_owners else 0.0)
             if score > best_score:
                 best, best_score = nm, score
         w.pov_agent = best
 
-    # Recovery drift
+    # recovery drift
     for a in w.agents.values():
         a.fatigue = clamp(a.fatigue - 0.01, 0.0, 1.0)
 
-    # advance time
     w.sim_elapsed_seconds += w.sim_seconds_per_tick
     w.step += 1
 
-    # event cadence
-    wall_total = time.perf_counter() - t0
-    if w.step % 10 == 0:
-        w.events.append(f"t={w.step}: tick wall={wall_total:.3f}s | sim_elapsed={fmt_duration(w.sim_elapsed_seconds)}")
-
-    if len(w.events) > 260:
-        w.events = w.events[-260:]
+    if len(w.events) > 320:
+        w.events = w.events[-320:]
 
 
 # -----------------------------
 # Init world
 # -----------------------------
-def init_world(seed: int, sim_seconds_per_tick: float, difficulty: float, incident_rate: float, max_parallel: int, backlog_size: int) -> World:
-    grid = build_office_map(seed)
+def init_world(seed: int, sim_seconds_per_tick: float, difficulty: float, incident_rate: float, max_parallel: int,
+               backlog_size: int, map_preset: str, wall_density: float, resource_density: float, skill_mix: str) -> World:
+    grid = build_map(seed, map_preset, wall_density, resource_density)
     agents = default_agents()
-    tasks = generate_backlog(seed, backlog_size, difficulty, grid)
+    tasks = generate_backlog(seed, backlog_size, difficulty, grid, skill_mix)
     place_task_nodes(grid, tasks)
 
     w = World(
@@ -1029,147 +1240,234 @@ def init_world(seed: int, sim_seconds_per_tick: float, difficulty: float, incide
         pov_agent="ENG",
         overlay=True,
         auto_camera=True,
+        scenario_prompt="Run a realistic office execution cycle: prioritize critical work, mitigate incidents, and finish tasks.",
         model_profiles=json.loads(json.dumps(DEFAULT_MODEL_PROFILES)),
+        api_slots={
+            "KEYSLOT_A": ApiKeySlot(slot_name="KEYSLOT_A"),
+            "KEYSLOT_B": ApiKeySlot(slot_name="KEYSLOT_B"),
+        },
         events=[f"Initialized: seed={seed} | time/tick={fmt_duration(sim_seconds_per_tick)} | difficulty={difficulty:.2f}"],
     )
     return w
 
 
 # -----------------------------
-# UI update + actions
+# UI refresh
 # -----------------------------
-def ui_refresh(w: World, highlight: Optional[Tuple[int,int]] = None):
+def ui_refresh(w: World, highlight: Optional[Tuple[int, int]], runlog_rows: int):
     arena = svg_render(w, highlight)
     pov = raycast_pov(w, w.pov_agent)
     status = status_summary(w)
     agents_txt = agents_table(w)
     tasks_txt = tasks_table(w)
-    events_txt = "\n".join(w.events[-24:])
+    events_txt = "\n".join(w.events[-30:])
     kpis_txt = kpi_text(w)
-    return arena, pov, status, agents_txt, tasks_txt, events_txt, kpis_txt
+    df = runlog_df(w, last_n=int(runlog_rows))
+    return arena, pov, status, agents_txt, tasks_txt, events_txt, kpis_txt, df
 
 
-def ui_reset(seed: int, sim_preset: str, difficulty: float, incident_rate: float, max_parallel: int, backlog_size: int):
-    sim_seconds = SIM_TIME_PRESETS.get(sim_preset, 7*24*3600)
-    w = init_world(int(seed), float(sim_seconds), float(difficulty), float(incident_rate), int(max_parallel), int(backlog_size))
-    return (*ui_refresh(w, None), w, None)
+# -----------------------------
+# Actions
+# -----------------------------
+def ui_reset(seed: int, sim_preset: str, difficulty: float, incident_rate: float, max_parallel: int, backlog_size: int,
+             map_preset: str, wall_density: float, resource_density: float, skill_mix: str, runlog_rows: int):
+    sim_seconds = SIM_TIME_PRESETS.get(sim_preset, 7 * 24 * 3600)
+    w = init_world(int(seed), float(sim_seconds), float(difficulty), float(incident_rate), int(max_parallel), int(backlog_size),
+                   map_preset, float(wall_density), float(resource_density), skill_mix)
+    return (*ui_refresh(w, None, runlog_rows), w, None)
 
 
-def ui_run(w: World, highlight, n: int):
-    r = make_rng(w.seed + w.step*31)
+def ui_run(w: World, highlight, n: int, runlog_rows: int):
+    r = make_rng(w.seed + w.step * 31)
     for _ in range(max(1, int(n))):
         if w.done:
             break
         tick(w, r)
-    return (*ui_refresh(w, highlight), w, highlight)
+    return (*ui_refresh(w, highlight, runlog_rows), w, highlight)
 
 
-def ui_inject_incident(w: World, highlight, task_id: str, note: str):
+def ui_inject_incident(w: World, highlight, task_id: str, note: str, runlog_rows: int):
     t = next((x for x in w.tasks if x.id == task_id.strip()), None)
     if not t:
         w.events.append(f"t={w.step}: inject failed — {task_id} not found.")
-        return (*ui_refresh(w, highlight), w, highlight)
+        return (*ui_refresh(w, highlight, runlog_rows), w, highlight)
 
     t.status = "blocked"
     t.notes = note.strip() or "Injected incident"
-    x,y = t.node_xy
+    x, y = t.node_xy
     if w.grid[y][x] in (TASKNODE, EMPTY):
         w.grid[y][x] = BLOCKER
 
     w.events.append(f"t={w.step}: 🔥 INJECTED INCIDENT on {t.id} — {t.notes}")
     w.run_log.append({
-        "t": w.step, "agent": "SYSTEM", "role": "Simulator", "model": "n/a",
+        "t": w.step, "agent": "SYSTEM", "engine": "sim", "role": "Simulator", "model": "n/a",
         "action": "inject_incident",
         "thought": "User injected an incident to stress-test orchestration.",
         "task_id": t.id, "task_title": t.title,
         "tokens_in": 0, "tokens_out": 0, "cost_usd": 0.0, "wall_seconds": 0.0,
         "sim_seconds": 0.0, "difficulty": w.difficulty,
         "incident": t.notes,
+        "task_progress": t.progress,
     })
-    # highlight the node
     highlight = t.node_xy
-    return (*ui_refresh(w, highlight), w, highlight)
+    return (*ui_refresh(w, highlight, runlog_rows), w, highlight)
 
 
-def ui_set_overlay(w: World, highlight, v: bool):
+def ui_set_overlay(w: World, highlight, v: bool, runlog_rows: int):
     w.overlay = bool(v)
-    return (*ui_refresh(w, highlight), w, highlight)
+    return (*ui_refresh(w, highlight, runlog_rows), w, highlight)
 
 
-def ui_set_autocam(w: World, highlight, v: bool):
+def ui_set_autocam(w: World, highlight, v: bool, runlog_rows: int):
     w.auto_camera = bool(v)
     w.events.append(f"t={w.step}: auto_camera={w.auto_camera}")
-    return (*ui_refresh(w, highlight), w, highlight)
+    return (*ui_refresh(w, highlight, runlog_rows), w, highlight)
 
 
-def ui_set_pov(w: World, highlight, who: str):
+def ui_set_pov(w: World, highlight, who: str, runlog_rows: int):
     if who in w.agents:
         w.pov_agent = who
         w.events.append(f"t={w.step}: POV -> {who}")
-    return (*ui_refresh(w, highlight), w, highlight)
+    return (*ui_refresh(w, highlight, runlog_rows), w, highlight)
+
+
+def ui_update_scenario_prompt(w: World, highlight, scenario: str, runlog_rows: int):
+    w.scenario_prompt = (scenario or "").strip()
+    w.events.append(f"t={w.step}: scenario_prompt updated.")
+    return (*ui_refresh(w, highlight, runlog_rows), w, highlight)
+
+
+# ---- Map & task regeneration (without full reset)
+def ui_regen_map(w: World, highlight, map_preset: str, wall_density: float, resource_density: float, runlog_rows: int):
+    w.grid = build_map(w.seed + w.step, map_preset, wall_density, resource_density)
+    # re-place task nodes where tasks want to be; if invalid, keep tasks but drop nodes
+    place_task_nodes(w.grid, w.tasks)
+    w.events.append(f"t={w.step}: regenerated map preset={map_preset} wall_density={wall_density:.2f} resource_density={resource_density:.2f}")
+    return (*ui_refresh(w, highlight, runlog_rows), w, highlight)
+
+
+def ui_regen_tasks(w: World, highlight, backlog_size: int, skill_mix: str, runlog_rows: int):
+    w.tasks = generate_backlog(w.seed + w.step, int(backlog_size), w.difficulty, w.grid, skill_mix)
+    place_task_nodes(w.grid, w.tasks)
+    w.events.append(f"t={w.step}: regenerated tasks size={backlog_size} mix={skill_mix}")
+    return (*ui_refresh(w, highlight, runlog_rows), w, highlight)
+
+
+# ---- Add agents
+def _unique_agent_name(existing: set, base: str) -> str:
+    base = base.strip() or "A"
+    if base not in existing:
+        return base
+    i = 2
+    while f"{base}{i}" in existing:
+        i += 1
+    return f"{base}{i}"
+
+
+def ui_add_agents(w: World, highlight, count: int, base_name: str, role: str, engine: str,
+                  api_slot: str, model_name: str, behavior_prompt: str,
+                  runlog_rows: int):
+    count = int(max(1, count))
+    existing = set(w.agents.keys())
+
+    # enforce API slot cap (10)
+    if engine == "api":
+        slot = w.api_slots.get(api_slot)
+        if not slot:
+            w.events.append(f"t={w.step}: add_agents failed — unknown api_slot {api_slot}")
+            return (*ui_refresh(w, highlight, runlog_rows), w, highlight)
+
+        available = max(0, 10 - slot.agents_using)
+        if available <= 0:
+            w.events.append(f"t={w.step}: add_agents blocked — {api_slot} already has 10 agents.")
+            return (*ui_refresh(w, highlight, runlog_rows), w, highlight)
+
+        count = min(count, available)
+
+    # spawn near a corner but not on walls
+    spx, spy = 2, 2
+    if len(w.agents) % 2 == 1:
+        spx, spy = GRID_W - 3, GRID_H - 3
+
+    for _ in range(count):
+        nm = _unique_agent_name(existing, base_name)
+        existing.add(nm)
+
+        a = Agent(
+            name=nm,
+            role=role.strip() or "Custom Agent",
+            model=("API-LLM" if engine == "api" else (model_name.strip() or "Sim-GPT-4o")),
+            x=spx,
+            y=spy,
+            focus=0.75,
+            reliability=0.86,
+            skill={
+                "engineering": 0.55,
+                "data": 0.55,
+                "product": 0.55,
+                "ops": 0.55,
+                "security": 0.55,
+                "design": 0.55,
+            },
+            behavior_prompt=(behavior_prompt or "").strip(),
+            engine=engine,
+            api_slot=(api_slot if engine == "api" else None),
+        )
+        w.agents[nm] = a
 
+        if engine == "api":
+            w.api_slots[api_slot].agents_using += 1
 
-def ui_set_agent_model(w: World, highlight, who: str, model: str):
-    if who in w.agents and model in w.model_profiles:
-        w.agents[who].model = model
-        w.events.append(f"t={w.step}: {who} model -> {model}")
-    return (*ui_refresh(w, highlight), w, highlight)
+        w.events.append(f"t={w.step}: added agent {nm} (engine={engine}, role={a.role})")
 
+    return (*ui_refresh(w, highlight, runlog_rows), w, highlight)
 
-def ui_update_model_price(w: World, highlight, model: str, in_per_1m: float, out_per_1m: float, tps: float):
-    if model not in w.model_profiles:
-        w.model_profiles[model] = {"in_per_1m": 2.0, "out_per_1m": 6.0, "tps": 100.0}
-    w.model_profiles[model]["in_per_1m"] = float(max(0.0, in_per_1m))
-    w.model_profiles[model]["out_per_1m"] = float(max(0.0, out_per_1m))
-    w.model_profiles[model]["tps"] = float(max(1.0, tps))
-    w.events.append(f"t={w.step}: pricing updated for {model}")
-    return (*ui_refresh(w, highlight), w, highlight)
 
+# ---- Configure API slot
+def ui_save_api_slot(w: World, highlight,
+                     slot_name: str, base_url: str, api_key: str, model: str,
+                     temperature: float, max_output_tokens: int, system_prompt: str,
+                     runlog_rows: int):
+    slot = w.api_slots.get(slot_name)
+    if not slot:
+        w.api_slots[slot_name] = ApiKeySlot(slot_name=slot_name)
+        slot = w.api_slots[slot_name]
 
-def ui_download_jsonl(w: World):
-    name, data = export_jsonl(w)
-    return gr.File.update(value=(name, data))
+    slot.base_url = (base_url or "").strip() or "https://api.openai.com/v1"
+    slot.api_key = (api_key or "").strip()  # stored only in state
+    slot.model = (model or "").strip() or "gpt-4o-mini"
+    slot.temperature = float(clamp(float(temperature), 0.0, 2.0))
+    slot.max_output_tokens = int(clamp(int(max_output_tokens), 16, 1200))
+    slot.system_prompt = (system_prompt or "").strip() or slot.system_prompt
 
+    # pricing profile for API agents (optional)
+    if "API-LLM" not in w.model_profiles:
+        w.model_profiles["API-LLM"] = {"in_per_1m": 5.00, "out_per_1m": 15.00, "tps": 120.0}
 
-def ui_download_csv(w: World):
-    name, data = export_csv(w)
-    return gr.File.update(value=(name, data))
+    masked = ("(set)" if slot.api_key else "(empty)")
+    w.events.append(f"t={w.step}: saved {slot_name} base_url={slot.base_url} model={slot.model} api_key={masked}")
+    return (*ui_refresh(w, highlight, runlog_rows), w, highlight)
 
 
-# -----------------------------
-# Exports helpers
-# -----------------------------
-def export_jsonl(w: World) -> Tuple[str, bytes]:
-    buf = io.StringIO()
-    for e in w.run_log:
-        buf.write(json.dumps(e, ensure_ascii=False) + "\n")
-    return "zen_orchestrator_runlog.jsonl", buf.getvalue().encode("utf-8")
+# ---- Downloads (these now work reliably)
+def ui_download_jsonl(w: World) -> str:
+    return write_runlog_jsonl_file(w)
 
 
-def export_csv(w: World) -> Tuple[str, bytes]:
-    if not w.run_log:
-        return "zen_orchestrator_ledger.csv", b""
-    fields = ["t","agent","role","model","action","task_id","task_title","tokens_in","tokens_out","cost_usd","wall_seconds","sim_seconds","difficulty"]
-    buf = io.StringIO()
-    wri = csv.DictWriter(buf, fieldnames=fields)
-    wri.writeheader()
-    for e in w.run_log:
-        wri.writerow({k: e.get(k) for k in fields})
-    return "zen_orchestrator_ledger.csv", buf.getvalue().encode("utf-8")
+def ui_download_csv(w: World) -> str:
+    return write_ledger_csv_file(w)
 
 
 # -----------------------------
-# Gradio UI
+# UI
 # -----------------------------
-TITLE = "ZEN Orchestrator Arena — Visual Agent Orchestra + KPIs"
+TITLE = "ZEN Orchestrator Arena — Visual Agents + Run Data"
 
 with gr.Blocks(title=TITLE) as demo:
     gr.Markdown(
         f"## {TITLE}\n"
-        "This is the hybrid you wanted: **visual world + business telemetry**.\n"
-        "- Agents move through the environment to task nodes\n"
-        "- Actions generate **logs, costs, tokens, time**, and KPI rollups\n"
-        "- Inject incidents to watch the orchestra reroute and recover\n"
+        "Now the **Run Data is always visible in-app** (scrollable table), and downloads are done via **real files**.\n"
+        "You can also add unlimited agents, including API-driven agents (OpenAI-compatible) with **1 key slot powering up to 10 agents**.\n"
     )
 
     w0 = init_world(
@@ -1179,11 +1477,14 @@ with gr.Blocks(title=TITLE) as demo:
         incident_rate=0.35,
         max_parallel=3,
         backlog_size=24,
+        map_preset="Office Corridors",
+        wall_density=0.55,
+        resource_density=0.06,
+        skill_mix="Balanced",
     )
 
     w_state = gr.State(w0)
     highlight_state = gr.State(None)
-
     autoplay_on = gr.State(False)
     timer = gr.Timer(value=0.18, active=False)
 
@@ -1207,10 +1508,32 @@ with gr.Blocks(title=TITLE) as demo:
             difficulty = gr.Slider(0.0, 1.0, value=0.55, step=0.01, label="Difficulty")
             incident_rate = gr.Slider(0.0, 1.0, value=0.35, step=0.01, label="Incident Rate")
         with gr.Row():
-            max_parallel = gr.Slider(1, 8, value=3, step=1, label="Max parallel tasks")
-            backlog_size = gr.Slider(8, 80, value=24, step=1, label="Backlog size")
+            max_parallel = gr.Slider(1, 12, value=3, step=1, label="Max parallel tasks")
+            backlog_size = gr.Slider(8, 120, value=24, step=1, label="Backlog size")
+            skill_mix = gr.Dropdown(["Balanced", "Engineering-heavy", "Ops-heavy", "Product-heavy"], value="Balanced", label="Task skill mix")
             btn_reset = gr.Button("Reset Scenario")
 
+        scenario_prompt = gr.Textbox(
+            value=w0.scenario_prompt,
+            label="Scenario Context Prompt (global)",
+            lines=4,
+            placeholder="Give context like: 'We are a startup racing to ship an agent sim product. Optimize for speed, realism, and clean logs.'",
+        )
+        btn_save_scenario = gr.Button("Save Scenario Prompt")
+
+    with gr.Accordion("Office Setup (Map)", open=False):
+        with gr.Row():
+            map_preset = gr.Dropdown(["Office Corridors", "Open Office", "Warehouse Grid"], value="Office Corridors", label="Map preset")
+            wall_density = gr.Slider(0.05, 0.85, value=0.55, step=0.01, label="Wall density")
+            resource_density = gr.Slider(0.0, 0.25, value=0.06, step=0.01, label="Resource density")
+            btn_regen_map = gr.Button("Regenerate Map (keep run)")
+
+    with gr.Accordion("Tasks (Regenerate)", open=False):
+        with gr.Row():
+            regen_backlog_size = gr.Slider(8, 200, value=24, step=1, label="New backlog size")
+            regen_skill_mix = gr.Dropdown(["Balanced", "Engineering-heavy", "Ops-heavy", "Product-heavy"], value="Balanced", label="New skill mix")
+            btn_regen_tasks = gr.Button("Regenerate Tasks (keep run)")
+
     with gr.Accordion("Autoplay / Run", open=True):
         autoplay_speed = gr.Slider(0.05, 0.8, value=0.18, step=0.01, label="Autoplay tick interval (sec)")
         with gr.Row():
@@ -1225,99 +1548,167 @@ with gr.Blocks(title=TITLE) as demo:
     with gr.Accordion("Camera & Visuals", open=False):
         overlay = gr.Checkbox(value=True, label="POV Overlay Reticle")
         auto_camera = gr.Checkbox(value=True, label="Auto Camera Cuts")
-        pov_pick = gr.Dropdown(choices=list(default_agents().keys()), value="ENG", label="POV Agent")
+        pov_pick = gr.Dropdown(choices=list(w0.agents.keys()), value="ENG", label="POV Agent")
 
     with gr.Accordion("Incidents", open=False):
         task_id = gr.Textbox(value="T001", label="Task ID (e.g., T001)")
         incident_note = gr.Textbox(value="Vendor outage", label="Incident note")
         btn_inject = gr.Button("Inject Incident (force block + highlight)")
 
-    with gr.Accordion("Models & Pricing", open=False):
+    with gr.Accordion("Add Agents (Unlimited)", open=True):
         with gr.Row():
-            agent_pick = gr.Dropdown(choices=list(default_agents().keys()), value="ENG", label="Agent")
-            model_pick = gr.Dropdown(choices=list(DEFAULT_MODEL_PROFILES.keys()), value="Sim-GPT-5", label="Model")
-            btn_set_model = gr.Button("Set Agent Model")
-
+            add_count = gr.Slider(1, 20, value=3, step=1, label="How many to add")
+            base_name = gr.Textbox(value="A", label="Base name (auto increments)")
+            role = gr.Textbox(value="Custom Agent", label="Role title")
+        with gr.Row():
+            engine = gr.Dropdown(["sim", "api"], value="sim", label="Engine")
+            api_slot = gr.Dropdown(["KEYSLOT_A", "KEYSLOT_B"], value="KEYSLOT_A", label="API Key Slot (max 10 agents per slot)")
+            sim_model = gr.Dropdown(list(DEFAULT_MODEL_PROFILES.keys()), value="Sim-GPT-4o", label="Sim model profile")
+        behavior_prompt = gr.Textbox(
+            value="",
+            lines=3,
+            label="Behavior Prompt (per new agent)",
+            placeholder="Example: 'Act like a ruthless optimizations engineer. Prioritize unblocking and finishing tasks fast.'"
+        )
+        btn_add_agents = gr.Button("Add Agents")
+
+    with gr.Accordion("API Key Slots (Optional)", open=False):
+        gr.Markdown(
+            "This supports **OpenAI-compatible** chat completion endpoints.\n"
+            "- Base URL: typically `https://api.openai.com/v1`\n"
+            "- 1 slot can power **up to 10 agents** (enforced)\n"
+            "- If you leave the key empty, API agents will still exist but will log `[API_ERROR]`.\n"
+        )
+        with gr.Row():
+            slot_pick = gr.Dropdown(["KEYSLOT_A", "KEYSLOT_B"], value="KEYSLOT_A", label="Slot")
+            base_url = gr.Textbox(value="https://api.openai.com/v1", label="Base URL")
+        with gr.Row():
+            api_key = gr.Textbox(value="", label="API Key", type="password")
+            api_model = gr.Textbox(value="gpt-4o-mini", label="Model")
         with gr.Row():
-            price_model = gr.Dropdown(choices=list(DEFAULT_MODEL_PROFILES.keys()), value="Sim-GPT-5", label="Model to edit")
-            in_per_1m = gr.Number(value=DEFAULT_MODEL_PROFILES["Sim-GPT-5"]["in_per_1m"], label="Input $/1M")
-            out_per_1m = gr.Number(value=DEFAULT_MODEL_PROFILES["Sim-GPT-5"]["out_per_1m"], label="Output $/1M")
-            tps = gr.Number(value=DEFAULT_MODEL_PROFILES["Sim-GPT-5"]["tps"], label="Tokens/sec (TPS)")
-            btn_price = gr.Button("Update Pricing")
+            temperature = gr.Slider(0.0, 2.0, value=0.3, step=0.01, label="Temperature")
+            max_out = gr.Slider(16, 1200, value=220, step=1, label="Max output tokens")
+        sys_prompt = gr.Textbox(value="You are an agent in a multi-agent office simulation. Be concise, action-oriented, and realistic.", lines=4, label="System Prompt")
+        btn_save_slot = gr.Button("Save Slot")
 
     with gr.Accordion("Exports", open=True):
         with gr.Row():
-            btn_dl_jsonl = gr.Button("Download Run Log (JSONL)")
-            btn_dl_csv = gr.Button("Download Ledger (CSV)")
-        file_out = gr.File(label="Download")
+            dl_jsonl = gr.DownloadButton("Download Run Log (JSONL)", fn=ui_download_jsonl, inputs=[w_state])
+            dl_csv = gr.DownloadButton("Download Ledger (CSV)", fn=ui_download_csv, inputs=[w_state])
+
+    with gr.Accordion("Run Data (Scroll + Download)", open=True):
+        runlog_rows = gr.Slider(50, 2000, value=400, step=50, label="Rows shown in table (last N)")
+        run_data = gr.Dataframe(label="Run Data", interactive=False, wrap=True, height=420)
 
     # initial load
     demo.load(
-        lambda w, h: (*ui_refresh(w, h), w, h),
-        inputs=[w_state, highlight_state],
-        outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, w_state, highlight_state],
+        lambda w, h, rows: (*ui_refresh(w, h, rows), w, h),
+        inputs=[w_state, highlight_state, runlog_rows],
+        outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state],
         queue=True,
     )
 
     # reset
     btn_reset.click(
         ui_reset,
-        inputs=[seed, sim_preset, difficulty, incident_rate, max_parallel, backlog_size],
-        outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, w_state, highlight_state],
+        inputs=[seed, sim_preset, difficulty, incident_rate, max_parallel, backlog_size, map_preset, wall_density, resource_density, skill_mix, runlog_rows],
+        outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state],
         queue=True,
     )
 
     # run
-    btn_run.click(ui_run, inputs=[w_state, highlight_state, run_n], outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, w_state, highlight_state], queue=True)
-    btn_run50.click(lambda w,h: ui_run(w,h,50), inputs=[w_state, highlight_state], outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, w_state, highlight_state], queue=True)
-    btn_run200.click(lambda w,h: ui_run(w,h,200), inputs=[w_state, highlight_state], outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, w_state, highlight_state], queue=True)
+    btn_run.click(ui_run, inputs=[w_state, highlight_state, run_n, runlog_rows],
+                  outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state], queue=True)
+    btn_run50.click(lambda w, h, rows: ui_run(w, h, 50, rows), inputs=[w_state, highlight_state, runlog_rows],
+                    outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state], queue=True)
+    btn_run200.click(lambda w, h, rows: ui_run(w, h, 200, rows), inputs=[w_state, highlight_state, runlog_rows],
+                     outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state], queue=True)
 
     # incidents
     btn_inject.click(
         ui_inject_incident,
-        inputs=[w_state, highlight_state, task_id, incident_note],
-        outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, w_state, highlight_state],
+        inputs=[w_state, highlight_state, task_id, incident_note, runlog_rows],
+        outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state],
         queue=True,
     )
 
     # visuals
-    overlay.change(ui_set_overlay, inputs=[w_state, highlight_state, overlay], outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, w_state, highlight_state], queue=True)
-    auto_camera.change(ui_set_autocam, inputs=[w_state, highlight_state, auto_camera], outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, w_state, highlight_state], queue=True)
-    pov_pick.change(ui_set_pov, inputs=[w_state, highlight_state, pov_pick], outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, w_state, highlight_state], queue=True)
+    overlay.change(ui_set_overlay, inputs=[w_state, highlight_state, overlay, runlog_rows],
+                   outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state], queue=True)
+    auto_camera.change(ui_set_autocam, inputs=[w_state, highlight_state, auto_camera, runlog_rows],
+                       outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state], queue=True)
+    pov_pick.change(ui_set_pov, inputs=[w_state, highlight_state, pov_pick, runlog_rows],
+                    outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state], queue=True)
+
+    # scenario prompt
+    btn_save_scenario.click(ui_update_scenario_prompt, inputs=[w_state, highlight_state, scenario_prompt, runlog_rows],
+                            outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state], queue=True)
+
+    # map/tasks regen
+    btn_regen_map.click(ui_regen_map, inputs=[w_state, highlight_state, map_preset, wall_density, resource_density, runlog_rows],
+                        outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state], queue=True)
+    btn_regen_tasks.click(ui_regen_tasks, inputs=[w_state, highlight_state, regen_backlog_size, regen_skill_mix, runlog_rows],
+                          outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state], queue=True)
+
+    # add agents
+    btn_add_agents.click(
+        ui_add_agents,
+        inputs=[w_state, highlight_state, add_count, base_name, role, engine, api_slot, sim_model, behavior_prompt, runlog_rows],
+        outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state],
+        queue=True,
+    )
 
-    # models/pricing
-    btn_set_model.click(ui_set_agent_model, inputs=[w_state, highlight_state, agent_pick, model_pick], outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, w_state, highlight_state], queue=True)
-    btn_price.click(ui_update_model_price, inputs=[w_state, highlight_state, price_model, in_per_1m, out_per_1m, tps], outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, w_state, highlight_state], queue=True)
+    # save api slot
+    btn_save_slot.click(
+        ui_save_api_slot,
+        inputs=[w_state, highlight_state, slot_pick, base_url, api_key, api_model, temperature, max_out, sys_prompt, runlog_rows],
+        outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state],
+        queue=True,
+    )
 
-    # exports
-    btn_dl_jsonl.click(lambda w: ui_download_jsonl(w), inputs=[w_state], outputs=[file_out], queue=True)
-    btn_dl_csv.click(lambda w: ui_download_csv(w), inputs=[w_state], outputs=[file_out], queue=True)
+    # runlog row slider refresh
+    runlog_rows.change(
+        lambda w, h, rows: (*ui_refresh(w, h, rows), w, h),
+        inputs=[w_state, highlight_state, runlog_rows],
+        outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state],
+        queue=True,
+    )
 
     # autoplay
-    def autoplay_start(w: World, h, interval: float):
+    def autoplay_start(w: World, h, interval: float, rows: int):
         interval = float(interval)
-        return gr.update(value=interval, active=True), True, w, h
+        return gr.update(value=interval, active=True), True, (*ui_refresh(w, h, rows)), w, h
 
-    def autoplay_stop(w: World, h):
-        return gr.update(active=False), False, w, h
+    def autoplay_stop(w: World, h, rows: int):
+        return gr.update(active=False), False, (*ui_refresh(w, h, rows)), w, h
 
-    btn_play.click(autoplay_start, inputs=[w_state, highlight_state, autoplay_speed], outputs=[timer, autoplay_on, w_state, highlight_state], queue=True)
-    btn_pause.click(autoplay_stop, inputs=[w_state, highlight_state], outputs=[timer, autoplay_on, w_state, highlight_state], queue=True)
+    btn_play.click(
+        autoplay_start,
+        inputs=[w_state, highlight_state, autoplay_speed, runlog_rows],
+        outputs=[timer, autoplay_on, arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state],
+        queue=True,
+    )
+    btn_pause.click(
+        autoplay_stop,
+        inputs=[w_state, highlight_state, runlog_rows],
+        outputs=[timer, autoplay_on, arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state],
+        queue=True,
+    )
 
-    def autoplay_tick(w: World, h, is_on: bool):
+    def autoplay_tick(w: World, h, is_on: bool, rows: int):
         if not is_on:
-            return (*ui_refresh(w, h), w, h, is_on, gr.update())
-        r = make_rng(w.seed + w.step*31)
+            return (*ui_refresh(w, h, rows), w, h, is_on, gr.update())
+        r = make_rng(w.seed + w.step * 31)
         if not w.done:
             tick(w, r)
         if w.done:
-            return (*ui_refresh(w, h), w, h, False, gr.update(active=False))
-        return (*ui_refresh(w, h), w, h, True, gr.update())
+            return (*ui_refresh(w, h, rows), w, h, False, gr.update(active=False))
+        return (*ui_refresh(w, h, rows), w, h, True, gr.update())
 
     timer.tick(
         autoplay_tick,
-        inputs=[w_state, highlight_state, autoplay_on],
-        outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, w_state, highlight_state, autoplay_on, timer],
+        inputs=[w_state, highlight_state, autoplay_on, runlog_rows],
+        outputs=[arena, pov_img, status, agents_box, tasks_box, events, kpis, run_data, w_state, highlight_state, autoplay_on, timer],
         queue=True,
     )