agent-theatre 0.1.0 → 0.1.2

package/dist/cli.js

@@ -11,11 +11,1123 @@ import pc from "picocolors";
 import { createServer } from "http";
 import { existsSync, mkdirSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join2, basename } from "path";
+import { join as join2, basename as basename2 } from "path";
 import { Hono } from "hono";
 import { getRequestListener } from "@hono/node-server";
 import { WebSocketServer } from "ws";
-import { Director, direct, filesFromEvents, generateWorld, hookPayloadToEvents, parseTranscript } from "@agent-theatre/core";
+
+// ../core/dist/index.js
+var last = 0;
+var counter = 0;
+var ALPHA = "0123456789abcdefghjkmnpqrstvwxyz";
+function mintId(now = Date.now()) {
+  if (now === last) counter++;
+  else {
+    last = now;
+    counter = 0;
+  }
+  let t = now;
+  let s = "";
+  for (let i = 0; i < 10; i++) {
+    s = ALPHA[t % 32] + s;
+    t = Math.floor(t / 32);
+  }
+  return `ev_${s}${counter.toString(32).padStart(3, "0")}`;
+}
+function norm(p) {
+  return p.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+function relativizePath(abs, ctx) {
+  const p = norm(abs);
+  const cwd = norm(ctx.cwd);
+  if (cwd && (p === cwd || p.startsWith(cwd + "/"))) return p.slice(cwd.length + 1) || ".";
+  if (ctx.home) {
+    const home = norm(ctx.home);
+    if (home && (p === home || p.startsWith(home + "/"))) return "~/" + p.slice(home.length + 1);
+  }
+  if (!p.startsWith("/")) return p;
+  const base2 = p.slice(p.lastIndexOf("/") + 1);
+  return `//ext/${base2}`;
+}
+function basename(p) {
+  const n = norm(p);
+  return n.slice(n.lastIndexOf("/") + 1);
+}
+function isTestPath(p) {
+  return /(^|\/)(tests?|__tests__|spec|specs)\//i.test(p) || /\.(test|spec)\.[cm]?[jt]sx?$/i.test(p) || /(^|\/)test_[^/]+\.py$/i.test(p) || /_test\.(go|rs|py)$/i.test(p);
+}
+var TEST_RUNNERS = /\b(vitest|jest|mocha|pytest|py\.test|go\s+test|cargo\s+test|npm\s+test|pnpm\s+test|yarn\s+test|bun\s+test|npx\s+(vitest|jest|playwright)|rspec|phpunit|dotnet\s+test|mvn\s+test|gradle\s+test|make\s+test)\b/;
+var BUILD = /\b(tsc|tsup|vite\s+build|webpack|esbuild|rollup|next\s+build|cargo\s+build|go\s+build|make\b(?!\s+test)|npm\s+run\s+build|pnpm\s+(run\s+)?build|yarn\s+build|gradle\s+build|mvn\s+package|docker\s+build)\b/;
+var INSTALL = /\b(npm\s+(i|install|ci)|pnpm\s+(i|install|add)|yarn(\s+add|\s+install)?|pip3?\s+install|poetry\s+(add|install)|cargo\s+add|go\s+get|brew\s+install|apt(-get)?\s+install|bun\s+(i|install|add))\b/;
+var SEARCH = /\b(grep|rg|ag|ack|find|fd|locate)\b/;
+var READ = /^\s*(cat|head|tail|less|more|bat|wc|stat|jq)\b/;
+function argv0Of(command) {
+  const first = command.split(/\s*(?:&&|\|\||;|\|)\s*/)[0] ?? "";
+  const toks = first.trim().split(/\s+/).map((t) => t.replace(/^[({]+/, "")).filter(Boolean);
+  let i = 0;
+  while (i < toks.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(toks[i])) i++;
+  if (toks[i] === "cd" && toks.length > i + 1) {
+    const rest = command.split(/\s*&&\s*/)[1];
+    if (rest) return argv0Of(rest);
+  }
+  const a = toks[i] ?? "";
+  return a.replace(/^.*\//, "").slice(0, 40) || "sh";
+}
+function cleanTarget(t) {
+  const s = t.replace(/^["']|["']$/g, "").trim();
+  if (!s || s.startsWith("-") || s === "/dev/null" || s.includes("$(") || s.startsWith("$")) return null;
+  if (/^\/dev\//.test(s) || /^&\d/.test(s)) return null;
+  return s;
+}
+function extractWrites(command) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of command.matchAll(/(?:^|[\s)])\d?>{1,2}\s*([^\s|&;<>]+)/g)) {
+    const t = cleanTarget(m[1] ?? "");
+    if (t) out.add(t);
+  }
+  for (const m of command.matchAll(/\btee\s+(?:-[a-z]+\s+)*((?:[^\s|&;<>]+\s*)+)/g)) {
+    for (const f of (m[1] ?? "").split(/\s+/)) {
+      const t = cleanTarget(f);
+      if (t) out.add(t);
+    }
+  }
+  for (const m of command.matchAll(/\bsed\s+-i\S*\s+(.+?)(?=\s*(?:&&|\|\||;|\||$))/g)) {
+    const toks = (m[1] ?? "").match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+    const files = toks.filter((t) => !t.startsWith("-") && !t.startsWith("'") && !t.startsWith('"') && !/^s[/|#]/.test(t) && !/^-e$/.test(t));
+    for (const f of files) {
+      const t = cleanTarget(f);
+      if (t) out.add(t);
+    }
+  }
+  for (const m of command.matchAll(/\b(?:cp|mv)\s+(?:-[a-zA-Z]+\s+)*((?:[^\s|&;<>]+\s+)+)([^\s|&;<>]+)/g)) {
+    const t = cleanTarget(m[2] ?? "");
+    if (t) out.add(t);
+  }
+  for (const m of command.matchAll(/\btouch\s+((?:[^\s|&;<>]+\s*)+)/g)) {
+    for (const f of (m[1] ?? "").split(/\s+/)) {
+      const t = cleanTarget(f);
+      if (t) out.add(t);
+    }
+  }
+  return [...out];
+}
+function extractReads(command) {
+  const out = /* @__PURE__ */ new Set();
+  for (const seg of command.split(/\s*(?:&&|\|\||;|\|)\s*/)) {
+    const m = seg.match(/^\s*(?:cat|head|tail|less|more|bat|wc)\s+(?:-[^\s]+\s+)*((?:[^\s|&;<>]+\s*)+)/);
+    if (!m) continue;
+    for (const f of (m[1] ?? "").split(/\s+/)) {
+      const t = cleanTarget(f);
+      if (t && !/^\d+$/.test(t)) out.add(t);
+    }
+  }
+  return [...out];
+}
+function classifyBash(command) {
+  const argv0 = argv0Of(command);
+  const writes = extractWrites(command);
+  const reads = extractReads(command);
+  let intent = "other";
+  if (TEST_RUNNERS.test(command)) intent = "test";
+  else if (BUILD.test(command)) intent = "build";
+  else if (INSTALL.test(command)) intent = "install";
+  else if (/^\s*git\b/.test(command) || argv0 === "git" || argv0 === "gh") intent = "git";
+  else if (writes.length) intent = "write_file";
+  else if (SEARCH.test(command) && argv0 !== "cd") intent = "search";
+  else if (READ.test(command) && reads.length) intent = "read_file";
+  return { argv0, intent, writes, reads };
+}
+var num = (s) => s ? parseInt(s, 10) : 0;
+function parseTestSummary(output) {
+  const tail = output.length > 2e4 ? output.slice(-2e4) : output;
+  let m = tail.match(/Tests\s+(?:(\d+)\s+failed\s*\|\s*)?(\d+)\s+passed(?:\s*\|\s*(\d+)\s+skipped)?/);
+  if (m) return { failed: num(m[1]), passed: num(m[2]), ...m[3] ? { skipped: num(m[3]) } : {}, framework: "vitest" };
+  m = tail.match(/Tests\s+(\d+)\s+failed\s*\((\d+)\)/);
+  if (m) return { failed: num(m[1]), passed: Math.max(0, num(m[2]) - num(m[1])), framework: "vitest" };
+  m = tail.match(/Tests:\s+(?:(\d+)\s+failed,\s*)?(?:(\d+)\s+skipped,\s*)?(\d+)\s+passed,\s*(?:(\d+)\s+skipped,\s*)?\d+\s+total/);
+  if (m) return { failed: num(m[1]), passed: num(m[3]), ...m[2] ?? m[4] ? { skipped: num(m[2] ?? m[4]) } : {}, framework: "jest" };
+  m = tail.match(/Tests:\s+(\d+)\s+failed,\s*\d+\s+total/);
+  if (m) return { failed: num(m[1]), passed: 0, framework: "jest" };
+  m = tail.match(/=+\s*(?:(\d+)\s+failed,?\s*)?(?:(\d+)\s+passed,?\s*)?(?:(\d+)\s+skipped,?\s*)?(?:\d+\s+(?:error|errors|warnings?|deselected|xfailed|xpassed),?\s*)*in\s+[\d.]+s/);
+  if (m && (m[1] || m[2])) return { failed: num(m[1]), passed: num(m[2]), ...m[3] ? { skipped: num(m[3]) } : {}, framework: "pytest" };
+  if (/^--- (?:PASS|FAIL):/m.test(tail) || /^(?:ok|FAIL)\s+\S+\s+(?:[\d.]+s|\(cached\))/m.test(tail)) {
+    const failed = (tail.match(/^--- FAIL:/gm) ?? []).length || (tail.match(/^FAIL\s+\S+\s+[\d.]+s/gm) ?? []).length;
+    const passed = (tail.match(/^--- PASS:/gm) ?? []).length || (tail.match(/^ok\s+\S+/gm) ?? []).length;
+    return { failed, passed, framework: "go" };
+  }
+  m = tail.match(/test result:\s*\w+\.\s*(\d+)\s+passed;\s*(\d+)\s+failed;\s*(\d+)\s+ignored/);
+  if (m) return { passed: num(m[1]), failed: num(m[2]), skipped: num(m[3]), framework: "cargo" };
+  const mp = tail.match(/^\s*(\d+)\s+passing\b/m);
+  const mf = tail.match(/^\s*(\d+)\s+failing\b/m);
+  if (mp || mf) {
+    const ms = tail.match(/^\s*(\d+)\s+pending\b/m);
+    return { passed: num(mp?.[1]), failed: num(mf?.[1]), ...ms ? { skipped: num(ms[1]) } : {}, framework: "mocha" };
+  }
+  const pp = tail.match(/^\s*(\d+)\s+passed\s*\(/m);
+  const pf = tail.match(/^\s*(\d+)\s+failed\b/m);
+  if (pp || pf) return { passed: num(pp?.[1]), failed: num(pf?.[1]), framework: "playwright" };
+  return null;
+}
+var obj = (x) => x && typeof x === "object" ? x : {};
+var str = (x) => typeof x === "string" ? x : void 0;
+var lineCount = (s) => s ? (s.match(/\n/g)?.length ?? 0) + (s.endsWith("\n") ? 0 : 1) : 0;
+function patchCounts(response) {
+  const patch = obj(response).structuredPatch;
+  if (!Array.isArray(patch)) return null;
+  let added = 0, removed = 0;
+  for (const h of patch) {
+    const lines = obj(h).lines;
+    if (!Array.isArray(lines)) continue;
+    for (const l of lines) {
+      if (typeof l !== "string") continue;
+      if (l.startsWith("+")) added++;
+      else if (l.startsWith("-")) removed++;
+    }
+  }
+  return { added, removed, hunks: patch.length };
+}
+function responseText(response) {
+  if (typeof response === "string") return response;
+  const r = obj(response);
+  const parts = [str(r.stdout), str(r.stderr), str(r.output)].filter((x) => !!x);
+  if (parts.length) return parts.join("\n");
+  if (Array.isArray(response)) return response.map((b) => str(obj(b).text) ?? "").join("\n");
+  return "";
+}
+function heredocLines(command) {
+  let n = 0;
+  for (const m of command.matchAll(/<<-?\s*(['"]?)(\w+)\1[^\n]*\n([\s\S]*?)\n\2(?=\n|$)/g)) n += lineCount(m[3]);
+  if (n === 0 && /(?:^|[\s)])\d?>{1,2}\s*[^\s|&;<>]+/.test(command) && !/>\s*\/dev\/null/.test(command)) n = 1;
+  return n;
+}
+var SEARCH_TOOLS_REPO = /* @__PURE__ */ new Set(["Grep", "Glob", "LS", "ToolSearch"]);
+var SEARCH_TOOLS_WEB = /* @__PURE__ */ new Set(["WebSearch", "WebFetch"]);
+var SILENT_TOOLS = /* @__PURE__ */ new Set(["TodoWrite", "TodoRead", "Skill", "EnterPlanMode", "ExitPlanMode", "EnterWorktree", "ExitWorktree", "NotebookRead", "ListAgents", "SendMessage", "TaskStop", "Monitor", "ScheduleWakeup", "ReportFindings"]);
+function toolCallToOutcome(call, ctx) {
+  const input = obj(call.input);
+  const resp = call.response;
+  const ok = !call.isError && obj(resp).interrupted !== true;
+  const rel = (p) => relativizePath(p, ctx);
+  const dur = call.durationMs !== void 0 ? { durationMs: call.durationMs } : {};
+  switch (call.name) {
+    case "Read": {
+      const path = str(input.file_path) ?? str(input.path);
+      if (!path) return { bodies: [], warning: { code: "missing_field", detail: "Read without file_path" } };
+      const content = str(obj(obj(resp).file).content);
+      return { bodies: [{ kind: "read_file", path: rel(path), ...content !== void 0 ? { bytes: content.length } : {} }] };
+    }
+    case "Edit":
+    case "MultiEdit":
+    case "NotebookEdit": {
+      const path = str(input.file_path) ?? str(input.notebook_path);
+      if (!path) return { bodies: [], warning: { code: "missing_field", detail: `${call.name} without file_path` } };
+      const counts = patchCounts(resp) ?? {
+        added: lineCount(str(input.new_string) ?? str(input.new_source)),
+        removed: lineCount(str(input.old_string)),
+        hunks: 1
+      };
+      return { bodies: [{ kind: "edit_file", path: rel(path), ...counts }] };
+    }
+    case "Write": {
+      const path = str(input.file_path);
+      if (!path) return { bodies: [], warning: { code: "missing_field", detail: "Write without file_path" } };
+      const r = obj(resp);
+      const created = r.type === "create" || r.type === void 0 && r.originalFile === null;
+      return { bodies: [{ kind: "write_file", path: rel(path), added: lineCount(str(input.content)), created }] };
+    }
+    case "Bash": {
+      const command = str(input.command) ?? "";
+      const c = classifyBash(command);
+      const touched = [...new Set([...c.writes, ...c.reads].map(rel))];
+      const bodies = [{ kind: "run_command", argv0: c.argv0, intent: c.intent, touched, ok, ...dur }];
+      const heredoc = heredocLines(command);
+      c.writes.forEach((w, i) => bodies.push({ kind: "write_file", path: rel(w), added: i === 0 ? heredoc : 0, created: false }));
+      for (const r of c.reads) bodies.push({ kind: "read_file", path: rel(r) });
+      if (c.intent === "test") {
+        const sum = parseTestSummary(responseText(resp));
+        if (sum) bodies.push({ kind: "test_result", ok: sum.failed === 0 && ok, passed: sum.passed, failed: sum.failed, ...sum.skipped !== void 0 ? { skipped: sum.skipped } : {}, framework: sum.framework, ...dur });
+        else bodies.push({ kind: "test_result", ok, passed: 0, failed: 0, framework: "unknown", ...dur });
+      }
+      return { bodies };
+    }
+    case "Agent":
+    case "Task": {
+      const r = obj(resp);
+      const agentId = str(r.agentId) ?? str(r.agent_id) ?? "";
+      const label = str(input.description) ?? str(input.subagent_type);
+      const start = { kind: "subagent_start", childId: agentId, ...label ? { label } : {} };
+      if (r.status === "async_launched" || r.isAsync === true) return { bodies: [start], pendingSubagent: { childId: agentId } };
+      return { bodies: [start, { kind: "subagent_stop", childId: agentId, ok }] };
+    }
+    case "AskUserQuestion":
+      return { bodies: [{ kind: "waiting_for_user", reason: "question" }] };
+  }
+  if (SEARCH_TOOLS_REPO.has(call.name)) {
+    const n = obj(resp).numFiles ?? obj(resp).numLines ?? obj(resp).count;
+    return { bodies: [{ kind: "search", scope: "repo", ...typeof n === "number" ? { hits: n } : {} }] };
+  }
+  if (SEARCH_TOOLS_WEB.has(call.name)) return { bodies: [{ kind: "search", scope: "web" }] };
+  if (SILENT_TOOLS.has(call.name)) return { bodies: [] };
+  return {
+    bodies: [{ kind: "run_command", argv0: call.name.slice(0, 40), intent: "other", touched: [], ok, ...dur }],
+    warning: { code: "unknown_tool", detail: call.name.slice(0, 80) }
+  };
+}
+var SUCCESS_LEXICON = [
+  /\ball (?:\d+ )?tests? (?:are )?pass(?:ing|ed)?\b/i,
+  /\btests? (?:are |is )?(?:now )?(?:passing|green)\b/i,
+  /\b(?:is|are|it's|that's|everything(?:'s| is)) (?:now )?(?:fixed|working|done|complete|resolved)\b/i,
+  /\bshould (?:now )?work\b/i,
+  /\bworks now\b/i,
+  /\b(?:done|complete|completed|fixed|resolved|shipped|implemented)[.!]/i,
+  /✅/
+];
+var HEDGE_LEXICON = [
+  /\bnot (?:yet )?(?:done|fixed|working|tested|verified|complete)\b/i,
+  /\bstill (?:fail|broken|not)/i,
+  /\b(?:could ?n[’']?t|cannot|can ?not|unable to|wasn[’']?t able)\b/i,
+  /\bfail(?:ed|ing|s)\b/i,
+  /\bTODO\b/,
+  /\bhaven[’']?t (?:run|tested|verified|checked)/i,
+  /\buntested\b/i,
+  /\bI did not (?:run|test|verify)/i
+];
+var TAIL = 600;
+function claimsSuccess(text) {
+  if (!text) return false;
+  const tail = text.length > TAIL ? text.slice(-TAIL) : text;
+  if (HEDGE_LEXICON.some((r) => r.test(tail))) return false;
+  return SUCCESS_LEXICON.some((r) => r.test(tail));
+}
+var ROW_TYPES = /* @__PURE__ */ new Set(["user", "assistant", "system"]);
+var obj2 = (x) => x && typeof x === "object" ? x : {};
+var str2 = (x) => typeof x === "string" ? x : void 0;
+function parseTranscript(text, opts = {}) {
+  const rows = [];
+  const warnings = [];
+  const lines = text.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.trim()) continue;
+    try {
+      rows.push(JSON.parse(line));
+    } catch {
+      warnings.push({ code: "bad_json", detail: `line ${i + 1}`, line: i + 1 });
+    }
+  }
+  const res = parseTranscriptRows(rows, opts);
+  return { events: res.events, warnings: [...warnings, ...res.warnings] };
+}
+function parseTranscriptRows(rows, opts = {}) {
+  const events = [];
+  const warnings = [];
+  const unknownTypes = /* @__PURE__ */ new Set();
+  const pending = /* @__PURE__ */ new Map();
+  const openSubagents = /* @__PURE__ */ new Map();
+  let sessionId = "";
+  let cwd = "";
+  let branch;
+  let firstTs = Number.NaN;
+  let lastTs = Number.NaN;
+  let lastAssistantText = "";
+  let seq = 0;
+  let sawEnd = false;
+  const ctx = () => ({ cwd, ...opts.home ? { home: opts.home } : {} });
+  const push = (ts, id, body, extra = {}) => {
+    events.push({ id, seq: seq++, ts, sessionId, source: "transcript", ...extra, ...body });
+  };
+  const tsOf = (row) => {
+    const t = str2(row.timestamp);
+    const n = t ? Date.parse(t) : Number.NaN;
+    return Number.isFinite(n) ? n : Number.isFinite(lastTs) ? lastTs : 0;
+  };
+  const agentOf = (row) => str2(row.agentId) ?? (row.isSidechain === true ? opts.sidechainAgentId ?? "sidechain" : void 0);
+  for (const raw of rows) {
+    const row = obj2(raw);
+    const type = str2(row.type) ?? "";
+    if (!ROW_TYPES.has(type)) {
+      if (type) unknownTypes.add(type);
+      continue;
+    }
+    if (!sessionId && str2(row.sessionId)) sessionId = str2(row.sessionId);
+    if (!cwd && str2(row.cwd)) cwd = str2(row.cwd);
+    if (!branch && str2(row.gitBranch)) branch = str2(row.gitBranch);
+    const ts = tsOf(row);
+    if (!Number.isFinite(firstTs)) {
+      firstTs = ts;
+      push(ts, `${sessionId || "session"}:start`, { kind: "session_start", repoId: basename(cwd) || "repo", ...branch ? { branch } : {} });
+    }
+    lastTs = ts;
+    const agentId = agentOf(row);
+    const message = obj2(row.message);
+    const content = message.content;
+    if (type === "system") {
+      if (row.subtype === "api_error") {
+        const attempt = typeof row.retryAttempt === "number" ? row.retryAttempt : 0;
+        const max = typeof row.maxRetries === "number" ? row.maxRetries : 0;
+        push(ts, str2(row.uuid) ?? `sys:${seq}`, { kind: "error", where: "api", retrying: attempt < max }, agentId ? { agentId } : {});
+      }
+      continue;
+    }
+    if (type === "assistant") {
+      const blocks2 = Array.isArray(content) ? content : [];
+      for (const b of blocks2) {
+        const block = obj2(b);
+        if (block.type === "tool_use" && str2(block.id) && str2(block.name)) {
+          pending.set(str2(block.id), { name: str2(block.name), input: block.input, ts, ...agentId ? { agentId } : {} });
+        } else if (block.type === "text" && !agentId) {
+          const t = str2(block.text);
+          if (t) lastAssistantText = t;
+        }
+      }
+      if (typeof content === "string" && !agentId) lastAssistantText = content;
+      if (message.stop_reason === "end_turn" && !agentId) {
+        push(ts, `${str2(row.uuid) ?? seq}:turn`, { kind: "turn_end", claimedSuccess: claimsSuccess(lastAssistantText) });
+      }
+      continue;
+    }
+    if (row.toolDenialKind !== void 0) push(ts, `${str2(row.uuid) ?? seq}:deny`, { kind: "waiting_for_user", reason: "permission" });
+    const blocks = Array.isArray(content) ? content : [];
+    for (const b of blocks) {
+      const block = obj2(b);
+      if (block.type !== "tool_result") continue;
+      const useId = str2(block.tool_use_id);
+      if (!useId) continue;
+      const p = pending.get(useId);
+      if (!p) {
+        warnings.push({ code: "unpaired_result", detail: useId });
+        continue;
+      }
+      pending.delete(useId);
+      const response = row.toolUseResult ?? block.content;
+      const out = toolCallToOutcome(
+        { name: p.name, input: p.input, response, isError: block.is_error === true, durationMs: Math.max(0, ts - p.ts) },
+        ctx()
+      );
+      if (out.warning) warnings.push(out.warning);
+      const rowAgent = p.agentId ?? agentId;
+      const parentId = rowAgent ? openSubagents.get(rowAgent) : void 0;
+      const extra = { ...rowAgent ? { agentId: rowAgent } : {}, ...parentId ? { parentId } : {} };
+      out.bodies.forEach((body, i) => push(p.ts, i === 0 ? useId : `${useId}:${i}`, body, extra));
+      if (out.pendingSubagent) openSubagents.set(out.pendingSubagent.childId, useId);
+    }
+    if (blocks.length === 0 && typeof content === "string" && /\[Request interrupted by user/i.test(content)) {
+      push(ts, `${str2(row.uuid) ?? seq}:interrupt`, { kind: "waiting_for_user", reason: "idle" });
+    }
+  }
+  for (const [useId, p] of pending) {
+    warnings.push({ code: "unpaired_result", detail: `tool_use ${useId} (${p.name}) has no result` });
+    const out = toolCallToOutcome({ name: p.name, input: p.input, isError: true }, ctx());
+    if (out.warning) warnings.push(out.warning);
+    out.bodies.forEach((body, i) => push(p.ts, i === 0 ? useId : `${useId}:${i}`, body, p.agentId ? { agentId: p.agentId } : {}));
+  }
+  for (const [childId, spawnId] of openSubagents) {
+    push(lastTs, `${spawnId}:stop`, { kind: "subagent_stop", childId, ok: true }, { parentId: spawnId });
+  }
+  for (const t of unknownTypes) warnings.push({ code: "unknown_row_type", detail: t });
+  if (Number.isFinite(firstTs) && !sawEnd) {
+    sawEnd = true;
+    push(lastTs, `${sessionId || "session"}:end`, { kind: "session_end", reason: "stop", claimedSuccess: claimsSuccess(lastAssistantText) });
+  }
+  return { events, warnings };
+}
+var obj3 = (x) => x && typeof x === "object" ? x : {};
+var str3 = (x) => typeof x === "string" ? x : void 0;
+var TOOL_EVENTS = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUse", "PostToolUseFailure"]);
+function endReason(reason) {
+  switch (reason) {
+    case "clear":
+    case "logout":
+    case "prompt_input_exit":
+      return "user";
+    default:
+      return "stop";
+  }
+}
+function hookPayloadToEvents(payload, opts = {}) {
+  const p = obj3(payload);
+  const name = str3(p.hook_event_name);
+  const sessionId = str3(p.session_id) ?? "";
+  const ts = opts.now ?? Date.now();
+  if (!name) return { events: [], warnings: [{ code: "missing_field", detail: "hook_event_name" }] };
+  const cwd = str3(p.cwd) ?? "";
+  const ctx = { cwd, ...opts.home ? { home: opts.home } : {} };
+  const agentId = TOOL_EVENTS.has(name) ? str3(p.agent_id) : void 0;
+  const extra = agentId ? { agentId } : {};
+  let seq = 0;
+  const mk = (body, id = mintId(ts)) => ({ id, seq: seq++, ts, sessionId, source: "hook", ...extra, ...body });
+  const one = (body) => ({ events: [mk(body)], warnings: [] });
+  switch (name) {
+    case "SessionStart":
+      return one({ kind: "session_start", repoId: basename(cwd) || "repo" });
+    case "SessionEnd":
+      return one({ kind: "session_end", reason: endReason(str3(p.reason)), claimedSuccess: false });
+    case "Stop":
+      return one({ kind: "turn_end", claimedSuccess: claimsSuccess(str3(p.last_assistant_message)) });
+    case "SubagentStart": {
+      const id = str3(p.agent_id) ?? "";
+      const label = str3(p.agent_type);
+      return { events: [mk({ kind: "subagent_start", childId: id, ...label ? { label } : {} })], warnings: [] };
+    }
+    case "SubagentStop":
+      return one({ kind: "subagent_stop", childId: str3(p.agent_id) ?? "", ok: true });
+    case "Notification": {
+      const t = str3(p.notification_type);
+      if (t === "permission_prompt") return one({ kind: "waiting_for_user", reason: "permission" });
+      if (t === "idle_prompt") return one({ kind: "waiting_for_user", reason: "idle" });
+      if (t === "elicitation_dialog") return one({ kind: "waiting_for_user", reason: "question" });
+      return { events: [], warnings: [] };
+    }
+    case "PostToolUseFailure":
+      return one({ kind: "error", where: str3(p.tool_name) ?? "tool", retrying: false });
+    case "PostToolUse": {
+      const tool = str3(p.tool_name);
+      if (!tool) return { events: [], warnings: [{ code: "missing_field", detail: "tool_name" }] };
+      const dur = typeof p.duration_ms === "number" ? { durationMs: p.duration_ms } : {};
+      const out = toolCallToOutcome({ name: tool, input: p.tool_input, response: p.tool_response, ...dur }, ctx);
+      const baseId = str3(p.tool_use_id) ?? mintId(ts);
+      const events = out.bodies.map((body, i) => mk(body, i === 0 ? baseId : `${baseId}:${i}`));
+      return { events, warnings: out.warning ? [out.warning] : [] };
+    }
+    case "PreToolUse":
+    case "UserPromptSubmit":
+    case "PreCompact":
+    case "PostCompact":
+      return { events: [], warnings: [] };
+  }
+  return { events: [], warnings: [{ code: "unknown_row_type", detail: name }] };
+}
+function hashString(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var ARCHIVE_RE = /(^|\/)(schema\.(sql|prisma|graphql|gql)|.*\.(sql|prisma|db|sqlite)|migrations?\/|drizzle\/|models?\/.*\.(ts|js|py|rb)$)/i;
+var IGNORE_RE = /(^|\/)(node_modules|\.git|dist|build|out|coverage|_site|\.next|\.turbo|target|vendor|__pycache__|\.venv|venv)(\/|$)|(^|\/)\.[^/]+$|\.(lock|map|min\.js|png|jpg|jpeg|gif|webp|svg|ico|woff2?|ttf|mp4|mp3|pdf|zip)$/i;
+function isIgnoredPath(p) {
+  return IGNORE_RE.test(p);
+}
+function kindOf(path) {
+  if (isTestPath(path)) return "beacon";
+  if (ARCHIVE_RE.test(path)) return "archive";
+  return "building";
+}
+function locOf(f) {
+  if (typeof f.loc === "number") return f.loc;
+  if (typeof f.size === "number") return Math.max(1, Math.round(f.size / 40));
+  return 1;
+}
+function scoreFiles(files, touched) {
+  const kept = files.filter((f) => !isIgnoredPath(f.path));
+  const maxLoc = Math.max(1, ...kept.map(locOf));
+  const maxChurn = Math.max(1, ...kept.map((f) => f.churn ?? 0));
+  return kept.map((file) => {
+    const loc = locOf(file);
+    const t = touched.has(file.path);
+    const score = 0.5 * Math.sqrt(loc / maxLoc) + 0.3 * ((file.churn ?? 0) / maxChurn) + (t ? 0.2 : 0);
+    return { file, loc, score, kind: kindOf(file.path), touched: t };
+  });
+}
+function heightClass(loc, maxLoc) {
+  const r = Math.sqrt(loc / Math.max(1, maxLoc));
+  return Math.max(1, Math.min(5, Math.ceil(r * 5)));
+}
+function footprintOf(height) {
+  return height >= 5 ? 3 : height >= 3 ? 2 : 1;
+}
+var EXT_LANG = { ts: "TypeScript", tsx: "TypeScript", js: "JavaScript", jsx: "JavaScript", mjs: "JavaScript", py: "Python", go: "Go", rs: "Rust", java: "Java", kt: "Kotlin", swift: "Swift", rb: "Ruby", php: "PHP", cs: "C#", cpp: "C++", cc: "C++", c: "C", h: "C", m: "Objective-C", scala: "Scala", ex: "Elixir", exs: "Elixir", dart: "Dart", lua: "Lua", zig: "Zig", sh: "Shell", sql: "SQL", md: "Markdown", mdx: "Markdown", html: "HTML", css: "CSS", scss: "CSS", vue: "Vue", svelte: "Svelte", tf: "Terraform", yaml: "YAML", yml: "YAML", ipynb: "Notebook" };
+function profileRepo(files, manifests = {}) {
+  const paths = files.map((f) => f.path.toLowerCase());
+  const has = (re) => paths.some((p) => re.test(p));
+  const count = (re) => paths.filter((p) => re.test(p)).length;
+  const langCount = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const ext = p.slice(p.lastIndexOf(".") + 1);
+    const l = EXT_LANG[ext];
+    if (l && !/^(markdown|yaml|html|css|shell|sql)$/i.test(l)) langCount.set(l, (langCount.get(l) ?? 0) + 1);
+  }
+  const languages = [...langCount.entries()].sort((a, b) => b[1] - a[1]).map(([l]) => l).slice(0, 4);
+  const pkg2 = (manifests["package.json"] ?? "").toLowerCase();
+  const py = ((manifests["pyproject.toml"] ?? "") + (manifests["requirements.txt"] ?? "")).toLowerCase();
+  const dep = (re) => re.test(pkg2) || re.test(py);
+  const scores = /* @__PURE__ */ new Map();
+  const add = (k, n) => scores.set(k, (scores.get(k) ?? 0) + n);
+  if (dep(/"(react|react-dom|next|vue|nuxt|svelte|@sveltejs\/kit|@angular\/core|solid-js|astro|remix|vite)"/)) add("web-frontend", 3);
+  if (count(/\.(tsx|jsx|vue|svelte)$/) > 3) add("web-frontend", 2);
+  if (has(/(^|\/)(index|app)\.html$/) || count(/\.(css|scss)$/) > 3) add("web-frontend", 1);
+  if (dep(/"(express|fastify|hono|koa|@nestjs\/core|apollo-server|prisma|drizzle-orm|django|flask|fastapi|sqlalchemy|gin|fiber|actix|axum|rails|spring)"/)) add("backend-api", 3);
+  if (has(/(^|\/)(routes?|controllers?|api|handlers?|migrations?)\//) || has(/\.(sql|prisma)$/)) add("backend-api", 2);
+  if (pkg2.includes('"bin"') || has(/(^|\/)(cli|cmd|bin)\//) || dep(/"(commander|yargs|clap|cobra|click|typer)"/)) add("cli-tool", 3);
+  if (dep(/"(torch|tensorflow|jax|pandas|numpy|scikit-learn|sklearn|transformers|xgboost|lightgbm|polars)"/) || count(/\.ipynb$/) > 0 || has(/(^|\/)(notebooks?|models?|datasets?|training)\//)) add("data-ml", 3);
+  if (has(/\.(swift|kt)$/) || has(/(^|\/)(ios|android)\//) || has(/package\.swift$/) || has(/build\.gradle(\.kts)?$/) || dep(/"(react-native|expo|flutter)"/) || has(/\.dart$/)) add("mobile", 3);
+  if (has(/\.(unity|unitypackage|godot|tscn|gd)$/) || has(/(^|\/)assets\/.*\.(prefab|fbx)$/) || dep(/"(phaser|pixi\.js|three|babylonjs|@react-three\/fiber|excalibur|kaplay|bevy|godot)"/)) add("game", 3);
+  if (has(/\.tf$/) || has(/(^|\/)(dockerfile|docker-compose\.ya?ml|helm|k8s|kubernetes|\.github\/workflows|ansible|pulumi)/)) add("infra-devops", has(/\.tf$/) || has(/(^|\/)(helm|k8s|kubernetes|ansible|pulumi)\//) ? 3 : 1);
+  const mdShare = count(/\.(md|mdx|rst)$/) / Math.max(1, paths.length);
+  if (mdShare > 0.4 || has(/(^|\/)(mkdocs|docusaurus)\.config|(^|\/)docs\/.*\.mdx?$/) && mdShare > 0.25) add("docs-content", 3);
+  if (has(/(^|\/)pnpm-workspace\.ya?ml$/) || has(/(^|\/)packages\/[^/]+\/package\.json$/) || has(/(^|\/)(lerna|nx|turbo)\.json$/) || has(/(^|\/)cargo\.toml$/) && count(/(^|\/)crates\/[^/]+\//) > 0) add("monorepo", 2);
+  if (count(/\.(rs|go|c|cpp|cc|h|zig)$/) > 5 && !scores.has("web-frontend")) add("systems", 2);
+  if (pkg2.includes('"main"') && !pkg2.includes('"bin"') && !scores.has("web-frontend") && !scores.has("backend-api")) add("library", 2);
+  if (has(/(^|\/)(lib|src\/lib)\//) && !scores.has("web-frontend")) add("library", 1);
+  const kinds = [...scores.entries()].filter(([, n]) => n >= 2).sort((a, b) => b[1] - a[1]).map(([k]) => k);
+  return { kinds: kinds.length ? kinds : ["unknown"], languages, files: files.length };
+}
+function generateWorld(opts) {
+  const cap = opts.cap ?? 60;
+  const beaconCap = opts.beaconCap ?? 8;
+  const touchedCap = opts.touchedCap ?? 48;
+  const touched = new Set((opts.touched ?? []).map(norm2).slice(0, touchedCap));
+  const seed = hashString(opts.repoId);
+  const rnd = mulberry32(seed);
+  const files = opts.files.map((f) => ({ ...f, path: norm2(f.path) }));
+  const scored = scoreFiles(files, touched);
+  const maxLoc = Math.max(1, ...scored.map((s) => s.loc));
+  const byScore = [...scored].sort((a, b) => b.score - a.score || a.file.path.localeCompare(b.file.path));
+  const beacons = pick(byScore.filter((s) => s.kind === "beacon"), beaconCap);
+  const others = pick(byScore.filter((s) => s.kind !== "beacon"), cap);
+  const selected = [...others, ...beacons];
+  const capped = selected.length < scored.length;
+  const groups = /* @__PURE__ */ new Map();
+  for (const s of others) {
+    const d = topDir(s.file.path);
+    (groups.get(d) ?? groups.set(d, []).get(d)).push(s);
+  }
+  const names = [...groups.keys()].sort();
+  const occupied = /* @__PURE__ */ new Set();
+  const places = [];
+  const districts = [];
+  const forge = { id: "forge", kind: "forge", path: "", label: "forge", district: "", gx: -1, gy: -1, footprint: 2, height: 2, score: 0, touched: false };
+  places.push(forge);
+  const layout = opts.layout ?? LAYOUTS[seed % LAYOUTS.length];
+  const jitter = rnd() * Math.PI * 2;
+  const sized = names.map((name) => {
+    const items = groups.get(name).sort((a, b) => b.score - a.score || a.file.path.localeCompare(b.file.path));
+    const cells = items.reduce((n, s) => n + footprintOf(heightClass(s.loc, maxLoc)) ** 2, 0);
+    const side = Math.max(3, Math.ceil(Math.sqrt(cells * 1.45)));
+    return { name, items, side };
+  });
+  const placedRects = [];
+  const hubRect = { x: -2, y: -2, w: 4, h: 4 };
+  const rects = layoutRects(layout, sized.map((d) => d.side), hubRect, jitter, rnd);
+  placedRects.push(hubRect, ...rects);
+  const hub = hubFor(layout, rects);
+  forge.gx = hub[0];
+  forge.gy = hub[1];
+  occupied.clear();
+  claim(occupied, forge);
+  sized.forEach((d0, i) => {
+    const rect = rects[i];
+    const d = { id: `d:${d0.name}`, label: d0.name === "" ? "/" : `${d0.name}/`, bounds: rect, cx: rect.x + Math.floor(rect.w / 2), cy: rect.y + Math.floor(rect.h / 2), placeIds: [] };
+    for (const s of d0.items) {
+      const h = heightClass(s.loc, maxLoc);
+      const fp = footprintOf(h);
+      const spot = spiralSpot(occupied, d.cx, d.cy, fp, rect);
+      const p = { id: `p:${s.file.path}`, kind: s.kind, path: s.file.path, label: base(s.file.path), district: d.id, gx: spot[0], gy: spot[1], footprint: fp, height: h, score: round3(s.score), touched: s.touched };
+      claim(occupied, p);
+      places.push(p);
+      d.placeIds.push(p.id);
+    }
+    districts.push(d);
+  });
+  let ring = Math.ceil(maxExtent(placedRects));
+  void ring;
+  for (const r of placedRects) for (let x = r.x - 1; x < r.x + r.w + 1; x++) for (let y = r.y - 1; y < r.y + r.h + 1; y++) occupied.add(`${x},${y}`);
+  for (const s of beacons) {
+    const home = districts.find((d) => d.id === `d:${topDir(s.file.path)}`);
+    const spot = home ? edgeSpot(occupied, home, forge, 1) : nearSpot(occupied, forge.gx + 1, forge.gy + 1, rnd() * Math.PI * 2, 4, 1);
+    const p = { id: `p:${s.file.path}`, kind: "beacon", path: s.file.path, label: base(s.file.path), district: home?.id ?? "", gx: spot[0], gy: spot[1], footprint: 1, height: 4, score: round3(s.score), touched: s.touched };
+    claim(occupied, p);
+    places.push(p);
+    home?.placeIds.push(p.id);
+  }
+  const dockSpot = nearSpot(occupied, forge.gx + 1, forge.gy + 1, jitter + Math.PI, 5, 2);
+  const dock = { id: "dock", kind: "dock", path: "", label: "dock", district: "", gx: dockSpot[0], gy: dockSpot[1], footprint: 2, height: 1, score: 0, touched: false };
+  claim(occupied, dock);
+  places.push(dock);
+  const paths = layoutPaths(layout, districts, forge, dock);
+  if (capped) {
+    for (const d of districts) {
+      const top = d.id.slice(2);
+      const total = scored.filter((s) => s.kind !== "beacon" && topDir(s.file.path) === top).length;
+      if (total <= d.placeIds.length) continue;
+      const spot = spiralSpot(occupied, d.cx, d.cy, 1, d.bounds);
+      const p = { id: `p:${top ? top + "/" : ""}\u2026`, kind: "overflow", path: `${top ? top + "/" : ""}\u2026`, label: `+${total - d.placeIds.length} more`, district: d.id, gx: spot[0], gy: spot[1], footprint: 1, height: 2, score: 0, touched: false };
+      claim(occupied, p);
+      places.push(p);
+      d.placeIds.push(p.id);
+    }
+  }
+  const bounds = boundsOf(places, 2);
+  const profile = profileRepo(files, opts.manifests ?? {});
+  return { repoId: opts.repoId, seed, layout, profile, districts, places, paths, bounds, stats: { files: scored.length, placed: selected.length, capped } };
+}
+var norm2 = (p) => p.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
+var base = (p) => p.slice(p.lastIndexOf("/") + 1);
+var topDir = (p) => p.includes("/") ? p.slice(0, p.indexOf("/")) : "";
+var round3 = (n) => Math.round(n * 1e3) / 1e3;
+function pick(sorted, cap) {
+  const forced = sorted.filter((s) => s.touched);
+  const rest = sorted.filter((s) => !s.touched);
+  return [...forced, ...rest.slice(0, Math.max(0, cap - forced.length))];
+}
+function overlaps(a, b, gap) {
+  return a.x < b.x + b.w + gap && b.x < a.x + a.w + gap && a.y < b.y + b.h + gap && b.y < a.y + a.h + gap;
+}
+function cellsOf(gx, gy, fp) {
+  const out = [];
+  for (let dx = 0; dx < fp; dx++) for (let dy = 0; dy < fp; dy++) out.push(`${gx + dx},${gy + dy}`);
+  return out;
+}
+function free(occ, gx, gy, fp) {
+  return cellsOf(gx, gy, fp).every((c) => !occ.has(c));
+}
+function claim(occ, p) {
+  for (const c of cellsOf(p.gx, p.gy, p.footprint)) occ.add(c);
+}
+function spiralSpot(occ, cx, cy, fp, rect) {
+  let x = 0, y = 0, dx = 0, dy = -1;
+  let fallback = null;
+  for (let i = 0; i < 4096; i++) {
+    const gx = cx + x - Math.floor(fp / 2), gy = cy + y - Math.floor(fp / 2);
+    if (free(occ, gx, gy, fp)) {
+      const inside = gx >= rect.x - 1 && gy >= rect.y - 1 && gx + fp <= rect.x + rect.w + 1 && gy + fp <= rect.y + rect.h + 1;
+      if (inside) return [gx, gy];
+      fallback ??= [gx, gy];
+      if (i > 600) return fallback;
+    }
+    if (x === y || x < 0 && x === -y || x > 0 && x === 1 - y) [dx, dy] = [-dy, dx];
+    x += dx;
+    y += dy;
+  }
+  return fallback ?? [cx, cy];
+}
+function maxExtent(rects) {
+  return Math.max(...rects.map((r) => Math.max(Math.abs(r.x), Math.abs(r.x + r.w), Math.abs(r.y), Math.abs(r.y + r.h))));
+}
+function boundsOf(places, pad) {
+  const xs = places.flatMap((p) => [p.gx, p.gx + p.footprint]);
+  const ys = places.flatMap((p) => [p.gy, p.gy + p.footprint]);
+  const x = Math.min(...xs) - pad, y = Math.min(...ys) - pad;
+  return { x, y, w: Math.max(...xs) + pad - x, h: Math.max(...ys) + pad - y };
+}
+var LAYOUTS = ["ring", "grid", "strip", "scatter", "terrace", "spine"];
+function layoutRects(style, sides, hub, jitter, rnd) {
+  const n = sides.length, out = [];
+  const maxSide = Math.max(3, ...sides);
+  const fits = (r) => !overlaps(hub, r, 1) && !out.some((o) => overlaps(o, r, 1));
+  const push = (x, y, side) => {
+    const r = { x, y, w: side, h: side };
+    out.push(r);
+    return r;
+  };
+  switch (style) {
+    case "grid": {
+      const cols = Math.max(2, Math.ceil(Math.sqrt(n + 1)));
+      const cells = [];
+      let y = 0, i = 0;
+      while (i < n) {
+        const row = sides.slice(i, i + cols), rowH = Math.max(...row) + 2;
+        let x = 0;
+        for (const w of row) {
+          cells.push({ x, y });
+          x += w + 2;
+        }
+        y += rowH;
+        i += cols;
+      }
+      const totalW = Math.max(...cells.map((c, j) => c.x + sides[j])), totalH = y;
+      for (let j = 0; j < n; j++) {
+        let rect = { x: cells[j].x - Math.round(totalW / 2), y: cells[j].y - Math.round(totalH / 2), w: sides[j], h: sides[j] };
+        while (!fits(rect)) rect = { ...rect, x: rect.x + 1 };
+        out.push(rect);
+      }
+      return out;
+    }
+    case "strip": {
+      const total = sides.reduce((a, b) => a + b + 2, 0);
+      let x = Math.round(-total / 2) + 6;
+      for (let i = 0; i < n; i++) {
+        const wobble = Math.round((rnd() - 0.5) * 3);
+        push(x, wobble - Math.floor(sides[i] / 2), sides[i]);
+        x += sides[i] + 2;
+      }
+      return out;
+    }
+    case "terrace": {
+      let x = -Math.round(n * (maxSide + 1) / 2), y = -Math.round(n * (maxSide + 1) * 0.3);
+      for (let i = 0; i < n; i++) {
+        push(x, y, sides[i]);
+        x += sides[i] + 1;
+        y += Math.round(sides[i] * 0.6) + 1;
+      }
+      return out;
+    }
+    case "spine": {
+      let y = -Math.round(n * (maxSide + 2) / 4);
+      for (let i = 0; i < n; i++) {
+        const left = i % 2 === 0;
+        push(left ? -sides[i] - 3 : 3, y, sides[i]);
+        if (!left) y += maxSide + 2;
+      }
+      return out;
+    }
+    case "scatter": {
+      for (let i = 0; i < n; i++) {
+        let R = 5 + maxSide, placed = false;
+        for (let tries = 0; tries < 400 && !placed; tries++) {
+          const a = jitter + rnd() * Math.PI * 2, r = R * (0.5 + rnd() * 0.7);
+          const rect = { x: Math.round(Math.cos(a) * r), y: Math.round(Math.sin(a) * r * 0.8), w: sides[i], h: sides[i] };
+          if (fits(rect)) {
+            out.push(rect);
+            placed = true;
+          }
+          if (tries % 40 === 39) R += 2;
+        }
+        if (!placed) push(R + i * 2, 0, sides[i]);
+      }
+      return out;
+    }
+    default: {
+      let ring = 3;
+      for (let i = 0; i < n; i++) {
+        const side = sides[i], angle = jitter + i / Math.max(1, n) * Math.PI * 2;
+        let r = ring + side / 2, rect;
+        for (; ; ) {
+          const cx = Math.round(Math.cos(angle) * r), cy = Math.round(Math.sin(angle) * r * 0.8);
+          rect = { x: cx - Math.floor(side / 2), y: cy - Math.floor(side / 2), w: side, h: side };
+          if (fits(rect)) break;
+          r += 1;
+        }
+        out.push(rect);
+        ring = Math.max(ring, r - side / 2);
+      }
+      return out;
+    }
+  }
+}
+function hubFor(style, rects) {
+  if (!rects.length) return [-1, -1];
+  const minX = Math.min(...rects.map((r) => r.x)), minY = Math.min(...rects.map((r) => r.y));
+  switch (style) {
+    case "strip":
+      return [minX - 5, -1];
+    case "terrace":
+      return [minX - 5, minY - 1];
+    case "spine":
+      return [-1, minY - 5];
+    default:
+      return [-1, -1];
+  }
+}
+function layoutPaths(style, districts, forge, dock) {
+  const hub = [forge.gx + 1, forge.gy + 1];
+  const paths = [];
+  if (style === "strip" || style === "terrace") {
+    const ordered = [...districts].sort((a, b) => a.cx - b.cx || a.cy - b.cy);
+    let prev = hub, prevId = "forge";
+    for (const d of ordered) {
+      paths.push({ from: prevId, to: d.id, points: [prev, [d.cx, d.cy]] });
+      prev = [d.cx, d.cy];
+      prevId = d.id;
+    }
+  } else if (style === "grid" || style === "spine") {
+    for (const d of districts) paths.push({ from: d.id, to: "forge", points: [[d.cx, d.cy], [d.cx, hub[1]], hub] });
+  } else {
+    for (const d of districts) paths.push({ from: d.id, to: "forge", points: [[d.cx, d.cy], [Math.round((d.cx + hub[0]) / 2), Math.round((d.cy + hub[1]) / 2)], hub] });
+  }
+  paths.push({ from: "dock", to: "forge", points: [[dock.gx, dock.gy], hub] });
+  return paths;
+}
+function nearSpot(occ, cx, cy, ang, radius, fp) {
+  for (let r = radius; r < radius + 40; r++) {
+    for (let k = 0; k < 64; k++) {
+      const a = ang + (k % 2 ? 1 : -1) * Math.ceil(k / 2) * (Math.PI / 32);
+      const gx = Math.round(cx + Math.cos(a) * r), gy = Math.round(cy + Math.sin(a) * r * 0.85);
+      if (free(occ, gx, gy, fp)) return [gx, gy];
+    }
+  }
+  return [cx + radius, cy];
+}
+function edgeSpot(occ, d, hub, fp) {
+  const ang = Math.atan2(d.cy - hub.gy, d.cx - hub.gx);
+  const r0 = Math.ceil(Math.max(d.bounds.w, d.bounds.h) / 2) + 2;
+  return nearSpot(occ, d.cx, d.cy, ang, r0, fp);
+}
+var MoodTracker = class {
+  constructor(windowMs) {
+    this.windowMs = windowMs;
+  }
+  windowMs;
+  mood = "curious";
+  trouble = [];
+  recordTrouble(ts) {
+    this.trouble = this.trouble.filter((t) => ts - t <= this.windowMs);
+    this.trouble.push(ts);
+    return this.trouble.length >= 2;
+  }
+  onRead() {
+    return this.mood = this.mood === "lost" ? "lost" : "curious";
+  }
+  onBuild() {
+    return this.mood = this.mood === "lost" ? "lost" : "focused";
+  }
+  onFail(ts) {
+    return this.mood = this.recordTrouble(ts) ? "lost" : "uneasy";
+  }
+  onError(ts) {
+    return this.mood = this.recordTrouble(ts) ? "lost" : "uneasy";
+  }
+  onPass() {
+    this.trouble = [];
+    return this.mood = "happy";
+  }
+  onClaimUnverified() {
+    return this.mood = "uneasy";
+  }
+};
+var Director = class {
+  constructor(world, opts = {}) {
+    this.world = world;
+    for (const p of world.places) {
+      this.places.set(p.id, p);
+      if (p.path) this.byPath.set(p.path, p);
+    }
+    this.beacons = world.places.filter((p) => p.kind === "beacon");
+    this.forge = world.places.find((p) => p.kind === "forge") ?? world.places[0];
+    this.dock = world.places.find((p) => p.kind === "dock") ?? this.forge;
+    this.maxGap = opts.maxGapMs ?? 2500;
+    this.msPerCell = opts.walkMsPerCell ?? 90;
+    this.mood = new MoodTracker(opts.lostWindowMs ?? 9e4);
+    this.actorAt.set("pip", this.forge.id);
+  }
+  world;
+  places = /* @__PURE__ */ new Map();
+  byPath = /* @__PURE__ */ new Map();
+  beacons;
+  forge;
+  dock;
+  maxGap;
+  msPerCell;
+  mood;
+  beats = [];
+  sceneMs = 0;
+  lastRealTs = null;
+  seq = 0;
+  actorAt = /* @__PURE__ */ new Map();
+  helpers = /* @__PURE__ */ new Map();
+  gremlins = /* @__PURE__ */ new Map();
+  // gremlinId -> place
+  lastEdited = null;
+  pendingBeacon = null;
+  editedSinceTurn = false;
+  verifiedSinceEdit = false;
+  everVerified = false;
+  claimGremlin = null;
+  get timeline() {
+    return this.beats;
+  }
+  feed(e) {
+    const start = this.beats.length;
+    this.advanceClock(e.ts, e.id);
+    const actor = e.agentId && this.helpers.has(e.agentId) ? e.agentId : "pip";
+    switch (e.kind) {
+      case "session_start":
+        this.emit(e, actor, { kind: "curtain_up", repoId: e.repoId }, 1200);
+        break;
+      case "read_file": {
+        const p = this.placeFor(e.path, e, actor);
+        this.walk(e, actor, p);
+        this.emit(e, actor, { kind: "read", target: p.id }, clamp(700 + (e.bytes ?? 400) / 4, 900, 1800), this.mood.onRead());
+        break;
+      }
+      case "edit_file":
+      case "write_file": {
+        const p = this.placeFor(e.path, e, actor);
+        this.walk(e, actor, p);
+        const lines = e.kind === "edit_file" ? e.added + e.removed : e.added;
+        const intensity = clamp(Math.sqrt(lines / 50), 0.15, 1);
+        const g = [...this.gremlins].find(([, at]) => at === p.id);
+        if (g) this.emit(e, actor, { kind: "chase", gremlinId: g[0], target: p.id }, 900, this.mood.mood);
+        if (e.kind === "write_file" && e.created) this.emit(e, actor, { kind: "raise", target: p.id }, 900, this.mood.onBuild());
+        this.emit(e, actor, { kind: "build", target: p.id, intensity }, clamp(600 + intensity * 1900, 800, 2500), this.mood.onBuild());
+        this.lastEdited = p;
+        this.editedSinceTurn = true;
+        this.verifiedSinceEdit = false;
+        break;
+      }
+      case "run_command": {
+        if (e.intent === "test") {
+          const beacon = this.beaconFor(e.touched);
+          this.walk(e, actor, beacon);
+          this.pendingBeacon = beacon;
+          this.emit(e, actor, { kind: "run_tests", target: beacon.id }, clamp(e.durationMs ?? 1200, 900, 3e3), this.mood.mood);
+        } else if (e.intent === "search") {
+          this.emit(e, actor, { kind: "search", scope: "repo" }, 700, this.mood.onRead());
+        } else if (e.touched.length === 0 || e.intent === "git" || e.intent === "install" || e.intent === "build") {
+          this.walk(e, actor, this.forge);
+          const intensity = e.intent === "build" || e.intent === "install" ? 0.8 : e.intent === "git" ? 0.4 : 0.5;
+          this.emit(e, actor, { kind: "forge", intensity }, clamp(e.durationMs ?? 800, 700, 2e3), this.mood.mood);
+        }
+        if (!e.ok && e.intent !== "test") this.emit(e, actor, { kind: "stumble", retrying: false }, 600, this.mood.onError(e.ts));
+        break;
+      }
+      case "test_result": {
+        const beacon = this.pendingBeacon ?? this.beaconFor([]);
+        this.pendingBeacon = null;
+        const outcome = e.framework === "unknown" && e.passed === 0 && e.failed === 0 ? e.ok ? "pass" : "fail" : e.ok ? "pass" : "fail";
+        if (outcome === "pass") {
+          this.emit(e, actor, { kind: "test_outcome", target: beacon.id, outcome, passed: e.passed, failed: e.failed }, 800, this.mood.onPass());
+          if (e.passed > 0 || e.framework === "unknown") {
+            this.verifiedSinceEdit = true;
+            this.everVerified = true;
+          }
+          for (const [gid] of this.gremlins) this.emit(e, actor, { kind: "banish", gremlinId: gid }, 700, "happy");
+          this.gremlins.clear();
+          if (this.claimGremlin) {
+            this.emit(e, actor, { kind: "banish", gremlinId: this.claimGremlin }, 700, "happy");
+            this.claimGremlin = null;
+          }
+          this.emit(e, actor, { kind: "celebrate", target: beacon.id }, 1600, "happy");
+        } else {
+          this.emit(e, actor, { kind: "test_outcome", target: beacon.id, outcome, passed: e.passed, failed: e.failed }, 800, this.mood.onFail(e.ts));
+          const at = this.lastEdited ?? beacon;
+          const gid = `g:${e.id}`;
+          this.gremlins.set(gid, at.id);
+          this.emit(e, actor, { kind: "spawn_gremlin", gremlinId: gid, target: at.id }, 900, this.mood.mood);
+        }
+        break;
+      }
+      case "search":
+        this.emit(e, actor, { kind: "search", scope: e.scope }, 700, this.mood.onRead());
+        break;
+      case "subagent_start":
+        this.helpers.set(e.childId, e.label ? { label: e.label } : {});
+        this.actorAt.set(e.childId, this.dock.id);
+        this.emit(e, "pip", { kind: "summon_helper", helperId: e.childId, ...e.label ? { label: e.label } : {} }, 1400, this.mood.mood);
+        break;
+      case "subagent_stop":
+        if (this.helpers.has(e.childId)) {
+          this.emit(e, e.childId, { kind: "dismiss_helper", helperId: e.childId, ok: e.ok }, 1e3, this.mood.mood);
+          this.helpers.delete(e.childId);
+          this.actorAt.delete(e.childId);
+        }
+        break;
+      case "waiting_for_user":
+        if (e.reason === "idle") this.emit(e, actor, { kind: "your_turn" }, 1e3, this.mood.mood);
+        else this.emit(e, actor, { kind: "blocked_on_you", reason: e.reason }, 1200, this.mood.mood);
+        break;
+      case "error":
+        this.emit(e, actor, { kind: "stumble", retrying: e.retrying }, 700, this.mood.onError(e.ts));
+        break;
+      case "turn_end": {
+        if (e.claimedSuccess && this.editedSinceTurn && !this.verifiedSinceEdit) {
+          const gid = `claim:${e.id}`;
+          this.claimGremlin = gid;
+          this.emit(e, actor, { kind: "unverified_claim", gremlinId: gid }, 1400, this.mood.onClaimUnverified());
+        }
+        this.editedSinceTurn = false;
+        this.emit(e, actor, { kind: "your_turn" }, 1e3, this.mood.mood);
+        break;
+      }
+      case "session_end":
+        this.emit(e, actor, { kind: "curtain_down", verified: this.everVerified && !this.claimGremlin }, 1500, this.mood.mood);
+        break;
+    }
+    return this.beats.slice(start);
+  }
+  // ---- internals ----
+  advanceClock(ts, eventId) {
+    if (this.lastRealTs !== null) {
+      const lastEnd = this.beats.length ? Math.max(...this.beats.slice(-3).map((b) => b.atMs + b.durationMs)) : this.sceneMs;
+      const gap = Math.min(Math.max(0, ts - this.lastRealTs), this.maxGap);
+      const target = Math.max(lastEnd, this.sceneMs) + gap;
+      if (target - lastEnd >= 1e3) {
+        const idle = { id: `b${this.seq++}`, atMs: lastEnd, durationMs: target - lastEnd, realTs: this.lastRealTs, mood: this.mood.mood, actor: "pip", sourceEventIds: [eventId], kind: "idle" };
+        this.beats.push(idle);
+      }
+      this.sceneMs = Math.max(this.sceneMs, target);
+    }
+    this.lastRealTs = ts;
+  }
+  emit(e, actor, body, durationMs, mood = this.mood.mood) {
+    durationMs = Math.round(durationMs);
+    if ("intensity" in body) body = { ...body, intensity: Math.round(body.intensity * 1e3) / 1e3 };
+    const b = { id: `b${this.seq++}`, atMs: Math.round(this.sceneMs), durationMs, realTs: e.ts, mood, actor, sourceEventIds: [e.id], ...body };
+    this.beats.push(b);
+    this.sceneMs += durationMs;
+    return b;
+  }
+  walk(e, actor, to) {
+    const fromId = this.actorAt.get(actor) ?? this.forge.id;
+    if (fromId === to.id) return;
+    const from = this.places.get(fromId) ?? this.forge;
+    const cells = Math.hypot(to.gx - from.gx, to.gy - from.gy);
+    this.emit(e, actor, { kind: "walk_to", target: to.id }, clamp(Math.round(cells * this.msPerCell), 300, 2500));
+    this.actorAt.set(actor, to.id);
+  }
+  raised = 0;
+  /** Known place; else the district's overflow building; else (bounded) a new one raised for a file created mid-session. */
+  placeFor(path, e, actor) {
+    const known = this.byPath.get(path);
+    if (known) return known;
+    const top = path.includes("/") ? path.slice(0, path.indexOf("/")) : "";
+    const overflow = this.byPath.get(`${top ? top + "/" : ""}\u2026`);
+    if (overflow && (this.raised >= 24 || !this.world.stats.capped === false)) return overflow;
+    if (this.raised >= 24) return overflow ?? this.forge;
+    this.raised++;
+    const district = this.world.districts.find((d) => d.id === `d:${top}`) ?? this.world.districts[0];
+    const anchor = district ? { gx: district.cx, gy: district.cy } : { gx: this.forge.gx + 3, gy: this.forge.gy };
+    const place = { id: `p:${path}`, kind: kindOf(path), path, label: path.slice(path.lastIndexOf("/") + 1), district: district?.id ?? "", gx: anchor.gx, gy: anchor.gy, footprint: 1, height: 1, score: 0, touched: true };
+    this.places.set(place.id, place);
+    this.byPath.set(path, place);
+    if (place.kind === "beacon") this.beacons.push(place);
+    this.emit(e, actor, { kind: "raise", target: place.id, newPlace: { path, label: place.label, kind: place.kind, district: place.district } }, 900);
+    return place;
+  }
+  /** The beacon a test run belongs to: an explicitly touched test file, else the last-edited district's, else the first, else the forge. */
+  beaconFor(touched) {
+    const t = touched.find((p) => isTestPath(p));
+    if (t) {
+      const b = this.byPath.get(t);
+      if (b) return b;
+    }
+    if (this.lastEdited) {
+      const same = this.beacons.find((b) => b.district === this.lastEdited.district);
+      if (same) return same;
+    }
+    return this.beacons[0] ?? this.forge;
+  }
+};
+function direct(events, world, opts) {
+  const d = new Director(world, opts);
+  for (const e of events) d.feed(e);
+  return [...d.timeline];
+}
+var clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+function filesFromEvents(events) {
+  const loc = /* @__PURE__ */ new Map();
+  const bump = (p, n) => loc.set(p, (loc.get(p) ?? 0) + n);
+  for (const e of events) {
+    if (e.kind === "read_file") bump(e.path, Math.max(5, Math.round((e.bytes ?? 400) / 40)));
+    else if (e.kind === "edit_file") bump(e.path, Math.max(5, (e.added + e.removed) * 3));
+    else if (e.kind === "write_file") bump(e.path, Math.max(5, e.added * 2));
+    else if (e.kind === "run_command") for (const p of e.touched) bump(p, 5);
+  }
+  const touched = [...loc.keys()].sort((a, b) => loc.get(b) - loc.get(a));
+  return { files: touched.map((path) => ({ path, loc: loc.get(path) })), touched };
+}
 
 // src/sessions.ts
 import { readdirSync, readFileSync, statSync } from "fs";
@@ -191,14 +1303,13 @@ var Theatre = class {
     return `http://127.0.0.1:${this.port}/`;
   }
   get name() {
-    return basename(this.opts.cwd);
+    return basename2(this.opts.cwd);
   }
 };
 
 // src/scan.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
 import { join as join3, relative } from "path";
-import { isIgnoredPath } from "@agent-theatre/core";
 function scanRepo(root, opts = {}) {
   const maxFiles = opts.maxFiles ?? 2e4, maxBytes = opts.maxBytesForLoc ?? 512e3;
   const files = [];
@@ -269,9 +1380,9 @@ var HOOK_TIMEOUT_S = 5;
 function parse(existing) {
   if (existing === null || existing.trim() === "") return {};
   try {
-    const obj = JSON.parse(existing);
-    if (!obj || typeof obj !== "object" || Array.isArray(obj)) throw new Error("not an object");
-    return obj;
+    const obj4 = JSON.parse(existing);
+    if (!obj4 || typeof obj4 !== "object" || Array.isArray(obj4)) throw new Error("not an object");
+    return obj4;
   } catch {
     throw new Error("existing settings.json is not valid JSON; refusing to overwrite it");
   }
@@ -281,8 +1392,8 @@ var isOurs = (group) => {
   return Array.isArray(g?.hooks) && g.hooks.some((h) => typeof h?.command === "string" && h.command.includes(HOOK_MARKER));
 };
 function patchSettings(existing, scriptPath) {
-  const obj = parse(existing);
-  const hooks2 = obj.hooks ??= {};
+  const obj4 = parse(existing);
+  const hooks2 = obj4.hooks ??= {};
   const cmd = `node "${scriptPath}"`;
   let changed = false;
   for (const { event, matcher } of HOOK_EVENTS) {
@@ -298,12 +1409,12 @@ function patchSettings(existing, scriptPath) {
     list.push({ ...matcher ? { matcher } : {}, hooks: [{ type: "command", command: cmd, timeout: HOOK_TIMEOUT_S }] });
     changed = true;
   }
-  return { next: JSON.stringify(obj, null, 2) + "\n", changed };
+  return { next: JSON.stringify(obj4, null, 2) + "\n", changed };
 }
 function unpatchSettings(existing) {
-  const obj = parse(existing);
+  const obj4 = parse(existing);
   let changed = false;
-  const hooks2 = obj.hooks;
+  const hooks2 = obj4.hooks;
   if (hooks2) {
     for (const event of Object.keys(hooks2)) {
       const list = hooks2[event];
@@ -313,14 +1424,14 @@ function unpatchSettings(existing) {
       if (kept.length) hooks2[event] = kept;
       else delete hooks2[event];
     }
-    if (Object.keys(hooks2).length === 0) delete obj.hooks;
+    if (Object.keys(hooks2).length === 0) delete obj4.hooks;
   }
-  return { next: JSON.stringify(obj, null, 2) + "\n", changed };
+  return { next: JSON.stringify(obj4, null, 2) + "\n", changed };
 }
 function hasOurHooks(existing) {
   try {
-    const obj = parse(existing);
-    return Object.values(obj.hooks ?? {}).some((l) => Array.isArray(l) && l.some(isOurs));
+    const obj4 = parse(existing);
+    return Object.values(obj4.hooks ?? {}).some((l) => Array.isArray(l) && l.some(isOurs));
   } catch {
     return false;
   }
@@ -435,8 +1546,8 @@ program.command("replay [session]").description("replay a past Claude Code sessi
     const ans = (await rl.question(`
 Which one? [1] `)).trim() || "1";
     rl.close();
-    const pick = sessions[Math.max(0, Math.min(sessions.length - 1, (parseInt(ans, 10) || 1) - 1))];
-    id = pick.id;
+    const pick2 = sessions[Math.max(0, Math.min(sessions.length - 1, (parseInt(ans, 10) || 1) - 1))];
+    id = pick2.id;
   }
   const found = sessions.find((s) => s.id === id || s.id.startsWith(id));
   if (!found) {