agent-theatre 1.3.9 → 1.4.0

package/dist/chunk-WAD5QXS2.js

@@ -0,0 +1,1614 @@
+#!/usr/bin/env node
+
+// src/sessions.ts
+import { readdirSync, readFileSync, statSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function projectSlug(cwd) {
+  return cwd.replace(/[^A-Za-z0-9]/g, "-");
+}
+function claudeConfigDir(env = process.env) {
+  return env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+}
+function listSessions(cwd, env = process.env) {
+  const dir = join(claudeConfigDir(env), "projects", projectSlug(cwd));
+  let names = [];
+  try {
+    names = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const f of names) {
+    const path = join(dir, f);
+    try {
+      const st = statSync(path);
+      out.push({ id: f.replace(/\.jsonl$/, ""), path, mtime: st.mtimeMs, bytes: st.size, title: sessionTitle(path) });
+    } catch {
+    }
+  }
+  return out.sort((a, b) => b.mtime - a.mtime);
+}
+function sessionTitle(path) {
+  let text = "";
+  try {
+    const st = statSync(path);
+    const fd = readFileSync(path);
+    text = fd.subarray(Math.max(0, st.size - 262144)).toString("utf8");
+  } catch {
+    return "";
+  }
+  let ai = "", prompt = "";
+  for (const line of text.split("\n")) {
+    if (!line.includes('"aiTitle"') && !line.includes('"lastPrompt"')) continue;
+    try {
+      const row = JSON.parse(line);
+      if (typeof row.aiTitle === "string" && row.aiTitle.trim()) ai = row.aiTitle.trim();
+      if (typeof row.lastPrompt === "string" && row.lastPrompt.trim()) prompt = row.lastPrompt.trim();
+    } catch {
+    }
+  }
+  const t = ai || prompt;
+  return t.length > 80 ? t.slice(0, 77) + "\u2026" : t;
+}
+
+// src/server.ts
+import { createServer } from "http";
+import { existsSync, mkdirSync, readFileSync as readFileSync2, readdirSync as readdirSync2, rmSync, writeFileSync, realpathSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2, basename as basename2, resolve, sep } from "path";
+import { spawnSync } from "child_process";
+import { Hono } from "hono";
+import { getRequestListener } from "@hono/node-server";
+import { WebSocketServer } from "ws";
+
+// ../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 segments = command.split(/\s*(?:&&|\|\||;|\|)\s*/);
+  const first = (segments.find((s) => !/^\s*(\[|test\b|!)/.test(s)) ?? segments[0] ?? "").replace(/^\s*!\s*/, "");
+  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 withoutHeredocBodies(command) {
+  return command.replace(/<<-?\s*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\1[^\n]*\n[\s\S]*?\n\s*\2(?=\s*(?:\n|$))/g, (m) => m.split("\n")[0] ?? "");
+}
+var plausibleFile = (t) => /[A-Za-z/.]/.test(t) && !/^\d+$/.test(t) && !/[()]$/.test(t);
+function extractWrites(commandRaw) {
+  const command = withoutHeredocBodies(commandRaw);
+  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 && plausibleFile(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 obj2 = (x) => x && typeof x === "object" ? x : {};
+var str2 = (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 = obj2(payload);
+  const name = str2(p.hook_event_name);
+  const sessionId = str2(p.session_id) ?? "";
+  const ts = opts.now ?? Date.now();
+  if (!name) return { events: [], warnings: [{ code: "missing_field", detail: "hook_event_name" }] };
+  const cwd = str2(p.cwd) ?? "";
+  const ctx = { cwd, ...opts.home ? { home: opts.home } : {} };
+  const agentId = TOOL_EVENTS.has(name) ? str2(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(str2(p.reason)), claimedSuccess: false });
+    case "Stop":
+      return one({ kind: "turn_end", claimedSuccess: claimsSuccess(str2(p.last_assistant_message)), ...noteOf(str2(p.last_assistant_message)) });
+    case "SubagentStart": {
+      const id = str2(p.agent_id) ?? "";
+      const label = str2(p.agent_type);
+      return { events: [mk({ kind: "subagent_start", childId: id, ...label ? { label } : {} })], warnings: [] };
+    }
+    case "SubagentStop":
+      return one({ kind: "subagent_stop", childId: str2(p.agent_id) ?? "", ok: true });
+    case "Notification": {
+      const t = str2(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: str2(p.tool_name) ?? "tool", retrying: false });
+    case "PostToolUse": {
+      const tool = str2(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 = str2(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 noteOf(text) {
+  if (!text) return {};
+  const clean = text.replace(/```[\s\S]*?```/g, " ").replace(/`([^`]*)`/g, "$1").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/\*+|#+|>+/g, "").replace(/(^|\s)_+|_+(?=\s|$)/g, "$1").replace(/^\s*(?:[-•]|\d+[.)])\s+/gm, "").replace(/\s+/g, " ").trim();
+  if (!clean) return {};
+  const sentences = clean.split(/(?<=[.!?])\s+(?=["'(A-Z])/).map((x) => x.trim()).filter(Boolean);
+  if (!sentences.length) return {};
+  const questions = sentences.filter((x) => x.endsWith("?"));
+  let note = questions.length ? questions[questions.length - 1] : sentences[0];
+  if (!questions.length) for (const raw of sentences.slice(1)) {
+    const next = /[.!?]$/.test(raw) ? raw : raw.replace(/[^.!?]*$/, "").trim();
+    if (!next || note.length + next.length + 1 > 160) break;
+    note = `${note} ${next}`;
+  }
+  if (note.length > 200) note = note.slice(0, 197).replace(/\s+\S*$/, "") + "\u2026";
+  return { note };
+}
+var ROW_TYPES = /* @__PURE__ */ new Set(["user", "assistant", "system"]);
+var obj3 = (x) => x && typeof x === "object" ? x : {};
+var str3 = (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 = str3(row.timestamp);
+    const n = t ? Date.parse(t) : Number.NaN;
+    return Number.isFinite(n) ? n : Number.isFinite(lastTs) ? lastTs : 0;
+  };
+  const agentOf = (row) => str3(row.agentId) ?? (row.isSidechain === true ? opts.sidechainAgentId ?? "sidechain" : void 0);
+  for (const raw of rows) {
+    const row = obj3(raw);
+    const type = str3(row.type) ?? "";
+    if (!ROW_TYPES.has(type)) {
+      if (type) unknownTypes.add(type);
+      continue;
+    }
+    if (!sessionId && str3(row.sessionId)) sessionId = str3(row.sessionId);
+    if (!cwd && str3(row.cwd)) cwd = str3(row.cwd);
+    if (!branch && str3(row.gitBranch)) branch = str3(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 = obj3(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, str3(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 = obj3(b);
+        if (block.type === "tool_use" && str3(block.id) && str3(block.name)) {
+          pending.set(str3(block.id), { name: str3(block.name), input: block.input, ts, ...agentId ? { agentId } : {} });
+        } else if (block.type === "text" && !agentId) {
+          const t = str3(block.text);
+          if (t) lastAssistantText = t;
+        }
+      }
+      if (typeof content === "string" && !agentId) lastAssistantText = content;
+      if (message.stop_reason === "end_turn" && !agentId) {
+        push(ts, `${str3(row.uuid) ?? seq}:turn`, { kind: "turn_end", claimedSuccess: claimsSuccess(lastAssistantText), ...noteOf(lastAssistantText) });
+      }
+      continue;
+    }
+    if (row.toolDenialKind !== void 0) push(ts, `${str3(row.uuid) ?? seq}:deny`, { kind: "waiting_for_user", reason: "permission" });
+    const blocks = Array.isArray(content) ? content : [];
+    for (const b of blocks) {
+      const block = obj3(b);
+      if (block.type !== "tool_result") continue;
+      const useId = str3(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, `${str3(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 };
+}
+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 pkg = (manifests["package.json"] ?? "").toLowerCase();
+  const py = ((manifests["pyproject.toml"] ?? "") + (manifests["requirements.txt"] ?? "")).toLowerCase();
+  const dep = (re) => re.test(pkg) || 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 (pkg.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 (pkg.includes('"main"') && !pkg.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 ?? 150;
+    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", ...e.note ? { note: e.note } : {} }, 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), 700, 3500));
+    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/server.ts
+var Theatre = class {
+  constructor(opts) {
+    this.opts = opts;
+    const world = generateWorld({ repoId: opts.repoId, files: opts.files });
+    this.live = { world, director: new Director(world), events: [], beats: [], lastEventAt: 0, sessionOpen: false };
+    this.routes();
+  }
+  opts;
+  app = new Hono();
+  server = null;
+  wss = null;
+  live;
+  signal = "ok";
+  /** The most recent cwd of a Claude Code session that is NOT this repo (so an empty stage can point the person there). */
+  elsewhere = null;
+  openSessions = /* @__PURE__ */ new Set();
+  seen = /* @__PURE__ */ new Set();
+  timer = null;
+  port = 0;
+  routes() {
+    const a = this.app;
+    a.post("/hook", async (c) => {
+      let payload;
+      try {
+        payload = await c.req.json();
+      } catch {
+        return c.body(null, 204);
+      }
+      const cwd = typeof payload?.cwd === "string" ? payload.cwd : "";
+      if (cwd && !isWithin(cwd, this.opts.cwd)) {
+        if (this.elsewhere !== cwd) {
+          this.elsewhere = cwd;
+          this.broadcast({ type: "elsewhere", cwd });
+        }
+        return c.body(null, 204);
+      }
+      const sid = payload.session_id;
+      const hookName = payload.hook_event_name;
+      if (typeof sid === "string" && sid) {
+        if (hookName === "SessionEnd") this.openSessions.delete(sid);
+        else this.openSessions.add(sid);
+      }
+      let { events } = hookPayloadToEvents(payload, { home: homedir2() });
+      events = events.filter((e) => {
+        if (this.seen.has(e.id)) return false;
+        this.seen.add(e.id);
+        if (this.seen.size > 5e3) {
+          const first = this.seen.values().next().value;
+          if (first !== void 0) this.seen.delete(first);
+        }
+        return true;
+      });
+      if (this.openSessions.size > 0) events = events.filter((e) => e.kind !== "session_end");
+      if (events.length) this.ingest(events);
+      return c.body(null, 204);
+    });
+    const cors = { "access-control-allow-origin": "*", "access-control-allow-headers": "content-type", "access-control-allow-methods": "GET, POST, OPTIONS", "access-control-allow-private-network": "true" };
+    a.use("/api/*", async (c, next) => {
+      await next();
+      for (const [k, v] of Object.entries(cors)) c.res.headers.set(k, v);
+    });
+    a.options("/api/*", (c) => c.body(null, 204, cors));
+    a.get("/api/scene", (c) => c.json(this.scene()));
+    a.get("/api/sessions", (c) => c.json(listSessions(this.opts.cwd).map((s) => ({ id: s.id, title: s.title, mtime: s.mtime, bytes: s.bytes }))));
+    a.get("/api/replay/:id", (c) => {
+      const id = c.req.param("id");
+      const s = listSessions(this.opts.cwd).find((x) => x.id === id);
+      if (!s) return c.json({ error: "no such session" }, 404);
+      const { events, warnings } = parseTranscript(readFileSync2(s.path, "utf8"), { home: homedir2() });
+      const inferred = filesFromEvents(events);
+      const known = new Set(this.opts.files.map((f) => f.path));
+      const files = [...this.opts.files, ...inferred.files.filter((f) => !known.has(f.path))];
+      const world = generateWorld({ repoId: this.opts.repoId, files, touched: inferred.touched });
+      const beats = direct(events, world);
+      return c.json({ mode: "replay", repoId: this.opts.repoId, title: s.title, world, events, beats, warnings: warnings.length });
+    });
+    a.get("/healthz", (c) => c.json({ ok: true, port: this.port, events: this.live.events.length }));
+    if (this.opts.webDir) {
+      const dir = this.opts.webDir;
+      a.get("/*", (c) => {
+        const p = c.req.path === "/" ? "/index.html" : c.req.path;
+        const file = join2(dir, p);
+        if (!file.startsWith(dir) || !existsSync(file)) return c.text("not found", 404);
+        const ext = p.slice(p.lastIndexOf(".") + 1);
+        const type = { html: "text/html; charset=utf-8", js: "text/javascript", css: "text/css", json: "application/json", jsonl: "application/x-ndjson", svg: "image/svg+xml", png: "image/png", woff2: "font/woff2", webp: "image/webp" };
+        return c.body(readFileSync2(file), 200, { "content-type": type[ext] ?? "application/octet-stream", "cache-control": p.includes("/assets/") ? "public, max-age=31536000, immutable" : "no-cache" });
+      });
+    }
+  }
+  /** Append events to the live session, direct them, and broadcast. */
+  ingest(events) {
+    const l = this.live;
+    const out = [];
+    for (const e of events) {
+      if (e.kind === "session_start") l.sessionOpen = true;
+      if (e.kind === "session_end") l.sessionOpen = false;
+      l.events.push(e);
+      out.push(...l.director.feed(e));
+    }
+    l.beats.push(...out);
+    l.lastEventAt = Date.now();
+    if (this.signal !== "ok") {
+      this.signal = "ok";
+      this.broadcast({ type: "signal", state: "ok" });
+    }
+    this.broadcast({ type: "beats", beats: out, events });
+    return out;
+  }
+  /** In-process subscribers (the VS Code extension relays these to its webview). */
+  listeners = /* @__PURE__ */ new Set();
+  broadcast(msg) {
+    for (const l of this.listeners) {
+      try {
+        l(msg);
+      } catch {
+      }
+    }
+    const data = JSON.stringify(msg);
+    for (const ws of this.wss?.clients ?? []) if (ws.readyState === 1) ws.send(data);
+  }
+  async listen(port = 0) {
+    const listener = getRequestListener(this.app.fetch);
+    this.server = createServer(listener);
+    this.wss = new WebSocketServer({ noServer: true });
+    this.server.on("upgrade", (req, socket, head) => {
+      if (req.url?.startsWith("/live")) this.wss.handleUpgrade(req, socket, head, (ws) => {
+        this.wss.emit("connection", ws, req);
+        ws.send(JSON.stringify({ type: "hello", signal: this.signal }));
+      });
+      else socket.destroy();
+    });
+    await new Promise((res) => this.server.listen(port, "127.0.0.1", res));
+    const addr = this.server.address();
+    this.port = typeof addr === "object" && addr ? addr.port : port;
+    const home = this.opts.home ?? join2(homedir2(), ".agent-theatre");
+    mkdirSync(home, { recursive: true });
+    try {
+      const old = parseInt(readFileSync2(join2(home, "port"), "utf8").trim(), 10);
+      if (old > 0 && old !== this.port && portAlive(old) && !existsSync(join2(home, "ports", String(old)))) {
+        mkdirSync(join2(home, "ports"), { recursive: true });
+        writeFileSync(join2(home, "ports", String(old)), "(started by an older build)");
+      }
+    } catch {
+    }
+    writeFileSync(join2(home, "port"), String(this.port));
+    mkdirSync(join2(home, "ports"), { recursive: true });
+    for (const f of readdirSync2(join2(home, "ports"))) {
+      const n = parseInt(f, 10);
+      if (n > 0 && n !== this.port && !portAlive(n)) {
+        try {
+          rmSync(join2(home, "ports", f));
+        } catch {
+        }
+      }
+    }
+    writeFileSync(join2(home, "ports", String(this.port)), this.opts.cwd);
+    const lostAfter = this.opts.lostAfterMs ?? 9e4;
+    this.timer = setInterval(() => {
+      const l = this.live;
+      if (l.sessionOpen && l.lastEventAt && Date.now() - l.lastEventAt > lostAfter && this.signal === "ok") {
+        this.signal = "lost";
+        this.broadcast({ type: "signal", state: "lost" });
+      }
+    }, 5e3);
+    this.timer.unref();
+    return this.port;
+  }
+  async close() {
+    if (this.timer) clearInterval(this.timer);
+    const home = this.opts.home ?? join2(homedir2(), ".agent-theatre");
+    try {
+      if (readFileSync2(join2(home, "port"), "utf8").trim() === String(this.port)) rmSync(join2(home, "port"));
+    } catch {
+    }
+    try {
+      rmSync(join2(home, "ports", String(this.port)));
+    } catch {
+    }
+    for (const ws of this.wss?.clients ?? []) ws.close();
+    this.wss?.close();
+    await new Promise((res) => this.server ? this.server.close(() => res()) : res());
+  }
+  /** The live scene as /api/scene returns it. */
+  scene() {
+    return { mode: "live", repoId: this.opts.repoId, cwd: this.opts.cwd, elsewhere: this.elsewhere, world: this.live.world, events: this.live.events, beats: this.live.beats, signal: this.signal };
+  }
+  get url() {
+    return `http://127.0.0.1:${this.port}/`;
+  }
+  get name() {
+    return basename2(this.opts.cwd);
+  }
+};
+function isWithin(dir, root) {
+  const norm3 = (p) => {
+    try {
+      return realpathSync(p);
+    } catch {
+      return resolve(p);
+    }
+  };
+  const d = norm3(dir), r = norm3(root);
+  return d === r || d.startsWith(r.endsWith(sep) ? r : r + sep);
+}
+function portAlive(port) {
+  const r = spawnSync("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], { encoding: "utf8", timeout: 2e3 });
+  if (r.status === 0 && r.stdout.trim()) return true;
+  if (r.error) return true;
+  return false;
+}
+
+// src/scan.ts
+import { readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { join as join3, relative } from "path";
+function scanRepo(root, opts = {}) {
+  const maxFiles = opts.maxFiles ?? 2e4, maxBytes = opts.maxBytesForLoc ?? 512e3;
+  const files = [];
+  const walk = (dir) => {
+    if (files.length >= maxFiles) return;
+    let ents;
+    try {
+      ents = readdirSync3(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of ents) {
+      if (files.length >= maxFiles) return;
+      const full = join3(dir, ent.name);
+      const rel = relative(root, full).replace(/\\/g, "/");
+      if (isIgnoredPath(rel + (ent.isDirectory() ? "/" : ""))) continue;
+      if (ent.isDirectory()) walk(full);
+      else if (ent.isFile()) {
+        let size = 0;
+        try {
+          size = statSync2(full).size;
+        } catch {
+          continue;
+        }
+        let loc;
+        if (size < maxBytes) {
+          try {
+            const buf = readFileSync3(full);
+            if (!buf.subarray(0, 1024).includes(0)) loc = buf.toString("utf8").split("\n").length;
+          } catch {
+          }
+        }
+        files.push({ path: rel, size, ...loc !== void 0 ? { loc } : {} });
+      }
+    }
+  };
+  walk(root);
+  return files;
+}
+function repoIdFor(root) {
+  try {
+    const cfg = readFileSync3(join3(root, ".git", "config"), "utf8");
+    const m = /\[remote "origin"\]\s*\n\s*url\s*=\s*(\S+)/.exec(cfg);
+    if (m) return m[1].replace(/\.git$/, "").replace(/^git@([^:]+):/, "$1/").replace(/^https?:\/\//, "");
+  } catch {
+  }
+  return root;
+}
+
+// src/hooks/install.ts
+import { chmodSync, copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+
+// src/hooks/patch.ts
+var HOOK_MARKER = "agent-theatre-hook.mjs";
+var HOOK_EVENTS = [
+  { event: "SessionStart" },
+  { event: "PostToolUse" },
+  { event: "PostToolUseFailure" },
+  { event: "SubagentStart" },
+  { event: "SubagentStop" },
+  { event: "Notification" },
+  { event: "Stop" },
+  { event: "SessionEnd" }
+];
+var HOOK_TIMEOUT_S = 5;
+function parse(existing) {
+  if (existing === null || existing.trim() === "") return {};
+  try {
+    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");
+  }
+}
+var isOurs = (group) => {
+  const g = group;
+  return Array.isArray(g?.hooks) && g.hooks.some((h) => typeof h?.command === "string" && h.command.includes(HOOK_MARKER));
+};
+function patchSettings(existing, scriptPath) {
+  const obj4 = parse(existing);
+  const hooks = obj4.hooks ??= {};
+  const cmd = `node "${scriptPath}"`;
+  let changed = false;
+  for (const { event, matcher } of HOOK_EVENTS) {
+    const list = hooks[event] ??= [];
+    const mine = list.find(isOurs);
+    if (mine) {
+      for (const h of mine.hooks) if (h.command.includes(HOOK_MARKER) && h.command !== cmd) {
+        h.command = cmd;
+        changed = true;
+      }
+      continue;
+    }
+    list.push({ ...matcher ? { matcher } : {}, hooks: [{ type: "command", command: cmd, timeout: HOOK_TIMEOUT_S }] });
+    changed = true;
+  }
+  return { next: JSON.stringify(obj4, null, 2) + "\n", changed };
+}
+function unpatchSettings(existing) {
+  const obj4 = parse(existing);
+  let changed = false;
+  const hooks = obj4.hooks;
+  if (hooks) {
+    for (const event of Object.keys(hooks)) {
+      const list = hooks[event];
+      if (!Array.isArray(list)) continue;
+      const kept = list.filter((g) => !isOurs(g));
+      if (kept.length !== list.length) changed = true;
+      if (kept.length) hooks[event] = kept;
+      else delete hooks[event];
+    }
+    if (Object.keys(hooks).length === 0) delete obj4.hooks;
+  }
+  return { next: JSON.stringify(obj4, null, 2) + "\n", changed };
+}
+function hasOurHooks(existing) {
+  try {
+    const obj4 = parse(existing);
+    return Object.values(obj4.hooks ?? {}).some((l) => Array.isArray(l) && l.some(isOurs));
+  } catch {
+    return false;
+  }
+}
+
+// src/hooks/script.ts
+var HOOK_SCRIPT = `#!/usr/bin/env node
+// Agent Theatre hook \u2014 forwards Claude Code events to the local theatre. Never blocks the agent.
+import { readFileSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// Every running stage registers itself in ports/<port>; the event goes to all of them (browser, VS Code, a second repo\u2026).
+const home = process.env.AGENT_THEATRE_HOME || join(homedir(), ".agent-theatre");
+const ports = new Set();
+try { for (const f of readdirSync(join(home, "ports"))) { const n = parseInt(f, 10); if (n > 0) ports.add(n); } } catch { /* no registry yet */ }
+try { const n = parseInt(readFileSync(join(home, "port"), "utf8").trim(), 10); if (n > 0) ports.add(n); } catch { /* no port file */ }
+if (!ports.size) process.exit(0);
+let body = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (c) => { body += c; if (body.length > 2_000_000) body = body.slice(0, 2_000_000); });
+process.stdin.on("end", async () => {
+  try {
+    await Promise.allSettled([...ports].map((port) => fetch(\`http://127.0.0.1:\${port}/hook\`, { method: "POST", headers: { "content-type": "application/json" }, body, signal: AbortSignal.timeout(300) })));
+  } catch { /* a theatre not running or slow: that is fine */ }
+  process.exit(0);
+});
+setTimeout(() => process.exit(0), 600).unref();
+`;
+
+// src/hooks/install.ts
+function installPaths(env = process.env) {
+  const claude = env.CLAUDE_CONFIG_DIR || join4(homedir3(), ".claude");
+  const home = env.AGENT_THEATRE_HOME || join4(homedir3(), ".agent-theatre");
+  const settings = join4(claude, "settings.json");
+  return { settings, home, script: join4(home, "hooks", "agent-theatre-hook.mjs"), backup: `${settings}.bak-agent-theatre` };
+}
+var read = (p) => existsSync2(p) ? readFileSync4(p, "utf8") : null;
+function installHooks(paths = installPaths()) {
+  mkdirSync2(join4(paths.home, "hooks"), { recursive: true });
+  writeFileSync2(paths.script, HOOK_SCRIPT, { mode: 493 });
+  chmodSync(paths.script, 493);
+  const existing = read(paths.settings);
+  const { next, changed } = patchSettings(existing, paths.script);
+  let backup = null;
+  if (changed) {
+    if (existing !== null) {
+      copyFileSync(paths.settings, paths.backup);
+      backup = paths.backup;
+    }
+    mkdirSync2(join4(paths.settings, ".."), { recursive: true });
+    writeFileSync2(paths.settings, next);
+  }
+  return { changed, backup };
+}
+function uninstallHooks(paths = installPaths()) {
+  const existing = read(paths.settings);
+  if (existing === null) return { changed: false };
+  const { next, changed } = unpatchSettings(existing);
+  if (changed) {
+    copyFileSync(paths.settings, paths.backup);
+    writeFileSync2(paths.settings, next);
+  }
+  return { changed };
+}
+function hooksStatus(paths = installPaths()) {
+  return { installed: hasOurHooks(read(paths.settings)), scriptPresent: existsSync2(paths.script), settings: paths.settings };
+}
+
+export {
+  listSessions,
+  Theatre,
+  scanRepo,
+  repoIdFor,
+  installHooks,
+  uninstallHooks,
+  hooksStatus
+};
+//# sourceMappingURL=chunk-WAD5QXS2.js.map