cubefarm 0.2.0 → 0.3.1

package/dist-server/index.js

@@ -1,7 +1,7 @@
 // server/index.ts
 import http2 from "node:http";
-import path8 from "node:path";
-import fs6 from "node:fs";
+import path13 from "node:path";
+import fs11 from "node:fs";
 import express from "express";
 import { WebSocketServer } from "ws";
 
@@ -474,20 +474,38 @@ function removeDesk(fullName, agentSlug) {
   });
 }
 var LAUNCHERS = ["node.exe", "cmd.exe", "bash.exe", "sh.exe", "conhost.exe", "python.exe", "npm.exe", "npx.exe", "bun.exe", "deno.exe"];
-async function releaseDesk(fullName, agentSlug, port) {
+var pathForms = (p) => [.../* @__PURE__ */ new Set([p, p.replaceAll("\\", "/"), p.replaceAll("\\", "\\\\")])];
+function leftoversInDesk(listing, desk, keep) {
+  const out = [];
+  for (const line of listing.split("\n")) {
+    const m = line.trim().match(/^(\d+)\s+(.*)$/);
+    if (!m) continue;
+    const [pid, args] = [Number(m[1]), m[2]];
+    if (keep.pids.includes(pid) || keep.markers.some((mark) => pathForms(mark).some((f) => args.includes(f)))) continue;
+    if (pathForms(desk).some((f) => args.includes(f))) out.push(pid);
+  }
+  return out;
+}
+async function releaseDesk(fullName, agentSlug, port, keep = { pids: [], markers: [] }) {
   const desk = deskDir(fullName, agentSlug);
+  const spare = [process.pid, ...keep.pids];
   if (process.platform === "win32") {
-    const variants = [desk, desk.replaceAll("\\", "/")].map((d) => `'${d.toLowerCase().replaceAll("'", "''")}'`).join(", ");
+    const psList = (paths) => paths.flatMap(pathForms).map((d) => `'${d.toLowerCase().replaceAll("'", "''")}'`).join(", ");
     const script = `
 $ErrorActionPreference = 'SilentlyContinue'
+$spare = @(${spare.join(", ")})
 $seed = @()
 Get-NetTCPConnection -LocalPort ${port} -State Listen | ForEach-Object { $seed += [int]$_.OwningProcess }
-$desks = @(${variants})
+$desks = @(${psList([desk])})
+$marks = @(${psList(keep.markers)})
 $all = Get-CimInstance Win32_Process
 $byId = @{}; foreach ($p in $all) { $byId[[int]$p.ProcessId] = $p }
 foreach ($p in $all) {
   if (-not $p.CommandLine) { continue }
   $cmd = $p.CommandLine.ToLower()
+  $ours = $false
+  foreach ($m in $marks) { if ($cmd.Contains($m)) { $ours = $true } }
+  if ($ours) { continue }
   foreach ($d in $desks) { if ($cmd.Contains($d)) { $seed += [int]$p.ProcessId } }
 }
 $launchers = @(${LAUNCHERS.map((n) => `'${n}'`).join(", ")})
@@ -495,7 +513,7 @@ $kill = New-Object 'System.Collections.Generic.HashSet[int]'
 foreach ($id in $seed) {
   $cur = $byId[$id]
   $first = $true
-  while ($cur -and [int]$cur.ProcessId -ne ${process.pid} -and ($first -or $launchers -contains $cur.Name.ToLower())) {
+  while ($cur -and -not ($spare -contains [int]$cur.ProcessId) -and ($first -or $launchers -contains $cur.Name.ToLower())) {
     [void]$kill.Add([int]$cur.ProcessId)
     $first = $false
     $cur = $byId[[int]$cur.ParentProcessId]
@@ -506,8 +524,11 @@ Write-Output $kill.Count`;
     await run("powershell", ["-NoProfile", "-NonInteractive", "-Command", script], { timeoutMs: 3e4 }).catch(() => void 0);
     return;
   }
-  const pids = await run("sh", ["-c", `lsof -ti tcp:${port} -sTCP:LISTEN 2>/dev/null; pgrep -f ${JSON.stringify(desk)} 2>/dev/null`]).catch(() => "");
-  for (const pid of pids.split(/\s+/).map(Number).filter((p) => p && p !== process.pid)) {
+  const listening = await run("sh", ["-c", `lsof -ti tcp:${port} -sTCP:LISTEN 2>/dev/null || true`]).catch(() => "");
+  const listing = await run("ps", ["-A", "-ww", "-o", "pid=,args="]).catch(() => "");
+  const pids = /* @__PURE__ */ new Set([...listening.split(/\s+/).map(Number), ...leftoversInDesk(listing, desk, keep)]);
+  for (const pid of pids) {
+    if (!pid || spare.includes(pid)) continue;
     try {
       process.kill(pid, "SIGKILL");
     } catch {
@@ -516,6 +537,7 @@ Write-Output $kill.Count`;
 }
 
 // server/agentRunner.ts
+import fs3 from "node:fs";
 import path3 from "node:path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 var InputQueue = class {
@@ -544,54 +566,43 @@ var InputQueue = class {
     };
   }
 };
-var WRITE_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
-var BLOCKED_COMMANDS = [
-  { re: /\bgit\s+push\b[^\n]*(\s--force\b|\s-f\b|\s--force-with-lease\b|\s\+\S)/, why: "force-pushing is not allowed" },
-  { re: /\bgh\s+pr\s+merge\b/, why: "the office merges pull requests once QA and the checks pass, not agents" },
-  { re: /\bgh\s+(repo\s+(delete|edit|rename|archive)|secret|auth|release\s+delete|api\s+-X\s*DELETE)\b/, why: "repository administration is off-limits" },
-  { re: /\brm\s+-[a-zA-Z]*r[a-zA-Z]*f?\s+(\/|~|[A-Za-z]:[\\/]?)(\s|$)/, why: "deleting a filesystem root is not allowed" },
-  { re: /\b(shutdown|format\s+[a-z]:|mkfs|Remove-Item\s+[^\n]*-Recurse[^\n]*[A-Za-z]:\\\s*$)/i, why: "destructive system command" },
-  { re: /\bgit\s+worktree\b/, why: "worktrees are managed by the swarm" }
-];
-function isInside(child, parent) {
-  const rel2 = path3.relative(parent, child);
-  return rel2 === "" || !rel2.startsWith("..") && !path3.isAbsolute(rel2);
+var allowAll = async (_toolName, input) => ({ behavior: "allow", updatedInput: input });
+function screenshotFile(cwd, text) {
+  const file = text.match(/\]\(([^)\s]+\.(png|jpe?g))\)/i);
+  if (!file) return null;
+  try {
+    return { data: fs3.readFileSync(path3.resolve(cwd, file[1])), mime: /png$/i.test(file[2]) ? "image/png" : "image/jpeg" };
+  } catch {
+    return null;
+  }
 }
-var QA_BLOCKED = [
-  { re: /\bgit\s+push\b/, why: "QA testers do not push code" },
-  { re: /\bgh\s+(pr|issue)\s+(merge|close|reopen|review|comment|edit|ready|create)\b/, why: "QA testers report back to the office instead of changing PRs or issues" }
-];
-function guardedCanUseTool(cwd, defaultBranchPush, role) {
-  return async (toolName, input, { blockedPath }) => {
-    if (toolName.startsWith("mcp__") && !toolName.startsWith("mcp__playwright__") && !(role === "ceo" && toolName.startsWith("mcp__office__"))) {
-      return { behavior: "deny", message: "Only the Playwright browser tools are available to swarm agents." };
-    }
-    if (WRITE_TOOLS.has(toolName)) {
-      const target = String(input.file_path ?? input.notebook_path ?? "");
-      if (target && !isInside(path3.resolve(cwd, target), cwd)) {
-        return { behavior: "deny", message: `You may only edit files inside your worktree (${cwd}).` };
-      }
-    }
-    if (toolName === "Bash" || toolName === "PowerShell") {
-      const cmd = String(input.command ?? "");
-      for (const rule of role === "qa" ? [...BLOCKED_COMMANDS, ...QA_BLOCKED] : BLOCKED_COMMANDS) {
-        if (rule.re.test(cmd)) return { behavior: "deny", message: `Blocked by cubefarm: ${rule.why}.` };
-      }
-      if (defaultBranchPush.test(cmd)) {
-        return { behavior: "deny", message: "Push your own branch and open a PR; pushing to the default branch is not allowed." };
-      }
-      if (blockedPath && /\b(rm|del|rmdir|mv|move|Remove-Item)\b/i.test(cmd) && !isInside(path3.resolve(blockedPath), cwd)) {
-        return { behavior: "deny", message: `That command touches ${blockedPath}, which is outside your worktree.` };
-      }
+var IMAGE_MIME = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg" };
+function newScreenshots(dir, seen, now2 = Date.now()) {
+  let names;
+  try {
+    names = fs3.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const found2 = [];
+  for (const name of names.sort()) {
+    const mime = IMAGE_MIME[path3.extname(name).toLowerCase()];
+    const file = path3.join(dir, name);
+    if (!mime || seen.has(name)) continue;
+    try {
+      if (now2 - fs3.statSync(file).mtimeMs < 1e3) continue;
+    } catch {
+      continue;
     }
-    return { behavior: "allow", updatedInput: input };
-  };
+    found2.push({ name, file, mime });
+  }
+  return found2;
 }
 var clip = (s, n) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
 function rel(cwd, p) {
   const s = String(p ?? "");
   if (!s) return "";
-  const r = path3.relative(cwd, s);
+  const r = path3.relative(cwd, path3.resolve(cwd, s));
   return r && !r.startsWith("..") ? r.replaceAll("\\", "/") : s;
 }
 var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -628,6 +639,12 @@ function describeTool(cwd, name, input) {
       return `Subagent: ${input.description ?? ""}`;
     case "TodoWrite":
       return "Update todo list";
+    case "ToolSearch":
+      return `Load tools ${String(input.query ?? "").replace(/^select:/, "")}`;
+    case "apply_patch": {
+      const files = [...String(input.command ?? "").matchAll(/^\*\*\* (Add|Update|Delete) File: (.+)$/gm)].map((m) => `${m[1] === "Update" ? "" : `${m[1].toLowerCase()} `}${rel(cwd, m[2].trim())}`);
+      return `Edit ${clip(files.join(", ") || "files", 200)}`;
+    }
   }
   if (name.startsWith("mcp__playwright__")) {
     const action = name.replace("mcp__playwright__browser_", "").replace("mcp__playwright__", "");
@@ -676,6 +693,7 @@ function resultText(content) {
 var lineCount = (text) => text.replace(/\r/g, "").split("\n").filter((l) => l.trim() !== "").length;
 function summariseResult(cwd, tool2, text) {
   if (tool2 === "Edit" || tool2 === "MultiEdit" || tool2 === "NotebookEdit") return [{ kind: "result", text: "  \u23BF Updated" }];
+  if (tool2 === "apply_patch" && /Success\. Updated the following files/.test(text)) return [{ kind: "result", text: "  \u23BF Updated" }];
   if (tool2 === "Write") return [{ kind: "result", text: "  \u23BF Saved" }];
   if (tool2 === "Read") return [{ kind: "result", text: `  \u23BF Read ${lineCount(text)} lines` }];
   if (tool2 === "Glob") return [{ kind: "result", text: `  \u23BF Found ${lineCount(text)} files` }];
@@ -685,7 +703,7 @@ function summariseResult(cwd, tool2, text) {
   if (lines.length > 3) shown.push({ kind: "result", text: `    \u2026 +${lines.length - 3} lines` });
   return shown;
 }
-function startSession(opts, callbacks, defaultBranch) {
+function startSession(opts, callbacks) {
   let done = false;
   const cb = {
     ...callbacks,
@@ -717,8 +735,6 @@ function startSession(opts, callbacks, defaultBranch) {
   if (opts.office) mcpServers.office = opts.office.server;
   const disallowedTools = ["AskUserQuestion", "EnterPlanMode", "ExitPlanMode"];
   if (opts.role === "ceo") disallowedTools.push("Bash", "PowerShell", "NotebookEdit");
-  const escaped = defaultBranch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const defaultBranchPush = new RegExp(`\\bgit\\s+push\\b[^\\n]*\\s(HEAD:)?(refs/heads/)?${escaped}(\\s|$)`);
   const options = {
     cwd: opts.cwd,
     additionalDirectories: opts.additionalDirectories,
@@ -726,11 +742,8 @@ function startSession(opts, callbacks, defaultBranch) {
     env,
     model: opts.model || void 0,
     effort: opts.effort,
-    settingSources: ["project", "local"],
-    // Agents get exactly the MCP servers passed below: no claude.ai connectors (Gmail, Drive…),
-    // no user-level servers or plugins from the host machine.
-    strictMcpConfig: true,
-    settings: { disableClaudeAiConnectors: true },
+    // The manager's own setup (settings, skills, plugins, MCP servers, connectors), plus the office's servers below.
+    settingSources: ["user", "project", "local"],
     systemPrompt: { type: "preset", preset: "claude_code", append: opts.systemAppend },
     mcpServers,
     disallowedTools,
@@ -739,7 +752,8 @@ function startSession(opts, callbacks, defaultBranch) {
       const line = data.trim();
       if (line && /error|fail/i.test(line)) cb.log([{ kind: "error", text: clip(line, 200) }]);
     },
-    ...opts.permissionMode === "bypass" ? { permissionMode: "bypassPermissions", allowDangerouslySkipPermissions: true } : { permissionMode: "acceptEdits", canUseTool: guardedCanUseTool(opts.cwd, defaultBranchPush, opts.role) },
+    permissionMode: "acceptEdits",
+    canUseTool: allowAll,
     ...opts.outputSchema ? { outputFormat: { type: "json_schema", schema: opts.outputSchema } } : {}
   };
   let emptyTurn;
@@ -771,7 +785,7 @@ function startSession(opts, callbacks, defaultBranch) {
           cb.sessionId(msg.session_id);
           const mcp = msg.mcp_servers.map((s) => `${s.name}:${s.status}`).join(", ");
           cb.log([
-            { kind: "system", text: `\u273B Claude Code ${msg.claude_code_version} \xB7 ${msg.model} \xB7 ${msg.effort ?? opts.effort} effort \xB7 ${opts.permissionMode}` },
+            { kind: "system", text: `\u273B Claude Code ${msg.claude_code_version} \xB7 ${msg.model} \xB7 ${msg.effort ?? opts.effort} effort` },
             { kind: "system", text: `  cwd ${msg.cwd}${mcp ? ` \xB7 mcp ${mcp}` : ""}` }
           ]);
         } else if (msg.subtype === "api_retry") {
@@ -805,12 +819,12 @@ function startSession(opts, callbacks, defaultBranch) {
           } else if (block.type === "thinking") {
             out.push({ kind: "thinking", text: "\u273B Thinking\u2026" });
           } else if (block.type === "tool_use") {
-            const toolInput = block.input ?? {};
+            const toolInput2 = block.input ?? {};
             toolNames.set(block.id, block.name);
-            out.push({ kind: "tool", tool: block.name, text: `\u23FA ${describeTool(opts.cwd, block.name, toolInput)}` });
-            if (block.name === "TodoWrite") out.push(...todoLines(toolInput));
+            out.push({ kind: "tool", tool: block.name, text: `\u23FA ${describeTool(opts.cwd, block.name, toolInput2)}` });
+            if (block.name === "TodoWrite") out.push(...todoLines(toolInput2));
             cb.tool(block.name);
-            if (block.name === "mcp__playwright__browser_navigate" && typeof toolInput.url === "string") cb.browserUrl(toolInput.url);
+            if (block.name === "mcp__playwright__browser_navigate" && typeof toolInput2.url === "string") cb.browserUrl(toolInput2.url);
           }
         }
         if (out.length) cb.log(out);
@@ -825,13 +839,17 @@ function startSession(opts, callbacks, defaultBranch) {
           if (block.type !== "tool_result") continue;
           const name = toolNames.get(block.tool_use_id) ?? "";
           const text = resultText(block.content);
+          let images = 0;
           if (Array.isArray(block.content)) {
             for (const part of block.content) {
               if (part.type === "image" && part.source.type === "base64") {
+                images += 1;
                 cb.screenshot(Buffer.from(part.source.data, "base64"), part.source.media_type);
               }
             }
           }
+          const saved = name === "mcp__playwright__browser_take_screenshot" && !images ? screenshotFile(opts.cwd, text) : null;
+          if (saved) cb.screenshot(saved.data, saved.mime);
           if (name.startsWith("mcp__playwright__")) {
             const url = text.match(/Page URL:\s*(\S+)/);
             if (url) cb.browserUrl(url[1]);
@@ -883,12 +901,1029 @@ function startSession(opts, callbacks, defaultBranch) {
   };
 }
 
-// server/previewRunner.ts
+// server/cliRunner.ts
+import crypto3 from "node:crypto";
+import fs6 from "node:fs";
+import path7 from "node:path";
+import { pathToFileURL } from "node:url";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+
+// server/clis.ts
+import fs4 from "node:fs";
+import { createRequire } from "node:module";
+import path4 from "node:path";
+var CLIS = [
+  { id: "claude", label: "Claude Code", command: "claude", integrated: true },
+  { id: "codex", label: "Codex", command: "codex", integrated: false },
+  { id: "opencode", label: "OpenCode", command: "opencode", integrated: false }
+];
+var isCli = (v) => CLIS.some((c) => c.id === v);
+var cliLabel = (id) => CLIS.find((c) => c.id === id)?.label ?? id;
+var WIN = process.platform === "win32";
+function resolveCommand(name, env = process.env) {
+  const key = Object.keys(env).find((k) => k.toUpperCase() === "PATH") ?? "PATH";
+  const dirs = (env[key] ?? "").split(path4.delimiter).filter(Boolean);
+  const exts = WIN ? (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter((e) => /^\.(exe|cmd|bat|com)$/i.test(e)) : [""];
+  for (const dir of dirs) {
+    for (const ext of exts) {
+      const file = path4.join(dir, name + ext.toLowerCase());
+      try {
+        const st = fs4.statSync(file);
+        if (st.isFile() && (WIN || (st.mode & 73) !== 0)) return file;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function unwrapCmdShim(shimPath, text) {
+  const line = text.split(/\r?\n/).find((l) => /%\*\s*$/.test(l));
+  if (!line) return null;
+  const dir = path4.dirname(shimPath);
+  const targets = [...line.matchAll(/"%dp0%\\([^"]+)"/g)].map((m) => path4.join(dir, m[1]));
+  const target = targets[targets.length - 1];
+  if (!target) return null;
+  if (/\.exe$/i.test(target)) return { file: target, args: [] };
+  if (!/\.[cm]?js$/i.test(target)) return null;
+  const between = line.slice(line.indexOf('"%_prog%"') + '"%_prog%"'.length, line.lastIndexOf(`"%dp0%\\`));
+  const nodeFlags = line.includes('"%_prog%"') ? between.trim().split(/\s+/).filter((f) => f.startsWith("--")) : [];
+  const localNode = path4.join(dir, "node.exe");
+  return { file: fs4.existsSync(localNode) ? localNode : process.execPath, args: [...nodeFlags, target] };
+}
+var bundled;
+function bundledClaude() {
+  if (bundled !== void 0) return bundled;
+  bundled = null;
+  let sdk;
+  try {
+    sdk = createRequire(import.meta.url).resolve("@anthropic-ai/claude-agent-sdk");
+  } catch {
+    return null;
+  }
+  const { platform, arch } = process;
+  const report = platform === "linux" ? process.report?.getReport() : void 0;
+  const musl = platform === "linux" && !report?.header?.glibcVersionRuntime;
+  const targets = platform === "linux" ? musl ? [`linux-${arch}-musl`, `linux-${arch}`] : [`linux-${arch}`, `linux-${arch}-musl`] : [`${platform}-${arch}`];
+  for (const target of targets) {
+    try {
+      bundled = createRequire(sdk).resolve(`@anthropic-ai/claude-agent-sdk-${target}/claude${WIN ? ".exe" : ""}`);
+      return bundled;
+    } catch {
+    }
+  }
+  return null;
+}
+function commandFor(id) {
+  const bundled2 = id === "claude" ? bundledClaude() : null;
+  if (bundled2) return { file: bundled2, args: [] };
+  const def = CLIS.find((c) => c.id === id);
+  const found2 = def && resolveCommand(def.command);
+  if (!found2) return null;
+  if (WIN && /\.(cmd|bat)$/i.test(found2)) {
+    try {
+      return unwrapCmdShim(found2, fs4.readFileSync(found2, "utf8")) ?? { file: found2, args: [] };
+    } catch {
+      return { file: found2, args: [] };
+    }
+  }
+  return { file: found2, args: [] };
+}
+async function detectClis() {
+  return Promise.all(
+    CLIS.map(async (c) => {
+      const cmd = commandFor(c.id);
+      const version = cmd ? await run(cmd.file, [...cmd.args, "--version"], { timeoutMs: 2e4 }).catch(() => null) : null;
+      return { id: c.id, label: c.label, installed: !!cmd, version: version?.split(/\r?\n/)[0].trim().slice(0, 60) || null, integrated: c.integrated };
+    })
+  );
+}
+var EFFORT_CODEX = { low: "low", medium: "medium", high: "high", xhigh: "xhigh", max: "xhigh" };
+var CODEX_HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Interrupt"];
+function codexHookCommand(node, script, win = WIN) {
+  return win ? `node "${script}"` : [node, script].map((s) => `'${s.replaceAll("'", `'"'"'`)}'`).join(" ");
+}
+function launchArgs(id, ctx) {
+  switch (id) {
+    case "claude": {
+      const disallowed = ["AskUserQuestion", "EnterPlanMode", "ExitPlanMode", ...ctx.role === "ceo" ? ["Bash", "PowerShell", "NotebookEdit"] : []];
+      const args = [
+        ...ctx.resumeId ? ["--resume", ctx.resumeId] : ["--session-id", ctx.sessionId],
+        ...ctx.model ? ["--model", ctx.model] : [],
+        ...ctx.effort ? ["--effort", ctx.effort] : [],
+        // The office's PreToolUse hook answers every permission question (allow, or deny with an office rule).
+        "--permission-mode",
+        "acceptEdits",
+        // On top of the manager's own setup (settings, skills, plugins, MCP servers): the office's hooks and servers.
+        "--settings",
+        ctx.files.settings,
+        ...ctx.files.mcp ? ["--mcp-config", ctx.files.mcp] : [],
+        "--append-system-prompt-file",
+        ctx.files.system,
+        "--name",
+        ctx.name,
+        ...ctx.additionalDirectories.flatMap((d) => ["--add-dir", d]),
+        "--disallowedTools",
+        ...disallowed,
+        "--",
+        ctx.prompt
+      ];
+      return { args, env: { DISABLE_AUTOUPDATER: "1" } };
+    }
+    case "codex": {
+      const toml = (s) => JSON.stringify(s);
+      const args = [
+        "--no-alt-screen",
+        "-c",
+        `notify=[${[process.execPath, ctx.notify.script, ctx.notify.url].map(toml).join(",")}]`,
+        "-c",
+        `developer_instructions=${toml(ctx.systemAppend)}`,
+        ...ctx.model ? ["-m", ctx.model] : [],
+        ...ctx.effort ? ["-c", `model_reasoning_effort=${toml(EFFORT_CODEX[ctx.effort])}`] : [],
+        ...ctx.browser ? ["-c", `mcp_servers.playwright={command=${toml(ctx.browser.command)},args=[${ctx.browser.args.map(toml).join(",")}]}`] : [],
+        ...CODEX_HOOK_EVENTS.flatMap((e) => ["-c", `hooks.${e}=[{hooks=[{type="command",command=${toml(codexHookCommand(process.execPath, ctx.codexHook))},timeout=10}]}]`]),
+        // Like the manager's own Codex, but it can't stop to ask: no approvals and no sandbox (its sandbox can't reach
+        // the credential store, so git and gh fail in it).
+        "--dangerously-bypass-approvals-and-sandbox"
+      ];
+      return { args: ctx.resumeId ? ["resume", ...args, ctx.resumeId, ctx.prompt] : [...args, "--", ctx.prompt], env: { CUBEFARM_HOOK_URL: ctx.notify.url } };
+    }
+    case "opencode": {
+      const config = {
+        plugin: [ctx.plugin],
+        instructions: [ctx.files.system],
+        autoupdate: false,
+        // several agents starting at once must not each reinstall it
+        permission: { edit: "allow", bash: "allow", webfetch: "allow" },
+        // it can't stop to ask either
+        ...ctx.browser ? { mcp: { playwright: { type: "local", command: [ctx.browser.command, ...ctx.browser.args], enabled: true } } } : {}
+      };
+      const args = [
+        "--auto",
+        ...ctx.model ? ["--model", ctx.model] : [],
+        ...ctx.resumeId ? ["--session", ctx.resumeId] : [],
+        "--prompt",
+        ctx.prompt
+      ];
+      return { args, env: { OPENCODE_CONFIG_CONTENT: JSON.stringify(config), CUBEFARM_NOTIFY_URL: ctx.notify.url } };
+    }
+  }
+}
+var TRUST_PROMPT = /Quick safety check|Do you trust the (files|contents) (in|of) this|trust this folder|allow Codex to work in this folder/i;
+function trustKey(screen) {
+  if (!TRUST_PROMPT.test(screen)) return null;
+  const selected = screen.match(/^\s*[❯›]\s*(?:\d+\.\s*)?(.+)$/m)?.[1] ?? "";
+  if (/^(yes|trust|continue|proceed)\b/i.test(selected.trim())) return "enter";
+  if (/^(no|exit|quit|cancel)\b/i.test(selected.trim())) return "down";
+  return null;
+}
+function hookReviewKey(screen) {
+  if (!/Hooks need review/i.test(screen)) return null;
+  const selected = screen.match(/^\s*[❯›]\s*(?:\d+\.\s*)?(.+)$/m)?.[1] ?? "";
+  return /^continue without trusting/i.test(selected.trim()) ? "enter" : "down";
+}
+function interruptions(screen) {
+  return screen.split("\n").filter((l) => /\binterrupted\b/i.test(l)).length;
+}
+var STATUSLINE_SOURCE = String.raw`// cubefarm: Claude Code's status line. Forwards the session's status to the office and prints the office's line.
+const url = process.argv[2];
+let body = '';
+process.stdin.on('data', (c) => (body += c));
+process.stdin.on('end', async () => {
+  try {
+    const status = JSON.parse(body);
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ hook_event_name: 'StatusLine', session_id: status.session_id, cost: status.cost, rate_limits: status.rate_limits }),
+      signal: AbortSignal.timeout(2000),
+    });
+    const out = await res.json();
+    process.stdout.write(String(out.statusLine ?? ''));
+  } catch {
+    process.stdout.write('cubefarm');
+  }
+});
+`;
+var NOTIFY_SOURCE = String.raw`// cubefarm: Codex's notify program. Tells the office a turn is complete.
+const [url, payload] = process.argv.slice(2);
+let event = {};
+try {
+  event = JSON.parse(payload ?? '{}');
+} catch {}
+if (event.type === 'agent-turn-complete') {
+  const input = String((event['input-messages'] ?? [])[0] ?? '').slice(0, 300);
+  fetch(url, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ hook_event_name: 'TurnComplete', session_id: event['thread-id'] ?? null, last_assistant_message: event['last-assistant-message'] ?? '', input }),
+    signal: AbortSignal.timeout(3000),
+  }).catch(() => {});
+}
+`;
+var CODEX_HOOK_SOURCE = String.raw`// cubefarm: Codex's hooks. Tells the office what Codex is doing; never changes what it does.
+const url = process.env.CUBEFARM_HOOK_URL;
+const chunks = [];
+process.stdin.on('data', (c) => chunks.push(c));
+process.stdin.on('end', async () => {
+  try {
+    if (url) await fetch(url, { method: 'POST', headers: { 'content-type': 'application/json' }, body: Buffer.concat(chunks), signal: AbortSignal.timeout(5000) });
+  } catch {}
+  process.stdout.write('{}');
+});
+`;
+var OPENCODE_PLUGIN_SOURCE = String.raw`// cubefarm: tells the office when OpenCode's session goes idle.
+export default async function CubefarmPlugin({ client } = {}) {
+  const url = process.env.CUBEFARM_NOTIFY_URL;
+  if (!url) return {};
+  let root;
+  const post = (body) =>
+    fetch(url, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body), signal: AbortSignal.timeout(3000) }).catch(() => {});
+  const lastReply = async (id) => {
+    try {
+      const res = await client.session.messages({ path: { id } });
+      const reply = (res?.data ?? []).filter((m) => m?.info?.role === 'assistant').pop();
+      return (reply?.parts ?? []).filter((p) => p?.type === 'text').map((p) => p.text).join('\n').trim();
+    } catch {
+      return '';
+    }
+  };
+  return {
+    event: async ({ event }) => {
+      const props = event?.properties ?? {};
+      if (event?.type === 'session.created' && !props.info?.parentID && !root) root = props.info?.id;
+      const sessionID = props.sessionID ?? props.info?.id;
+      if (event?.type === 'session.idle' && (!root || sessionID === root)) {
+        post({ hook_event_name: 'TurnComplete', session_id: sessionID ?? null, last_assistant_message: sessionID ? await lastReply(sessionID) : '' });
+      }
+      if (event?.type === 'session.error') post({ hook_event_name: 'TurnError', session_id: sessionID ?? null, error: String(props.error?.data?.message ?? props.error?.name ?? 'error') });
+    },
+  };
+}
+`;
+
+// server/ptyClient.ts
+import crypto2 from "node:crypto";
+import fs5 from "node:fs";
+import net from "node:net";
+import path6 from "node:path";
 import { spawn } from "node:child_process";
+
+// server/ptyProtocol.ts
 import crypto from "node:crypto";
-import fs3 from "node:fs/promises";
-import net from "node:net";
-import path4 from "node:path";
+import path5 from "node:path";
+var PTY_PROTOCOL = 1;
+function hostSocket(home, platform = process.platform) {
+  if (platform !== "win32") return path5.join(home, "pty.sock");
+  const tag = crypto.createHash("sha1").update(path5.resolve(home).toLowerCase()).digest("hex").slice(0, 12);
+  return `\\\\.\\pipe\\cubefarm-pty-${tag}`;
+}
+var encode = (m) => `${JSON.stringify(m)}
+`;
+function readMessages(sock, onMessage2) {
+  let buf = "";
+  sock.setEncoding("utf8");
+  sock.on("data", (chunk) => {
+    buf += chunk;
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl);
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      let m;
+      try {
+        m = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      onMessage2(m);
+    }
+  });
+}
+
+// server/ptyClient.ts
+var nodePty = await import("@lydell/node-pty").catch((err) => {
+  console.warn(`  terminals unavailable: ${err.message}`);
+  return null;
+});
+var terminalsAvailable = nodePty !== null;
+var conn = null;
+var leaving = false;
+var hookPort = 0;
+var hostPid = 0;
+var found = [];
+var remote = /* @__PURE__ */ new Map();
+var hookHandler = () => ({});
+var send = (m) => {
+  if (conn && !conn.destroyed) conn.write(encode(m));
+};
+var RemotePty = class {
+  constructor(id) {
+    this.id = id;
+    remote.set(id, this);
+  }
+  id;
+  pid = 0;
+  dataFns = [];
+  exitFns = [];
+  done = false;
+  write(data) {
+    send({ op: "write", id: this.id, data });
+  }
+  resize(cols, rows) {
+    send({ op: "resize", id: this.id, cols, rows });
+  }
+  kill() {
+    send({ op: "kill", id: this.id });
+  }
+  setMeta(meta) {
+    send({ op: "meta", id: this.id, meta });
+  }
+  onData(cb) {
+    this.dataFns.push(cb);
+  }
+  onExit(cb) {
+    this.exitFns.push(cb);
+  }
+  data(data) {
+    for (const fn of this.dataFns) fn(data);
+  }
+  exit(code) {
+    if (this.done) return;
+    this.done = true;
+    remote.delete(this.id);
+    for (const fn of this.exitFns) fn(code);
+  }
+};
+function onMessage(m) {
+  switch (m.op) {
+    case "spawned": {
+      const p = remote.get(m.id);
+      if (p) p.pid = m.pid;
+      return;
+    }
+    case "failed":
+      console.warn(`  could not start a terminal: ${m.error}`);
+      return remote.get(m.id)?.exit(-1);
+    case "data":
+      return remote.get(m.id)?.data(m.data);
+    case "exit":
+      return remote.get(m.id)?.exit(m.code);
+    case "hook":
+      void Promise.resolve().then(() => hookHandler(m.token, m.body)).catch(() => ({})).then((answer) => send({ op: "hookReply", rid: m.rid, answer }));
+      return;
+  }
+}
+function connect(socket, secret) {
+  return new Promise((resolve) => {
+    const sock = net.connect(socket);
+    let ready = false;
+    const fail = () => {
+      clearTimeout(timer);
+      sock.destroy();
+      resolve(null);
+    };
+    const timer = setTimeout(fail, 2e3);
+    sock.once("error", fail);
+    sock.once("connect", () => sock.write(encode({ op: "hello", secret, version: PTY_PROTOCOL })));
+    readMessages(sock, (m) => {
+      if (ready) return onMessage(m);
+      if (m.op !== "ready") return;
+      ready = true;
+      clearTimeout(timer);
+      sock.removeListener("error", fail);
+      sock.on("error", () => void 0);
+      resolve({ ready: m, sock });
+    });
+    sock.on("close", () => {
+      if (conn !== sock) return;
+      conn = null;
+      if (leaving) return;
+      console.warn("  the terminal keeper stopped; running agents lost their terminals");
+      for (const p of [...remote.values()]) p.exit(-1);
+    });
+  });
+}
+var runtimeFlags = () => process.execArgv.filter((a, i, all) => !/^--(inspect|watch|debug)/.test(a) && !/^--(inspect|watch|debug)/.test(all[i - 1] ?? ""));
+function launch(socket, secretFile) {
+  const entry = path6.join(import.meta.dirname, `ptyHost${path6.extname(import.meta.filename)}`);
+  spawn(process.execPath, [...runtimeFlags(), entry, "launch", socket, secretFile], { detached: true, stdio: "ignore", windowsHide: true }).once("error", () => void 0).unref();
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function startKeeper(home, onHook) {
+  hookHandler = onHook;
+  if (!nodePty) return [];
+  const socket = hostSocket(home);
+  const secretFile = path6.join(home, "pty.secret");
+  try {
+    if (!fs5.existsSync(secretFile)) {
+      fs5.mkdirSync(home, { recursive: true });
+      fs5.writeFileSync(secretFile, crypto2.randomBytes(24).toString("hex"), { mode: 384 });
+    }
+  } catch (err) {
+    console.warn(`  terminal keeper unavailable: ${err.message}`);
+    return [];
+  }
+  const secret = fs5.readFileSync(secretFile, "utf8").trim();
+  let hello = await connect(socket, secret);
+  if (hello && hello.ready.version !== PTY_PROTOCOL) {
+    console.log(`  replacing the terminal keeper (v${hello.ready.version}); the ${hello.ready.ptys.length} terminal(s) it held are stopped`);
+    hello.sock.end(encode({ op: "shutdown" }));
+    hello = null;
+    await sleep(3500);
+  }
+  if (!hello) {
+    launch(socket, secretFile);
+    for (let i = 0; i < 30 && !hello; i++) {
+      await sleep(200);
+      hello = await connect(socket, secret);
+    }
+  }
+  if (!hello) {
+    console.warn("  terminal keeper unavailable: agents' terminals run in the office and stop when it restarts");
+    return [];
+  }
+  conn = hello.sock;
+  leaving = false;
+  hookPort = hello.ready.hookPort;
+  hostPid = hello.ready.pid ?? 0;
+  found = hello.ready.ptys;
+  return found;
+}
+var keeperPid = () => conn ? hostPid : 0;
+function keeperHookUrl() {
+  return conn ? `http://127.0.0.1:${hookPort}` : null;
+}
+function spawnPty(file, args, o, meta) {
+  if (conn) {
+    const p2 = new RemotePty(crypto2.randomUUID());
+    send({ op: "spawn", id: p2.id, file, args, cwd: o.cwd, env: o.env, cols: o.cols, rows: o.rows, meta });
+    return p2;
+  }
+  if (!nodePty) throw new Error("the terminal module could not be loaded on this machine");
+  const p = nodePty.spawn(file, args, { name: "xterm-256color", cols: o.cols, rows: o.rows, cwd: o.cwd, env: o.env, useConptyDll: true });
+  return {
+    get pid() {
+      return p.pid;
+    },
+    write: (data) => p.write(data),
+    resize: (cols, rows) => p.resize(cols, rows),
+    kill: () => killTree(p),
+    setMeta: () => void 0,
+    onData: (cb) => void p.onData(cb),
+    onExit: (cb) => void p.onExit(({ exitCode }) => cb(exitCode))
+  };
+}
+function adoptPty(held) {
+  const p = new RemotePty(held.id);
+  p.pid = held.pid;
+  queueMicrotask(() => send({ op: "attach", id: held.id }));
+  return p;
+}
+function discardPty(held) {
+  send({ op: "kill", id: held.id });
+}
+function hooksReady() {
+  send({ op: "hooksReady" });
+}
+function leaveKeeper() {
+  leaving = true;
+  conn?.end();
+}
+function killTree(proc) {
+  if (process.platform === "win32") {
+    const tk = spawn("taskkill", ["/PID", String(proc.pid), "/T", "/F"], { windowsHide: true, stdio: "ignore" });
+    tk.once("error", () => void 0);
+    return;
+  }
+  try {
+    process.kill(-proc.pid, "SIGTERM");
+  } catch {
+    proc.kill();
+  }
+}
+
+// server/cliRunner.ts
+var SESSIONS_DIR = path7.join(HOME_DIR, "sessions");
+var BIN_DIR = path7.join(HOME_DIR, "bin");
+var FINISH_GRACE_MS = 3e3;
+var BOOT_MS = 6e4;
+var USAGE_WARN_PCT = 90;
+var INLINE_PROMPT_MAX = 8e3;
+var officeUrl = "";
+function setOfficeUrl(url) {
+  officeUrl = url;
+}
+var routes = /* @__PURE__ */ new Map();
+function handleHook(token, body) {
+  const route2 = routes.get(token);
+  if (!route2 || !body || typeof body !== "object" || Array.isArray(body)) return {};
+  try {
+    return route2.hook(body);
+  } catch (err) {
+    console.warn("hook failed", err);
+    return {};
+  }
+}
+async function handleMcp(token, req, res) {
+  const office = routes.get(token)?.office;
+  if (!office) {
+    res.status(404).json({ jsonrpc: "2.0", error: { code: -32001, message: "This session has ended." }, id: null });
+    return;
+  }
+  const server2 = office.serve();
+  const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0, enableJsonResponse: true });
+  res.on("close", () => {
+    void transport.close();
+    void server2.close();
+  });
+  await server2.connect(transport);
+  await transport.handleRequest(req, res, req.body);
+}
+var helpersWritten = false;
+function writeHelpers() {
+  if (helpersWritten) return;
+  fs6.mkdirSync(BIN_DIR, { recursive: true });
+  fs6.writeFileSync(path7.join(BIN_DIR, "statusline.cjs"), STATUSLINE_SOURCE);
+  fs6.writeFileSync(path7.join(BIN_DIR, "notify.cjs"), NOTIFY_SOURCE);
+  fs6.writeFileSync(path7.join(BIN_DIR, "codex-hook.cjs"), CODEX_HOOK_SOURCE);
+  fs6.writeFileSync(path7.join(BIN_DIR, "opencode-plugin.mjs"), OPENCODE_PLUGIN_SOURCE);
+  helpersWritten = true;
+}
+var shellArg = (p) => `"${p.replaceAll("\\", "/")}"`;
+var HOOK_EVENTS = ["UserPromptSubmit", "PreToolUse", "PostToolUse", "PostToolUseFailure", "Stop", "StopFailure", "Notification"];
+function playwrightServer(outputDir) {
+  const args = ["-y", "@playwright/mcp@latest", "--headless", "--isolated", "--output-dir", outputDir, "--init-script", path7.join(import.meta.dirname, "browser-init.js")];
+  return process.platform === "win32" ? { command: "cmd", args: ["/c", "npx", ...args] } : { command: "npx", args };
+}
+function toolOutput(response) {
+  const images = [];
+  const blocks = Array.isArray(response) ? response : Array.isArray(response?.content) ? response.content : null;
+  if (blocks) {
+    for (const b of blocks) {
+      const source = b?.source;
+      if (b?.type === "image" && source?.type === "base64" && source.data) images.push({ data: source.data, mime: source.media_type ?? "image/png" });
+      else if (b?.type === "image" && typeof b.data === "string") images.push({ data: b.data, mime: String(b.mimeType ?? "image/png") });
+    }
+    return { text: resultText(blocks), images };
+  }
+  if (typeof response === "string") return { text: response, images };
+  const r = response;
+  if (r && typeof r === "object") {
+    if (typeof r.stdout === "string" || typeof r.stderr === "string") return { text: [r.stdout, r.stderr].filter((s) => typeof s === "string" && s).join("\n"), images };
+    if (typeof r.file?.content === "string") return { text: r.file.content, images };
+    if (Array.isArray(r.filenames)) return { text: r.filenames.join("\n"), images };
+  }
+  return { text: "", images };
+}
+function quietly(fn) {
+  try {
+    fn();
+  } catch {
+  }
+}
+var lives = /* @__PURE__ */ new Map();
+var hooksHinted = false;
+var IDLE_MS = 30 * 6e4;
+var ALLOW = { hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow", permissionDecisionReason: "Approved by cubefarm" } };
+var toolInput = (b) => b.tool_input && typeof b.tool_input === "object" ? b.tool_input : {};
+function endLive(live) {
+  if (lives.get(live.term) !== live) return;
+  lives.delete(live.term);
+  clearTimeout(live.idleTimer);
+  routes.delete(live.token);
+  live.term.releaseIdle = null;
+  live.term.bind(null);
+  live.proc?.kill();
+  live.proc = null;
+  live.term.note(`\u2500\u2500 ${cliLabel(live.cli)} session ended \u2500\u2500`);
+  fs6.rm(live.dir, { recursive: true, force: true, maxRetries: 5 }, () => void 0);
+}
+var metaOf = (l) => ({ agentId: l.agentId, cli: l.cli, token: l.token, dir: l.dir, resumeId: l.resumeId, busy: !!l.session });
+var remember = (l) => l.proc?.setMeta(metaOf(l));
+function wire(l, office) {
+  const p = l.proc;
+  lives.set(l.term, l);
+  routes.set(l.token, { hook: (b) => l.session ? l.session.hook(b) : idleHook(l, b), office });
+  l.term.bind({ write: (d) => quietly(() => p.write(d)), resize: (c, r) => quietly(() => p.resize(c, r)) });
+  p.onData((data) => {
+    if (lives.get(l.term) === l) l.term.write(data);
+  });
+  p.onExit((code) => {
+    l.proc = null;
+    if (lives.get(l.term) !== l) return;
+    if (l.session) l.session.exited(code);
+    else endLive(l);
+  });
+}
+function waitAtPrompt(l) {
+  clearTimeout(l.idleTimer);
+  l.idleTimer = setTimeout(() => endLive(l), IDLE_MS);
+  l.term.releaseIdle = () => endLive(l);
+  remember(l);
+}
+async function reconnectClis(terminalFor) {
+  const held = await startKeeper(HOME_DIR, handleHook);
+  const back = [];
+  for (const h of held) {
+    const meta = h.meta ?? {};
+    const term = meta.agentId ? terminalFor(meta.agentId) : null;
+    if (h.exit !== null || !term || lives.has(term) || !isCli(meta.cli) || !meta.token || !meta.dir || !meta.agentId) {
+      discardPty(h);
+      continue;
+    }
+    const l = { agentId: meta.agentId, cli: meta.cli, term, proc: adoptPty(h), token: meta.token, dir: meta.dir, resumeId: meta.resumeId ?? null, statusLine: "\u{1F3E2} cubefarm", shots: /* @__PURE__ */ new Set(), session: null };
+    wire(l);
+    waitAtPrompt(l);
+    setTimeout(() => quietly(() => (l.proc?.resize(term.cols - 1, term.rows), l.proc?.resize(term.cols, term.rows))), 500);
+    back.push({ agentId: l.agentId, cli: l.cli, resumeId: l.resumeId, busy: !!meta.busy });
+  }
+  return back;
+}
+function officeProcesses() {
+  const pids = [keeperPid(), ...[...lives.values()].map((l) => l.proc?.pid ?? 0)].filter((p) => p > 0);
+  return { pids, markers: [SESSIONS_DIR, BIN_DIR] };
+}
+function releaseClis(restart) {
+  if (!restart) for (const l of [...lives.values()]) endLive(l);
+  leaveKeeper();
+}
+function idleHook(live, b) {
+  switch (String(b.hook_event_name ?? "")) {
+    case "PreToolUse":
+      return ALLOW;
+    case "UserPromptSubmit": {
+      const text = String(b.prompt ?? "").trim();
+      if (!text || live.term.onIdlePrompt?.(text)) return {};
+      return { decision: "block", reason: "The office couldn't take that on as a follow-up right now (see the agent's panel). Nothing was sent." };
+    }
+    case "StatusLine":
+      return { statusLine: live.statusLine };
+  }
+  return {};
+}
+function startCliSession(opts, callbacks) {
+  const term = opts.terminal;
+  const prev = lives.get(term);
+  const waiting = !!prev?.proc && !prev.session;
+  const adopt = waiting && (!!opts.reattach || prev.cli === (opts.cli ?? "claude") && !!opts.resumeSessionId && prev.resumeId === opts.resumeSessionId);
+  if (prev && !adopt) endLive(prev);
+  let live = adopt ? prev : null;
+  const cli = live?.cli ?? opts.cli ?? "claude";
+  const label = cliLabel(cli);
+  const token = crypto3.randomUUID();
+  const sessionId = opts.resumeSessionId ?? crypto3.randomUUID();
+  const dir = path7.join(SESSIONS_DIR, token);
+  const started = Date.now();
+  const statusLine = `\u{1F3E2} cubefarm${opts.label ? ` \xB7 ${opts.label}` : ""}`;
+  const toolNames = /* @__PURE__ */ new Map();
+  const officePrompts = [];
+  const launched = [];
+  let mainThread = opts.resumeSessionId ?? null;
+  const usageResets = /* @__PURE__ */ new Map();
+  const warned = /* @__PURE__ */ new Set();
+  let done = false;
+  let costUsd = 0;
+  let turns = 0;
+  let lastText = "";
+  let turnError = null;
+  let begun = false;
+  let finishTimer;
+  let bootTimer;
+  let screenTimer;
+  let shotTimer;
+  const nudged = /* @__PURE__ */ new Set();
+  let trustKeys = 0;
+  let trustedAt = 0;
+  const cb = { ...callbacks };
+  const log = (entries) => entries.length && cb.log(entries);
+  const collectShots = (all = false) => {
+    const l2 = live;
+    if (!l2 || cli === "claude" || !opts.browserTesting) return;
+    for (const shot of newScreenshots(path7.join(l2.dir, "browser"), l2.shots, all ? Infinity : Date.now())) {
+      l2.shots.add(shot.name);
+      try {
+        cb.screenshot(fs6.readFileSync(shot.file), shot.mime);
+      } catch {
+      }
+    }
+  };
+  const finish = (r, keep = false) => {
+    if (done) return;
+    done = true;
+    for (const t of [finishTimer, bootTimer]) clearTimeout(t);
+    clearInterval(screenTimer);
+    clearInterval(shotTimer);
+    collectShots(true);
+    if (term.onInput === watchKeys) term.onInput = null;
+    const l2 = live;
+    if (l2 && lives.get(term) === l2) {
+      l2.session = null;
+      if (keep && opts.keepAlive && l2.proc) waitAtPrompt(l2);
+      else endLive(l2);
+    }
+    cb.tool(null);
+    cb.finished({ ...r, costUsd, turns });
+  };
+  const turnEnded = (text) => {
+    lastText = text;
+    cb.tool(null);
+    clearTimeout(finishTimer);
+    finishTimer = setTimeout(() => finish({ ok: !turnError, text: lastText, errors: turnError ? [turnError] : [] }, true), FINISH_GRACE_MS);
+  };
+  const busy = () => {
+    begun = true;
+    clearTimeout(finishTimer);
+  };
+  const interrupted = () => finish({ ok: false, text: lastText, errors: ["Interrupted in the terminal"], interrupted: true }, true);
+  const watchKeys = (data) => {
+    if (data !== "\x1B" || done || !begun) return;
+    const before = interruptions(term.screen());
+    let looks = 0;
+    const look = () => {
+      if (done) return;
+      if (interruptions(term.screen()) > before) interrupted();
+      else if (++looks < 4) setTimeout(look, 1e3);
+    };
+    setTimeout(look, 800);
+  };
+  term.onInput = watchKeys;
+  const assistantLines = (text) => {
+    const lines = text.split("\n");
+    const out = lines.slice(0, 30).map((l2, i) => ({ kind: "text", text: `${i === 0 ? "\u25CF " : "  "}${l2}` }));
+    if (lines.length > 30) out.push({ kind: "text", text: `  \u2026 (${lines.length - 30} more lines)` });
+    return out;
+  };
+  const onStatus = (b) => {
+    const cost = Number(b.cost?.total_cost_usd);
+    if (Number.isFinite(cost)) costUsd = cost;
+    const limits = b.rate_limits ?? {};
+    for (const [type, l2] of Object.entries(limits)) {
+      const used = Number(l2?.used_percentage);
+      if (!Number.isFinite(used)) continue;
+      const resetsAt = Number(l2?.resets_at) > 0 ? Number(l2?.resets_at) * 1e3 : null;
+      usageResets.set(type, used >= 100 ? resetsAt : null);
+      if (used >= USAGE_WARN_PCT && used < 100 && !warned.has(type)) {
+        warned.add(type);
+        cb.usageWarning?.({ resetsAt, rateLimitType: type, utilization: used / 100 });
+      }
+    }
+    return { statusLine };
+  };
+  const hook = (b) => {
+    const event = String(b.hook_event_name ?? "");
+    const sub = typeof b.agent_id === "string" && b.agent_id !== "";
+    switch (event) {
+      case "PreToolUse": {
+        const name = String(b.tool_name ?? "");
+        const input = toolInput(b);
+        if (!sub) {
+          busy();
+          turns += 1;
+          toolNames.set(String(b.tool_use_id ?? ""), name);
+          log([{ kind: "tool", tool: name, text: `\u23FA ${describeTool(opts.cwd, name, input)}` }, ...name === "TodoWrite" ? todoLines(input) : []]);
+          cb.tool(name);
+          if (name === "mcp__playwright__browser_navigate" && typeof input.url === "string") cb.browserUrl(input.url);
+        }
+        return ALLOW;
+      }
+      case "PostToolUse":
+      case "PostToolUseFailure": {
+        if (sub) return {};
+        const name = toolNames.get(String(b.tool_use_id ?? "")) ?? String(b.tool_name ?? "");
+        const out = toolOutput(b.tool_response);
+        if (cli === "claude") for (const img of out.images) cb.screenshot(Buffer.from(img.data, "base64"), img.mime);
+        const saved = name === "mcp__playwright__browser_take_screenshot" && !out.images.length ? screenshotFile(opts.cwd, out.text) : null;
+        if (saved) cb.screenshot(saved.data, saved.mime);
+        if (name.startsWith("mcp__playwright__")) {
+          const url = out.text.match(/Page URL:\s*(\S+)/);
+          if (url) cb.browserUrl(url[1]);
+        }
+        if (event === "PostToolUseFailure") log([{ kind: "error", text: `  \u23BF ${clip(tidyPaths(opts.cwd, String(b.error ?? out.text ?? "Error")).split("\n")[0] || "Error", 200)}` }]);
+        else if (name !== "TodoWrite") log(summariseResult(opts.cwd, name, out.text));
+        cb.tool(null);
+        return {};
+      }
+      case "UserPromptSubmit": {
+        if (sub) return {};
+        busy();
+        const prompt2 = String(b.prompt ?? "").trim();
+        const i = officePrompts.findIndex((p2) => p2.slice(0, 60) === prompt2.slice(0, 60));
+        if (i >= 0) officePrompts.splice(i, 1);
+        else if (prompt2) log([{ kind: "manager", text: `\u25B6 Typed in the terminal: ${clip(prompt2.split("\n")[0], 200)}` }]);
+        return {};
+      }
+      case "Stop": {
+        const text = String(b.last_assistant_message ?? "").trim();
+        turns += 1;
+        if (text) {
+          log(assistantLines(text));
+          cb.turn?.(text);
+        }
+        turnEnded(text);
+        return {};
+      }
+      case "StopFailure": {
+        const error = String(b.error ?? "unknown");
+        const details = String(b.error_details ?? "").trim();
+        if (error === "rate_limit") cb.limited?.([...usageResets.values()].find((t) => t !== null) ?? null);
+        finish({ ok: false, text: lastText, errors: [`${label} stopped: ${error.replace(/_/g, " ")}${details ? ` (${clip(details, 160)})` : ""}`] }, true);
+        return {};
+      }
+      case "Notification": {
+        if (b.notification_type === "permission_prompt") log([{ kind: "error", text: `\u26A0 ${label} is waiting for a permission answer: open the terminal to answer it.` }]);
+        return {};
+      }
+      case "StatusLine":
+        return onStatus(b);
+      case "Interrupt":
+        if (!sub) interrupted();
+        return {};
+      // Codex's notify program and the OpenCode plugin
+      case "TurnComplete": {
+        const thread = typeof b.session_id === "string" ? b.session_id : "";
+        if (cli === "codex" && thread !== mainThread) {
+          const input = String(b.input ?? "").trim();
+          if (mainThread || !launched.some((p2) => input.startsWith(p2.slice(0, 40)))) return {};
+          mainThread = thread;
+        }
+        if (thread) {
+          cb.sessionId(thread);
+          if (live && live.resumeId !== thread) {
+            live.resumeId = thread;
+            remember(live);
+          }
+        }
+        const text = String(b.last_assistant_message ?? "").trim();
+        turns += 1;
+        if (text) {
+          log(assistantLines(text));
+          cb.turn?.(text);
+        }
+        turnEnded(text);
+        return {};
+      }
+      case "TurnError":
+        turnError = `${label}: ${clip(String(b.error ?? "error"), 200)}`;
+        log([{ kind: "error", text: `\u2717 ${turnError}` }]);
+        return {};
+    }
+    return {};
+  };
+  const exited = (exitCode) => {
+    const ok = exitCode === 0 && (lastText !== "" || cli !== "claude" && Date.now() - started > 2e4);
+    finish({ ok, text: lastText, errors: ok ? [] : [`${label} exited${exitCode ? ` with code ${exitCode}` : ""} before finishing.`] });
+  };
+  const handle = {
+    send(text) {
+      const proc = live?.proc;
+      if (done || !proc) return;
+      busy();
+      turnError = null;
+      officePrompts.push(text.trim());
+      const clean = text.replace(/\x1b\[20[01]~/g, "").replace(/\r\n?/g, "\n");
+      launched.push(clean.trim());
+      quietly(() => proc.write(`\x1B[200~${clean}\x1B[201~`));
+      setTimeout(() => quietly(() => live?.proc?.write("\r")), 150);
+    },
+    stop() {
+      finish({ ok: false, text: "", errors: ["Stopped by manager"] });
+    }
+  };
+  if (adopt && live) {
+    clearTimeout(live.idleTimer);
+    term.releaseIdle = null;
+    live.session = { hook, exited };
+    Object.assign(live, { statusLine });
+    remember(live);
+    if (live.resumeId) cb.sessionId(live.resumeId);
+    if (opts.typed || opts.reattach) busy();
+    else handle.send(opts.prompt);
+    shotTimer = setInterval(collectShots, 2e3);
+    return handle;
+  }
+  if (opts.reattach) {
+    setTimeout(() => finish({ ok: false, text: "", errors: [`${label} stopped while the office restarted.`] }), 0);
+    return handle;
+  }
+  const cmd = commandFor(cli);
+  if (!terminalsAvailable || !cmd) {
+    const why = !terminalsAvailable ? "the terminal module could not be loaded on this machine" : `${label} isn't installed (no "${cli}" on PATH)`;
+    setTimeout(() => finish({ ok: false, text: "", errors: [`Could not start ${label}: ${why}.`] }), 0);
+    return handle;
+  }
+  const keeper = keeperHookUrl();
+  const hookUrl = `${keeper ?? officeUrl}/api/hooks/${token}`;
+  const browser = opts.browserTesting ? playwrightServer(path7.join(dir, "browser")) : null;
+  let prompt = opts.prompt;
+  if (opts.outputSchema) {
+    prompt += `
+
+When you are done, end your final message with your report as one JSON object in a \`\`\`json block, matching this JSON schema:
+${JSON.stringify(opts.outputSchema)}`;
+  }
+  let files;
+  try {
+    writeHelpers();
+    fs6.mkdirSync(dir, { recursive: true });
+    const settings = {
+      hooks: Object.fromEntries(HOOK_EVENTS.map((e) => [e, [{ hooks: [{ type: "http", url: hookUrl, timeout: keeper ? 120 : 30 }] }]])),
+      statusLine: { type: "command", command: `${shellArg(process.execPath)} ${shellArg(path7.join(BIN_DIR, "statusline.cjs"))} ${shellArg(hookUrl)}`, padding: 0 }
+    };
+    const servers = {};
+    if (browser) servers.playwright = browser;
+    if (opts.office) servers.office = { type: "http", url: `${officeUrl}/api/mcp/${token}` };
+    files = { settings: path7.join(dir, "settings.json"), mcp: Object.keys(servers).length ? path7.join(dir, "mcp.json") : null, system: path7.join(dir, "instructions.md") };
+    fs6.writeFileSync(files.settings, JSON.stringify(settings, null, 2));
+    if (files.mcp) fs6.writeFileSync(files.mcp, JSON.stringify({ mcpServers: servers }, null, 2));
+    fs6.writeFileSync(files.system, opts.systemAppend);
+    if (prompt.length > INLINE_PROMPT_MAX) {
+      const file = path7.join(dir, "task.md");
+      fs6.writeFileSync(file, prompt);
+      prompt = `Your task is in ${file}. Read all of it first, then do what it says.`;
+    }
+  } catch (err) {
+    setTimeout(() => finish({ ok: false, text: "", errors: [`Could not prepare ${label}: ${err.message}`] }), 0);
+    return handle;
+  }
+  officePrompts.push(prompt.trim());
+  launched.push(prompt.trim());
+  const launch2 = launchArgs(cli, {
+    prompt,
+    systemAppend: opts.systemAppend,
+    model: opts.model,
+    effort: opts.effort,
+    resumeId: opts.resumeSessionId,
+    sessionId,
+    name: opts.label ?? "cubefarm",
+    role: opts.role,
+    additionalDirectories: opts.additionalDirectories,
+    files,
+    notify: { script: path7.join(BIN_DIR, "notify.cjs"), url: hookUrl },
+    codexHook: path7.join(BIN_DIR, "codex-hook.cjs"),
+    plugin: pathToFileURL(path7.join(BIN_DIR, "opencode-plugin.mjs")).href,
+    browser
+  });
+  const env = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v === void 0) continue;
+    if (/^(ANTHROPIC_|CLAUDE)/i.test(k) && k !== "CLAUDE_CONFIG_DIR") continue;
+    if (/^(NO_COLOR|FORCE_COLOR|TERM_PROGRAM|TERM_PROGRAM_VERSION|CODEX_THREAD_ID|OPENCODE_CONFIG_CONTENT)$/i.test(k)) continue;
+    env[k] = v;
+  }
+  Object.assign(env, { TERM: "xterm-256color", COLORTERM: "truecolor" }, launch2.env);
+  if (cli === "claude") cb.sessionId(sessionId);
+  term.note(`\u2500\u2500 ${label}${opts.label ? ` \xB7 ${opts.label}` : ""} \u2500\u2500`);
+  const resumeId = cli === "claude" ? sessionId : opts.resumeSessionId ?? null;
+  const l = { agentId: opts.agentId ?? "", cli, term, proc: null, token, dir, resumeId, statusLine, shots: /* @__PURE__ */ new Set(), session: { hook, exited } };
+  let p;
+  try {
+    p = spawnPty(cmd.file, [...cmd.args, ...launch2.args], { cols: term.cols, rows: term.rows, cwd: opts.cwd, env }, metaOf(l));
+  } catch (err) {
+    setTimeout(() => finish({ ok: false, text: "", errors: [`Could not start ${label}: ${err.message}`] }), 0);
+    return handle;
+  }
+  l.proc = p;
+  live = l;
+  wire(l, opts.office);
+  shotTimer = setInterval(collectShots, 2e3);
+  screenTimer = setInterval(() => {
+    if (done || Date.now() - started > BOOT_MS * 2) return clearInterval(screenTimer);
+    const screen = term.screen();
+    const review = hookReviewKey(screen);
+    const key = trustKeys < 12 && Date.now() - trustedAt > 3e3 ? trustKey(screen) ?? review : null;
+    if (key === "down") {
+      trustKeys += 1;
+      quietly(() => p.write(term.appCursor ? "\x1BOB" : "\x1B[B"));
+    } else if (key === "enter") {
+      trustKeys += 1;
+      trustedAt = Date.now();
+      if (!review) log([{ kind: "system", text: `\u2713 Trusted the worktree for ${label}.` }]);
+      else if (!hooksHinted) {
+        hooksHinted = true;
+        log([{ kind: "system", text: `\u2139 To see ${label}'s steps here, trust the office's hooks once: in this terminal, type /hooks and press t. Until then the office shows its task.` }]);
+      }
+      quietly(() => p.write("\r"));
+    }
+    if (!nudged.has("login") && /Not logged in|run \/login|Select login method|Sign in with ChatGPT|Please login|Invalid API key/i.test(screen)) {
+      nudged.add("login");
+      log([{ kind: "error", text: `\u26A0 ${label} needs you to sign in: open the terminal and sign in there, or run "${cli}" in a terminal of your own.` }]);
+    } else if (!nudged.has("setup") && !trustKey(screen) && Date.now() - trustedAt > 5e3 && /Choose the text style|Press Enter to continue|Bypass Permissions mode|Settings Error/i.test(screen)) {
+      nudged.add("setup");
+      log([{ kind: "error", text: `\u26A0 ${label} is waiting on a setup screen: open the terminal to answer it.` }]);
+    }
+  }, 1e3);
+  bootTimer = setTimeout(() => {
+    if (!done && !begun && cli === "claude") log([{ kind: "error", text: `\u26A0 ${label} hasn't started on the task yet. Open the terminal to see what it's waiting for.` }]);
+  }, BOOT_MS);
+  return handle;
+}
+
+// server/previewRunner.ts
+import { spawn as spawn2 } from "node:child_process";
+import crypto4 from "node:crypto";
+import fs7 from "node:fs/promises";
+import net2 from "node:net";
+import path8 from "node:path";
 var PREVIEW_SLUG = "preview";
 var PREVIEW_BRANCH = "swarm-preview";
 var PREVIEW_TMP = ".preview-tmp";
@@ -909,7 +1944,7 @@ function previewEnv(extra, port, tmp) {
 }
 async function portOpen(port) {
   const probe = (host) => new Promise((resolve) => {
-    const sock = net.connect({ port, host });
+    const sock = net2.connect({ port, host });
     const done = (ok) => {
       sock.destroy();
       resolve(ok);
@@ -921,10 +1956,10 @@ async function portOpen(port) {
   const [v4, v6] = await Promise.all([probe("127.0.0.1"), probe("::1")]);
   return v4 || v6;
 }
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
 async function readJson(file) {
   try {
-    return JSON.parse(await fs3.readFile(file, "utf8"));
+    return JSON.parse(await fs7.readFile(file, "utf8"));
   } catch {
     return null;
   }
@@ -937,11 +1972,11 @@ function defaultCommand(pkg) {
   const vite = /^\s*vite(\s|$)/.test(script) && !/--port\b/.test(script);
   return `npm run ${name}${vite ? " -- --port {port} --strictPort" : ""}`;
 }
-function killTree(child) {
+function killTree2(child) {
   if (child.pid === void 0 || child.exitCode !== null || child.signalCode !== null) return Promise.resolve();
   if (process.platform === "win32") {
     return new Promise((resolve) => {
-      const tk = spawn("taskkill", ["/PID", String(child.pid), "/T", "/F"], { windowsHide: true, stdio: "ignore" });
+      const tk = spawn2("taskkill", ["/PID", String(child.pid), "/T", "/F"], { windowsHide: true, stdio: "ignore" });
       tk.once("error", () => resolve());
       tk.once("close", () => resolve());
     });
@@ -962,7 +1997,7 @@ var RealPreview = class {
     void this.run().catch((err) => {
       if (this.stopped || err instanceof Stopped) return;
       this.stopped = true;
-      if (this.child) void killTree(this.child);
+      if (this.child) void killTree2(this.child);
       this.cb.failed(err.message);
     });
   }
@@ -973,7 +2008,7 @@ var RealPreview = class {
   partial = "";
   async stop() {
     this.stopped = true;
-    if (this.child) await killTree(this.child);
+    if (this.child) await killTree2(this.child);
   }
   check() {
     if (this.stopped) throw new Stopped();
@@ -985,9 +2020,9 @@ var RealPreview = class {
     this.check();
     await ensureLocalExcludes(job.fullName).catch(() => void 0);
     cb.commit(await git(["rev-parse", "--short", "HEAD"], { cwd: wt }).catch(() => ""));
-    const tmp = path4.join(wt, PREVIEW_TMP);
-    await fs3.mkdir(tmp, { recursive: true });
-    const pkg = await readJson(path4.join(wt, "package.json"));
+    const tmp = path8.join(wt, PREVIEW_TMP);
+    await fs7.mkdir(tmp, { recursive: true });
+    const pkg = await readJson(path8.join(wt, "package.json"));
     const command = job.command ?? defaultCommand(pkg);
     if (!command) {
       this.stopped = true;
@@ -1014,42 +2049,42 @@ var RealPreview = class {
       this.check();
       if (exitCode !== void 0) throw new Error(`The app exited (code ${exitCode}) before it listened on port ${job.port}.`);
       if (Date.now() > deadline) throw new Error(`The app did not listen on port ${job.port} within 3 minutes. Does the command use PORT or {port}?`);
-      await sleep(700);
+      await sleep2(700);
     }
     this.check();
     cb.status("running");
     const code = await exited;
-    while (!this.stopped && await portOpen(job.port)) await sleep(3e3);
+    while (!this.stopped && await portOpen(job.port)) await sleep2(3e3);
     if (this.stopped) return;
     this.stopped = true;
     cb.failed(`The app stopped (exit code ${code}).`);
   }
   /** npm ci (or npm install without a lockfile), skipped when package.json and the lockfile haven't changed. */
   async install(wt, env) {
-    const lockFile = path4.join(wt, "package-lock.json");
-    const lock = await fs3.readFile(lockFile, "utf8").catch(() => null);
-    const hash = crypto.createHash("sha256").update(await fs3.readFile(path4.join(wt, "package.json"), "utf8")).update("\0").update(lock ?? "").digest("hex");
-    const marker = path4.join(wt, "node_modules", INSTALL_MARKER);
-    if (await fs3.readFile(marker, "utf8").catch(() => "") === hash) {
+    const lockFile = path8.join(wt, "package-lock.json");
+    const lock = await fs7.readFile(lockFile, "utf8").catch(() => null);
+    const hash = crypto4.createHash("sha256").update(await fs7.readFile(path8.join(wt, "package.json"), "utf8")).update("\0").update(lock ?? "").digest("hex");
+    const marker = path8.join(wt, "node_modules", INSTALL_MARKER);
+    if (await fs7.readFile(marker, "utf8").catch(() => "") === hash) {
       this.cb.log(["Dependencies unchanged since the last install; skipping it."]);
       return;
     }
     const cmd = lock !== null ? "npm ci" : "npm install";
     this.cb.log([`$ ${cmd}`]);
-    const code = await Promise.race([this.spawn(cmd, wt, env), sleep(INSTALL_TIMEOUT_MS).then(() => "timeout")]);
+    const code = await Promise.race([this.spawn(cmd, wt, env), sleep2(INSTALL_TIMEOUT_MS).then(() => "timeout")]);
     this.check();
     if (code === "timeout") {
-      if (this.child) await killTree(this.child);
+      if (this.child) await killTree2(this.child);
       throw new Error(`${cmd} took longer than ${INSTALL_TIMEOUT_MS / 6e4} minutes.`);
     }
     if (code !== 0) throw new Error(`${cmd} failed (code ${code}).`);
     this.child = null;
-    await fs3.writeFile(marker, hash).catch(() => void 0);
+    await fs7.writeFile(marker, hash).catch(() => void 0);
   }
   /** Run a command line through the platform shell; resolves with its exit code. */
   spawn(cmd, cwd, env) {
     this.check();
-    const child = spawn(cmd, { cwd, env, shell: true, windowsHide: true, detached: process.platform !== "win32", stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn2(cmd, { cwd, env, shell: true, windowsHide: true, detached: process.platform !== "win32", stdio: ["ignore", "pipe", "pipe"] });
     this.child = child;
     const onData = (buf) => {
       const text = this.partial + buf.toString().replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "");
@@ -1075,12 +2110,12 @@ var RealPreview = class {
 };
 var realPreviews = {
   start: (job, cb) => new RealPreview(job, cb),
-  hasDefault: async (fullName) => fs3.access(path4.join(mainDir(fullName), "package.json")).then(() => true).catch(() => false)
+  hasDefault: async (fullName) => fs7.access(path8.join(mainDir(fullName), "package.json")).then(() => true).catch(() => false)
 };
 
 // server/officeUpdate.ts
-import fs4 from "node:fs/promises";
-import path5 from "node:path";
+import fs8 from "node:fs/promises";
+import path9 from "node:path";
 var DRAIN_TIMEOUT_MS = 20 * 6e4;
 var POSTPONE_MS = 2 * 60 * 6e4;
 function underLauncher(proc = process) {
@@ -1117,10 +2152,10 @@ function parseLastUpdate(raw) {
   }
 }
 async function takeLastUpdate(home) {
-  const file = path5.join(home, "last-update.json");
-  const raw = await fs4.readFile(file, "utf8").catch(() => null);
+  const file = path9.join(home, "last-update.json");
+  const raw = await fs8.readFile(file, "utf8").catch(() => null);
   if (raw === null) return null;
-  await fs4.rm(file, { force: true, maxRetries: 3 }).catch(() => void 0);
+  await fs8.rm(file, { force: true, maxRetries: 3 }).catch(() => void 0);
   return parseLastUpdate(raw);
 }
 function lastUpdateMessage(u, commits) {
@@ -1128,8 +2163,8 @@ function lastUpdateMessage(u, commits) {
   const n = commits === null ? "" : ` (${commits} commit${commits === 1 ? "" : "s"})`;
   return `\u2B06\uFE0F Updated the office from ${u.from.slice(0, 7)} to ${u.to.slice(0, 7)}${n}`;
 }
-var OFFICE_DIR = path5.resolve(import.meta.dirname, "..");
-var isSamePath = (a, b) => process.platform === "win32" ? path5.resolve(a).toLowerCase() === path5.resolve(b).toLowerCase() : path5.resolve(a) === path5.resolve(b);
+var OFFICE_DIR = path9.resolve(import.meta.dirname, "..");
+var isSamePath = (a, b) => process.platform === "win32" ? path9.resolve(a).toLowerCase() === path9.resolve(b).toLowerCase() : path9.resolve(a) === path9.resolve(b);
 var realOffice = {
   launcher: underLauncher(),
   head: () => git(["rev-parse", "HEAD"], { cwd: OFFICE_DIR }).catch(() => null),
@@ -1173,16 +2208,21 @@ var realBackend = {
   deskDir,
   prepareDesk,
   removeDesk,
-  releaseDesk,
-  startSession,
+  releaseDesk: (fullName, agentSlug, port) => releaseDesk(fullName, agentSlug, port, officeProcesses()),
+  startSession: (opts, cb) => opts.terminal ? startCliSession(opts, cb) : startSession(opts, cb),
+  terminals: terminalsAvailable,
+  reconnectClis: (terminalFor) => terminalsAvailable ? reconnectClis(terminalFor) : Promise.resolve([]),
+  hooksReady,
+  releaseClis,
+  detectClis,
   previews: realPreviews,
   office: realOffice
 };
 
 // server/demo.ts
-import crypto2 from "node:crypto";
+import crypto5 from "node:crypto";
 import http from "node:http";
-import path6 from "node:path";
+import path10 from "node:path";
 var now = () => (/* @__PURE__ */ new Date()).toISOString();
 function issue(n, title, body, fullName, labels = []) {
   return { number: n, title, body, url: `https://github.com/${fullName}/issues/${n}`, labels, createdAt: now() };
@@ -1191,7 +2231,7 @@ var repos = /* @__PURE__ */ new Map();
 var bareRepos = /* @__PURE__ */ new Set();
 var mergedSinceSync = /* @__PURE__ */ new Map();
 var closedIssues = /* @__PURE__ */ new Set();
-var fakeSha = () => crypto2.randomBytes(20).toString("hex");
+var fakeSha = () => crypto5.randomBytes(20).toString("hex");
 function runChecks(pr, fail = Math.random() < 0.2) {
   Object.assign(pr, { checks: "pending", pendingChecks: ["CI / build", "Vercel"], failedChecks: [] });
   setTimeout(() => {
@@ -1235,7 +2275,7 @@ function screenshotSvg(title, url, hue) {
 </svg>`;
 }
 function devScript(opts, cb, issueNumber, issueTitle) {
-  const branch = path6.basename(opts.cwd);
+  const branch = path10.basename(opts.cwd);
   const hue = issueNumber * 67 % 360;
   const file = ["src/App.tsx", "src/components/TodoList.tsx", "src/api/routes.ts", "src/styles.css"][issueNumber % 4];
   const port = 5200 + issueNumber % 50;
@@ -1314,7 +2354,7 @@ function fakeSession(opts, cb, fullName) {
   const title = (kind === "issue" ? issueMatch?.[2] : prMatch?.[2])?.trim() ?? "follow-up";
   const round = Number(opts.prompt.match(/QA round (\d+)/)?.[1] ?? 1);
   const header = [
-    { kind: "system", text: `\u273B Claude Code (demo) \xB7 ${opts.model} \xB7 ${opts.effort} effort \xB7 ${opts.permissionMode}` },
+    { kind: "system", text: `\u273B Claude Code (demo) \xB7 ${opts.model} \xB7 ${opts.effort} effort` },
     { kind: "system", text: `  cwd ${opts.cwd}` }
   ];
   const body = kind === "qa" ? qaScript(cb, number, title, round) : kind === "fix" ? fixScript(number) : devScript(opts, cb, number, title);
@@ -1373,7 +2413,7 @@ function fakeSession(opts, cb, fullName) {
         number: n,
         title,
         url,
-        headRefName: `swarm/issue-${number}-${path6.basename(opts.cwd).replace(/-[0-9a-f]{4}$/, "")}`,
+        headRefName: `swarm/issue-${number}-${path10.basename(opts.cwd).replace(/-[0-9a-f]{4}$/, "")}`,
         state: "OPEN",
         isDraft: false,
         mergeable: "MERGEABLE",
@@ -1425,6 +2465,71 @@ function fakeSession(opts, cb, fullName) {
     }
   };
 }
+var ANSI = {
+  text: (t) => t.replace(/^● /, "\x1B[97m\u25CF\x1B[0m "),
+  tool: (t) => `\x1B[32m\u25CF\x1B[0m \x1B[1m${t.replace(/^⏺ /, "")}\x1B[0m`,
+  result: (t) => `\x1B[2m${t}\x1B[0m`,
+  thinking: (t) => `\x1B[35m${t}\x1B[0m`,
+  error: (t) => `\x1B[31m${t}\x1B[0m`,
+  system: (t) => `\x1B[2m${t}\x1B[0m`,
+  manager: (t) => `\x1B[36m${t.replace(/^▶ /, "\u276F ")}\x1B[0m`,
+  done: (t) => `\x1B[32m${t}\x1B[0m`
+};
+function inTerminal(opts, cb, start) {
+  const term = opts.terminal;
+  if (!term) return start(cb);
+  const name = CLIS.find((c) => c.id === (opts.cli ?? "claude"))?.label ?? "Claude Code";
+  term.note(`\u2500\u2500 ${name}${opts.label ? ` \xB7 ${opts.label}` : ""} \u2500\u2500`);
+  term.write(
+    [
+      "",
+      ` \x1B[38;5;209m\u2590\u259B\u2588\u2588\u2588\u259C\u258C\x1B[0m   \x1B[1m${name}\x1B[0m (demo)`,
+      `\x1B[38;5;209m\u259D\u259C\u2588\u2588\u2588\u2588\u2588\u259B\u2598\x1B[0m  ${opts.model || "default model"} \xB7 ${opts.effort} effort`,
+      `\x1B[38;5;209m  \u2598\u2598 \u259D\u259D\x1B[0m    \x1B[2m${opts.cwd}\x1B[0m`,
+      "",
+      `\x1B[36m\u276F\x1B[0m ${opts.prompt.split("\n")[0].slice(0, 200)}`,
+      ""
+    ].join("\r\n")
+  );
+  let handle = null;
+  let line = "";
+  term.bind({
+    write: (data) => {
+      for (const ch of data.replace(/\x1b\[[0-9;?]*[A-Za-z~]|\x1b./g, "")) {
+        if (ch === "\r") {
+          const text = line.trim();
+          line = "";
+          term.write("\r\n");
+          if (text && handle) {
+            cb.log([{ kind: "manager", text: `\u25B6 Typed in the terminal: ${text}` }]);
+            handle.send(text);
+          }
+        } else if (ch === "\x7F" || ch === "\b") {
+          if (line) term.write("\b \b");
+          line = line.slice(0, -1);
+        } else if (ch >= " ") {
+          line += ch;
+          term.write(ch);
+        }
+      }
+    },
+    resize: () => void 0
+  });
+  handle = start({
+    ...cb,
+    log: (entries) => {
+      cb.log(entries);
+      for (const e of entries) term.write(`${e.kind === "tool" || e.kind === "text" && e.text.startsWith("\u25CF") ? "\r\n" : ""}${ANSI[e.kind](e.text)}\r
+`);
+    },
+    finished: (r) => {
+      term.bind(null);
+      term.note(`\u2500\u2500 ${name} session ended \u2500\u2500`);
+      cb.finished(r);
+    }
+  });
+  return handle;
+}
 var USAGE_WARNING_AT = 4;
 var USAGE_WARNING_MS = 5 * 6e4;
 var sessionsStarted = 0;
@@ -1562,8 +2667,14 @@ Closes #${pr.closesIssues[0] ?? "?"}`,
     releaseDesk: async () => void 0,
     startSession: (opts, cb) => {
       if (++sessionsStarted === USAGE_WARNING_AT) fakeUsageWarning(cb);
-      return opts.role === "ceo" ? ceoSession(opts, cb) : fakeSession(opts, cb, deskRepo.get(opts.cwd) ?? [...repos.keys()][0]);
+      return inTerminal(opts, cb, (c) => opts.role === "ceo" ? ceoSession(opts, c) : fakeSession(opts, c, deskRepo.get(opts.cwd) ?? [...repos.keys()][0]));
     },
+    terminals: true,
+    reconnectClis: async () => [],
+    // fake sessions end with the office
+    hooksReady: () => void 0,
+    releaseClis: () => void 0,
+    detectClis: async () => CLIS.map((c) => ({ id: c.id, label: c.label, installed: true, version: "demo", integrated: c.integrated })),
     previews: demoPreviews,
     office: demoOffice
   };
@@ -1940,9 +3051,9 @@ Acceptance criteria:
 }
 
 // server/swarm.ts
-import fs5 from "node:fs/promises";
-import path7 from "node:path";
-import crypto3 from "node:crypto";
+import fs10 from "node:fs/promises";
+import path12 from "node:path";
+import crypto6 from "node:crypto";
 
 // server/ceo.ts
 import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
@@ -2109,6 +3220,7 @@ function createOfficeTools(h) {
   const server2 = createSdkMcpServer({ name: "office", version: "1.0.0", tools: defs });
   return {
     server: server2,
+    serve: () => createSdkMcpServer({ name: "office", version: "1.0.0", tools: defs }).instance,
     async call(name, args) {
       const def = defs.find((d) => d.name === name);
       if (!def) throw new Error(`No office tool ${name}`);
@@ -2121,11 +3233,11 @@ function ceoSystemPrompt(o) {
   const manager = o.manager ? `the manager, ${o.manager}` : "the human manager";
   return [
     `You are ${o.name}, the CEO of ${o.company || "an autonomous software company"}, run from an office building called cubefarm. You work from the corner office in the lobby.`,
-    `Every floor of the building is one GitHub repository with its own team of Claude Code agents. Developers pick up GitHub issues, each in their own git worktree, and open pull requests. QA testers review and verify every pull request (code review, tests, build, and a real browser via Playwright); when every tester is busy, a free developer who didn't write the PR covers QA. On floors with auto-merge on, the office merges a PR by itself once QA passes and GitHub's checks are green, and sends failing checks or merge conflicts back to a developer; on the others, ${manager} merges. The manager is your board: they approve hires and let-gos.`,
+    `Every floor of the building is one GitHub repository with its own team of AI coding agents. Developers pick up GitHub issues, each in their own git worktree, and open pull requests. QA testers review and verify every pull request (code review, tests, build, and a real browser via Playwright); when every tester is busy, a free developer who didn't write the PR covers QA. On floors with auto-merge on, the office merges a PR by itself once QA passes and GitHub's checks are green, and sends failing checks or merge conflicts back to a developer; on the others, ${manager} merges. The manager is your board: they approve hires and let-gos.`,
     "",
     "Your job is to run the company, not to write code:",
     "- Understand each project: what it is, its stack, how far along it is, and what kind of people it needs. Projects differ a lot. A static marketing site, a 3D browser game and a REST API need different specialists and different QA.",
-    `- Shape each floor's team. Propose specialists with a specific title and a job description written for this project. Keep teams lean: every agent shares one Claude subscription's usage limits${o.sessionLimit ? ` and at most ${o.sessionLimit} sessions run at once` : ""}, so a floor rarely needs more than ${o.teamCap} people. Propose letting people go when a floor is clearly overstaffed or a specialty is no longer needed.`,
+    `- Shape each floor's team. Propose specialists with a specific title and a job description written for this project. Keep teams lean: agents on the same coding agent share one subscription's usage limits${o.sessionLimit ? ` and at most ${o.sessionLimit} sessions run at once` : ""}, so a floor rarely needs more than ${o.teamCap} people. Propose letting people go when a floor is clearly overstaffed or a specialty is no longer needed.`,
     "- Plan the work: turn a floor's brief into small, well-specified GitHub issues, one agent-session each, with acceptance criteria. Route each to a specialty. The office hands issues out itself: a free specialist gets first pick of their specialty, and otherwise any free developer takes the next issue that can start, so a specialty is a preference, not a lock.",
     "- Write each floor's QA brief: what QA testers must check for this kind of project (for a 3D game: the canvas renders, controls respond, frame rate is smooth; for a website: links, phone layout, accessibility; for an API: status codes, validation, error cases).",
     "",
@@ -2558,6 +3670,197 @@ function pacingMessage(w, until, sessions, now2) {
   return `\u{1F422} Claude's usage is getting high${what ? ` (${what})` : ""}. Until ${clock(until, now2)} the office finishes open work first and starts at most ${sessions} session${sessions === 1 ? "" : "s"} at a time.`;
 }
 
+// server/terminal.ts
+import fs9 from "node:fs/promises";
+import path11 from "node:path";
+import xtermHeadless from "@xterm/headless";
+import xtermSerialize from "@xterm/addon-serialize";
+var { Terminal } = xtermHeadless;
+var { SerializeAddon } = xtermSerialize;
+var TERM_COLS = 120;
+var TERM_ROWS = 32;
+var SCROLLBACK = 5e3;
+var STALE_BYTES = 4 * 1024 * 1024;
+var MOUSE_ENCODINGS = [1006, 1016];
+var clamp = (n, lo, hi, dflt) => {
+  const v = Math.round(Number(n));
+  return Number.isFinite(v) ? Math.max(lo, Math.min(hi, v)) : dflt;
+};
+var AgentTerminal = class {
+  cols = TERM_COLS;
+  rows = TERM_ROWS;
+  /** Output arrived since the last save. */
+  dirty = false;
+  /** Closes a CLI left waiting at its prompt after its task (set by the runtime that left it there). */
+  releaseIdle = null;
+  /** Something the manager typed at that waiting prompt: the office takes it on as a follow-up (true) or refuses. */
+  onIdlePrompt = null;
+  /** Keys a viewer typed, after they went to the CLI (the runtime watches for Esc interrupting a turn). */
+  onInput = null;
+  term = new Terminal({ cols: TERM_COLS, rows: TERM_ROWS, scrollback: SCROLLBACK, allowProposedApi: true, scrollOnEraseInDisplay: true });
+  ser = new SerializeAddon();
+  viewers = /* @__PURE__ */ new Map();
+  sink = null;
+  mouseEncoding = null;
+  resync = null;
+  constructor() {
+    this.term.loadAddon(this.ser);
+    const decset = (on) => (params) => {
+      for (const p of params) if (typeof p === "number" && MOUSE_ENCODINGS.includes(p)) this.mouseEncoding = on ? p : null;
+      return false;
+    };
+    this.term.parser.registerCsiHandler({ prefix: "?", final: "h" }, decset(true));
+    this.term.parser.registerCsiHandler({ prefix: "?", final: "l" }, decset(false));
+  }
+  /** Output from the CLI (or a note from the office): into the mirror and out to everyone watching. */
+  write(data) {
+    if (!data) return;
+    this.term.write(data);
+    this.dirty = true;
+    this.send({ t: "data", data });
+  }
+  /** A dim line from the office itself, e.g. between sessions. */
+  note(text) {
+    this.write(`\r
+\x1B[2m${text}\x1B[0m\r
+`);
+  }
+  get live() {
+    return this.sink !== null;
+  }
+  /** The CLI asked for application cursor keys: arrows are sent as ESC O A… rather than ESC [ A… */
+  get appCursor() {
+    return this.term.modes.applicationCursorKeysMode;
+  }
+  /** The running CLI, or null when it exits. */
+  bind(sink) {
+    this.sink = sink;
+    sink?.resize(this.cols, this.rows);
+    this.send({ t: "live", live: sink !== null });
+  }
+  resize(cols, rows) {
+    const c = clamp(cols, 20, 400, this.cols);
+    const r = clamp(rows, 5, 200, this.rows);
+    if (c === this.cols && r === this.rows) return;
+    this.cols = c;
+    this.rows = r;
+    this.term.resize(c, r);
+    this.sink?.resize(c, r);
+  }
+  /** Everything a fresh terminal needs to show the same screen: scrollback, colours, cursor and modes. */
+  snapshot() {
+    return this.ser.serialize({ scrollback: SCROLLBACK }) + (this.mouseEncoding ? `\x1B[?${this.mouseEncoding}h` : "");
+  }
+  /** The visible rows as plain text, for spotting prompts the CLI is waiting on. */
+  screen() {
+    const b = this.term.buffer.active;
+    const rows = [];
+    for (let i = b.viewportY; i < b.viewportY + this.rows; i++) rows.push(b.getLine(i)?.translateToString(true) ?? "");
+    return rows.join("\n");
+  }
+  /** Written to disk so a restarted office still shows what each agent did. */
+  /** Resolves once everything written so far is parsed (xterm parses asynchronously). */
+  flush() {
+    return new Promise((resolve) => this.term.write("", resolve));
+  }
+  async save(file) {
+    this.dirty = false;
+    await this.flush();
+    await fs9.mkdir(path11.dirname(file), { recursive: true });
+    await fs9.writeFile(`${file}.tmp`, this.snapshot());
+    await fs9.rename(`${file}.tmp`, file);
+  }
+  async load(file) {
+    const data = await fs9.readFile(file, "utf8").catch(() => "");
+    if (!data) return;
+    this.term.write(data);
+    this.note("(the office restarted)");
+    this.dirty = false;
+  }
+  // ---------- viewers ----------
+  attach(ws) {
+    const viewer = { stale: false, queued: [] };
+    this.viewers.set(ws, viewer);
+    this.term.write("", () => {
+      const queued = viewer.queued ?? [];
+      viewer.queued = null;
+      this.sendTo(ws, { t: "snapshot", data: this.snapshot(), cols: this.cols, rows: this.rows, live: this.live });
+      for (const json of queued) if (ws.readyState === ws.OPEN) ws.send(json);
+    });
+    ws.on("message", (raw) => {
+      let msg;
+      try {
+        msg = JSON.parse(String(raw));
+      } catch {
+        return;
+      }
+      if (msg.t === "input" && typeof msg.data === "string") {
+        const data = msg.data.slice(0, 64 * 1024);
+        this.sink?.write(data);
+        this.onInput?.(data);
+      } else if (msg.t === "resize") {
+        this.resize(msg.cols, msg.rows);
+        for (const other of this.viewers.keys()) if (other !== ws) this.sendTo(other, { t: "size", cols: this.cols, rows: this.rows });
+      }
+    });
+    ws.on("close", () => this.viewers.delete(ws));
+  }
+  dispose() {
+    for (const ws of this.viewers.keys()) ws.close();
+    this.viewers.clear();
+    if (this.resync) clearTimeout(this.resync);
+    this.sink = null;
+    this.term.dispose();
+  }
+  send(msg) {
+    if (this.viewers.size === 0) return;
+    const json = JSON.stringify(msg);
+    for (const [ws, v] of this.viewers) {
+      if (ws.readyState !== ws.OPEN || v.stale) continue;
+      if (v.queued) {
+        v.queued.push(json);
+        continue;
+      }
+      if (ws.bufferedAmount > STALE_BYTES) {
+        v.stale = true;
+        this.scheduleResync();
+        continue;
+      }
+      ws.send(json);
+    }
+  }
+  sendTo(ws, msg) {
+    if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(msg));
+  }
+  /** Viewers that fell behind get a fresh snapshot once their socket has drained, instead of an ever-growing backlog. */
+  scheduleResync() {
+    if (this.resync) return;
+    this.resync = setTimeout(() => {
+      this.resync = null;
+      let waiting = false;
+      for (const [ws, v] of this.viewers) {
+        if (!v.stale) continue;
+        if (ws.bufferedAmount > STALE_BYTES / 4) {
+          waiting = true;
+          continue;
+        }
+        v.stale = false;
+        this.sendTo(ws, { t: "snapshot", data: this.snapshot(), cols: this.cols, rows: this.rows, live: this.live });
+      }
+      if (waiting) this.scheduleResync();
+    }, 1e3);
+  }
+};
+
+// shared/models.ts
+var isClaudeModel = (model) => /^(claude|opus|sonnet|haiku|fable|default|best|opusplan)\b/i.test(model.trim());
+function effectiveModel(own, cli, office, claudeDefault) {
+  const suits = (m) => m.trim() !== "" && cli === "claude" === isClaudeModel(m);
+  if (suits(own)) return own.trim();
+  if (cli === office.defaultCli && suits(office.defaultModel)) return office.defaultModel.trim();
+  return cli === "claude" ? claudeDefault : "";
+}
+
 // shared/types.ts
 var CEO_ID = "ceo";
 
@@ -2605,8 +3908,8 @@ var EFFORTS = ["low", "medium", "high", "xhigh", "max"];
 var CEO_MODEL = "claude-opus-5-5";
 var CEO_EFFORT = "xhigh";
 var CEO_NAME = "Morgan";
-var CEO_DIR = path7.join(HOME_DIR, "ceo");
-var DEFAULT_PROJECTS_DIR = defaultProjectsDir(path7.resolve(import.meta.dirname, ".."));
+var CEO_DIR = path12.join(HOME_DIR, "ceo");
+var DEFAULT_PROJECTS_DIR = defaultProjectsDir(path12.resolve(import.meta.dirname, ".."));
 var MAX_PENDING_REQUESTS = 8;
 var MAX_ISSUES_PER_JOB = 12;
 var KEEP_MESSAGES = 200;
@@ -2619,14 +3922,14 @@ var ERROR_COOLDOWN_MS = 2 * 6e4;
 var MAX_ISSUE_FAILURES = 2;
 var LIMIT_PAUSE_MS = 15 * 6e4;
 var oneLine = (err) => (err instanceof Error ? err.message : String(err)).split(/\r?\n/)[0].slice(0, 200);
-var SCREENS_DIR = path7.join(HOME_DIR, "screens");
+var SCREENS_DIR = path12.join(HOME_DIR, "screens");
 var MIME_EXT = { "image/png": "png", "image/jpeg": "jpg", "image/webp": "webp", "image/svg+xml": "svg" };
-var screenFile = (agentId, mime) => path7.join(SCREENS_DIR, `${agentId}.${MIME_EXT[mime] ?? "img"}`);
+var screenFile = (agentId, mime) => path12.join(SCREENS_DIR, `${agentId}.${MIME_EXT[mime] ?? "img"}`);
 async function loadScreen(agentId) {
   for (const [mime, ext] of Object.entries(MIME_EXT)) {
-    const file = path7.join(SCREENS_DIR, `${agentId}.${ext}`);
+    const file = path12.join(SCREENS_DIR, `${agentId}.${ext}`);
     try {
-      const [data, stat] = await Promise.all([fs5.readFile(file), fs5.stat(file)]);
+      const [data, stat] = await Promise.all([fs10.readFile(file), fs10.stat(file)]);
       return { data, mime, at: stat.mtimeMs };
     } catch {
     }
@@ -2634,8 +3937,11 @@ async function loadScreen(agentId) {
   return null;
 }
 async function removeScreens(agentId) {
-  await Promise.all(Object.values(MIME_EXT).map((ext) => fs5.rm(path7.join(SCREENS_DIR, `${agentId}.${ext}`), { force: true })));
+  await Promise.all(Object.values(MIME_EXT).map((ext) => fs10.rm(path12.join(SCREENS_DIR, `${agentId}.${ext}`), { force: true })));
 }
+var TERMINALS_DIR = path12.join(HOME_DIR, "terminals");
+var terminalFile = (agentId) => path12.join(TERMINALS_DIR, `${agentId}.ansi`);
+var TERMINAL_SAVE_MS = 2e4;
 var QA_SCHEMA = {
   type: "object",
   additionalProperties: false,
@@ -2678,10 +3984,11 @@ var QA_SCHEMA = {
 function parseReport(result) {
   let raw = result.structured;
   if (!raw && result.text) {
-    const json = result.text.match(/\{[\s\S]*\}/);
-    if (json) {
+    const fenced = [...result.text.matchAll(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/g)].map((m) => m[1]).reverse();
+    for (const json of [...fenced, result.text.match(/\{[\s\S]*\}/)?.[0]].filter((j) => !!j)) {
       try {
-        raw = JSON.parse(json[0]);
+        raw = JSON.parse(json);
+        break;
       } catch {
         raw = null;
       }
@@ -2702,6 +4009,7 @@ function parseReport(result) {
 var cell = (s) => s.replace(/\|/g, "\\|").replace(/\r?\n/g, "<br>");
 var ICON = { pass: "\u2705", fail: "\u274C", skip: "\u23ED\uFE0F" };
 var Swarm = class {
+  // coding-agent CLIs found on this machine (detected at startup)
   constructor(backend) {
     this.backend = backend;
     this.previews = new Previews(backend, {
@@ -2718,7 +4026,8 @@ var Swarm = class {
       sessionLimit: 0,
       defaultModel: DEFAULT_MODEL,
       defaultEffort: "medium",
-      permissionMode: "guarded",
+      runtime: "terminal",
+      defaultCli: "claude",
       hiring: "approve",
       teamCap: 6,
       ceoHeartbeatMin: 60,
@@ -2781,10 +4090,11 @@ var Swarm = class {
     // sessions cut off by the hand-over are the restarted office's to recover
   };
   lastOfficeView = "";
+  clis = [];
   // ---------- lifecycle ----------
   async init() {
     try {
-      const raw = await fs5.readFile(STATE_FILE, "utf8");
+      const raw = await fs10.readFile(STATE_FILE, "utf8");
       const loaded = JSON.parse(raw);
       this.state = {
         settings: { ...this.state.settings, ...loaded.settings },
@@ -2807,7 +4117,9 @@ var Swarm = class {
           brief: a.brief ?? "",
           hiredBy: a.hiredBy ?? "manager",
           look: a.look ?? lookFor(a.name),
-          task: a.task ?? (a.issueNumber ? "issue" : null)
+          task: a.task ?? (a.issueNumber ? "issue" : null),
+          cli: isCli(a.cli) ? a.cli : "",
+          sessionCli: a.sessionCli ?? (a.sessionId ? "claude" : null)
         })),
         qa: (loaded.qa ?? []).map((q) => ({
           ...q,
@@ -2827,13 +4139,16 @@ var Swarm = class {
         phoneReadAt: loaded.phoneReadAt ?? 0
       };
       for (const m of this.state.messages) this.messageSeq = Math.max(this.messageSeq, m.id + 1);
-      if (!this.state.settings.defaultModel) this.state.settings.defaultModel = DEFAULT_MODEL;
       if (!EFFORTS.includes(this.state.settings.defaultEffort)) this.state.settings.defaultEffort = "medium";
+      if (this.state.settings.runtime !== "sdk") this.state.settings.runtime = "terminal";
+      if (!isCli(this.state.settings.defaultCli)) this.state.settings.defaultCli = "claude";
+      if (!this.state.settings.defaultModel && this.state.settings.defaultCli === "claude") this.state.settings.defaultModel = DEFAULT_MODEL;
       const old = this.state.settings;
       if (old.maxConcurrent !== void 0) {
         if (loaded.settings?.sessionLimit === void 0) old.sessionLimit = old.maxConcurrent === 4 ? 0 : old.maxConcurrent;
         delete old.maxConcurrent;
       }
+      delete old.permissionMode;
       if (loaded.settings && loaded.settings.setupDone === void 0 && this.state.repos.length > 0) {
         Object.assign(this.state.settings, { setupDone: true, tutorialStep: -1 });
       }
@@ -2844,14 +4159,30 @@ var Swarm = class {
     for (const a of this.state.agents) {
       const tail = a.logTail ?? [];
       for (const l of tail) this.logSeq = Math.max(this.logSeq, l.id + 1);
-      this.agentRt.set(a.id, { log: tail, pending: [], session: null, currentTool: null, browserUrl: null, screenshot: await loadScreen(a.id), shots: [] });
-      if (BUSY.includes(a.status)) {
-        a.status = "stopped";
-        a.lastError = "The swarm server restarted while this agent was working.";
-        interrupted.push(a);
+      this.agentRt.set(a.id, { log: tail, pending: [], session: null, currentTool: null, browserUrl: null, screenshot: await loadScreen(a.id), shots: [], terminal: await this.loadTerminal(a.id) });
+    }
+    const back = await this.backend.reconnectClis((id) => {
+      const a = this.state.agents.find((x) => x.id === id);
+      return a && a.role !== "ceo" ? this.terminalFor(a) : null;
+    }).catch((err) => {
+      console.warn("could not reconnect to the terminal keeper", err);
+      return [];
+    });
+    const carryOn = [];
+    for (const a of this.state.agents) {
+      if (!BUSY.includes(a.status)) continue;
+      if (back.some((c) => c.agentId === a.id && c.busy)) {
+        carryOn.push(a);
+        continue;
       }
+      a.status = "stopped";
+      a.lastError = "The swarm server restarted while this agent was working.";
+      interrupted.push(a);
     }
+    for (const c of back) if (c.busy && !carryOn.some((a) => a.id === c.agentId)) this.agentRt.get(c.agentId)?.terminal?.releaseIdle?.();
     for (const r of this.state.repos) this.repoRt.set(r.id, { issues: [], pulls: [], lastSync: null, syncing: false, cloneStatus: "pending", lastMergedAt: null, folderSync: null, merging: false });
+    for (const a of carryOn) this.reattachSession(a);
+    this.backend.hooksReady();
     try {
       this.user = await this.backend.user();
     } catch (err) {
@@ -2873,7 +4204,8 @@ var Swarm = class {
     await Promise.all([
       ...this.state.agents.map((a) => {
         const repo = this.state.repos.find((r) => r.id === a.repoId);
-        return repo ? this.backend.releaseDesk(repo.fullName, this.agentSlug(a), this.port(a)).catch(() => void 0) : void 0;
+        if (!repo || back.some((c) => c.agentId === a.id)) return void 0;
+        return this.backend.releaseDesk(repo.fullName, this.agentSlug(a), this.port(a)).catch(() => void 0);
       }),
       this.previews.clearOrphans(this.state.repos)
     ]);
@@ -2884,6 +4216,11 @@ var Swarm = class {
     if (updated) await this.reportUpdate(updated);
     setInterval(() => this.state.repos.forEach((r, i) => setTimeout(() => void this.syncRepo(r.id), i * 1500)), SYNC_INTERVAL_MS);
     setInterval(() => this.schedule(), SCHEDULER_INTERVAL_MS);
+    setInterval(() => void this.saveTerminals(), TERMINAL_SAVE_MS);
+    void this.backend.detectClis().then((clis) => {
+      this.clis = clis;
+      this.broadcast({ type: "clis", clis });
+    }).catch((err) => console.warn("could not look for agent CLIs", err));
     this.save();
     setTimeout(() => this.schedule(), 1e3);
   }
@@ -2955,6 +4292,8 @@ var Swarm = class {
       skin: a.skin,
       model: a.model,
       effort: a.effort,
+      cli: a.cli,
+      terminal: !!rt.terminal,
       status: a.status,
       issueNumber: a.issueNumber,
       issueTitle: a.issueTitle,
@@ -3004,6 +4343,7 @@ var Swarm = class {
       messages: this.state.messages.slice(-100),
       phoneReadAt: this.state.phoneReadAt,
       usage: this.usageNow(),
+      clis: this.clis,
       officeCommit: this.officeHead?.slice(0, 7) ?? null,
       officeUpdate: this.officeHead ? this.officeUpdateView() : void 0
     };
@@ -3071,10 +4411,10 @@ var Swarm = class {
     if (this.saveTimer) clearTimeout(this.saveTimer);
     this.saveTimer = null;
     for (const a of this.state.agents) a.logTail = (this.agentRt.get(a.id)?.log ?? []).slice(-200);
-    await fs5.mkdir(path7.dirname(STATE_FILE), { recursive: true });
+    await fs10.mkdir(path12.dirname(STATE_FILE), { recursive: true });
     const tmp = `${STATE_FILE}.tmp`;
-    await fs5.writeFile(tmp, JSON.stringify(this.state, null, 2));
-    await fs5.rename(tmp, STATE_FILE);
+    await fs10.writeFile(tmp, JSON.stringify(this.state, null, 2));
+    await fs10.rename(tmp, STATE_FILE);
   }
   // ---------- lookups ----------
   repo(id) {
@@ -3156,7 +4496,7 @@ var Swarm = class {
     const name = fullName.split("/")[1];
     const taken = folders.find((f) => f.name.toLowerCase() === name.toLowerCase());
     if (taken) throw new HttpError(409, `${taken.path} already exists and isn't a clone of ${fullName}. Connect that folder instead, or rename it first.`);
-    return path7.join(root, name);
+    return path12.join(root, name);
   }
   /** A brand-new project: a folder in your projects folder, pushed to a new GitHub repo. */
   async createRepo(name, opts) {
@@ -3168,11 +4508,11 @@ var Swarm = class {
   }
   /** The folders in your projects folder (or another folder you point at), and which are floors already. */
   async listProjectFolders(dir) {
-    const root = dir?.trim() ? path7.resolve(dir.trim()) : this.state.settings.projectsDir;
+    const root = dir?.trim() ? path12.resolve(dir.trim()) : this.state.settings.projectsDir;
     const folders = await this.backend.scanProjects(root).catch((err) => {
       throw new HttpError(400, err.message);
     });
-    const same = (a, b) => path7.resolve(a).toLowerCase() === path7.resolve(b).toLowerCase();
+    const same = (a, b) => path12.resolve(a).toLowerCase() === path12.resolve(b).toLowerCase();
     const floorOf = (f) => this.state.repos.find((r) => r.localPath && same(r.localPath, f.path) || f.github && r.id.toLowerCase() === f.github.toLowerCase())?.floor ?? null;
     return { root, folders: folders.map((f) => ({ name: f.name, path: f.path, git: f.git, github: f.github, floor: floorOf(f) })) };
   }
@@ -3352,7 +4692,7 @@ var Swarm = class {
     rt.folderSync = status;
     this.emitRepo(repo);
     if (status && status !== before) {
-      const name = repo.localPath ? path7.basename(repo.localPath) : repo.fullName;
+      const name = repo.localPath ? path12.basename(repo.localPath) : repo.fullName;
       if (status.startsWith("updated")) this.toast("success", `\u{1F4C1} ${name}: ${status}`);
       else if (/behind|diverged|failed/.test(status)) this.toast("info", `\u{1F4C1} ${name} wasn't updated: ${status}`);
     }
@@ -3371,9 +4711,14 @@ var Swarm = class {
   stopPreview(id) {
     return this.previews.stop(this.repo(id));
   }
-  /** Server shutdown: stop every floor's app so nothing is left holding a preview port. */
-  async shutdown() {
+  /**
+   * Server shutdown: stop every floor's app so nothing is left holding a preview port. Agents' CLIs keep working
+   * through a restart (the terminal keeper holds them for the next start) and stop when the office quits.
+   */
+  async shutdown(restart = false) {
     await this.writeState().catch((err) => console.warn("could not save the state", err));
+    this.backend.releaseClis(restart);
+    await this.saveTerminals(true);
     await this.previews.stopAll(this.state.repos);
   }
   async cloneRepo(id) {
@@ -3484,7 +4829,7 @@ var Swarm = class {
     }
     const name = opts.name?.trim() || this.freeName(role);
     const agent = {
-      id: crypto3.randomUUID(),
+      id: crypto6.randomUUID(),
       name,
       repoId: repo.id,
       role,
@@ -3500,6 +4845,7 @@ var Swarm = class {
       skin: opts.appearance?.skin ?? pick(SKIN),
       model: opts.model ?? "",
       effort: EFFORTS.includes(opts.effort) ? opts.effort : "",
+      cli: isCli(opts.cli) ? opts.cli : "",
       status: "idle",
       issueNumber: null,
       issueTitle: null,
@@ -3511,11 +4857,12 @@ var Swarm = class {
       costUsd: 0,
       turns: 0,
       sessionId: null,
+      sessionCli: null,
       lastError: null,
       logTail: []
     };
     this.state.agents.push(agent);
-    this.agentRt.set(agent.id, { log: [], pending: [], session: null, currentTool: null, browserUrl: null, screenshot: null, shots: [] });
+    this.agentRt.set(agent.id, { log: [], pending: [], session: null, currentTool: null, browserUrl: null, screenshot: null, shots: [], terminal: null });
     this.appendLog(agent, [
       { kind: "system", text: role === "qa" ? `\u{1F50D} ${name} joined the QA lab on floor ${repo.floor} (${repo.fullName}).` : `\u{1F44B} ${name} joined floor ${repo.floor} (${repo.fullName}).` },
       ...agent.title ? [{ kind: "system", text: `\u{1FAAA} ${agent.title}${agent.specialty ? ` \xB7 takes swarm:${agent.specialty} issues first` : ""}` }] : []
@@ -3538,6 +4885,7 @@ var Swarm = class {
   }
   updateAgent(id, patch) {
     const a = this.agent(id);
+    if (patch.cli !== void 0 && a.role !== "ceo") a.cli = isCli(patch.cli) ? patch.cli : "";
     if (patch.name?.trim() && patch.name.trim() !== a.name) {
       a.name = patch.name.trim().slice(0, 24);
       a.look = lookFor(a.name);
@@ -3565,7 +4913,10 @@ var Swarm = class {
       this.decide(r, { status: "approved", note: "They were let go directly.", decidedBy: "manager" });
     }
     this.agentRt.get(id)?.session?.stop();
+    this.agentRt.get(id)?.terminal?.releaseIdle?.();
+    this.agentRt.get(id)?.terminal?.dispose();
     void removeScreens(id);
+    void fs10.rm(terminalFile(id), { force: true }).catch(() => void 0);
     for (const q of this.state.qa) {
       if (q.qaAgentId === id && q.status === "testing") this.setQa(q, { status: "queued", qaAgentId: null });
       if (q.devAgentId === id) q.devAgentId = null;
@@ -3591,6 +4942,20 @@ var Swarm = class {
     this.emitAgent(a);
     this.save();
   }
+  /** An agent whose CLI kept working through the office's restart: the office follows its session again. */
+  reattachSession(a) {
+    const repo = this.state.repos.find((r) => r.id === a.repoId);
+    if (!repo) return;
+    this.appendLog(a, [{ kind: "system", text: "\u21BB The office restarted; their CLI kept working and the office is following it again." }]);
+    this.startAgentSession(a, repo, this.backend.deskDir(repo.fullName, this.agentSlug(a)), "", "", a.sessionId ?? void 0, void 0, "reattach");
+  }
+  /** The manager pressed Esc in the agent's terminal and the CLI stopped its turn: a Stop that leaves the CLI to them. */
+  interrupted(a) {
+    if (!BUSY.includes(a.status)) return;
+    a.status = "stopped";
+    a.lastError = "Interrupted in the terminal";
+    this.appendLog(a, [{ kind: "manager", text: "\u25A0 Interrupted in the terminal. Type there to carry on." }]);
+  }
   resetAgent(id) {
     const a = this.agent(id);
     if (BUSY.includes(a.status)) throw new HttpError(409, `${a.name} is busy; stop them first`);
@@ -3598,6 +4963,7 @@ var Swarm = class {
       if (q.qaAgentId === id && q.status === "testing") this.setQa(q, { status: "queued", qaAgentId: null });
       if (q.devAgentId === id && q.status === "fixing") this.setQa(q, { status: "failed" });
     }
+    this.agentRt.get(id)?.terminal?.releaseIdle?.();
     this.clearTask(a);
     this.appendLog(a, [{ kind: "system", text: "\u21BA Cleared desk. Ready for new work." }]);
     this.save();
@@ -3632,6 +4998,57 @@ var Swarm = class {
   linkedRepos(repo) {
     return repo.links.map((id) => this.state.repos.find((r) => r.id === id)).filter((r) => !!r);
   }
+  /**
+   * How an agent's next session runs: the CLI in their terminal (the terminal runtime), or Claude Code through the
+   * SDK. A session can only be resumed by the CLI that made it, so a follow-up stays with that CLI.
+   */
+  sessionRuntime(a, resume) {
+    const inTerminal2 = this.state.settings.runtime === "terminal" && this.backend.terminals;
+    let cli = a.role === "ceo" ? "claude" : a.cli || this.state.settings.defaultCli;
+    if (resume && a.sessionCli && a.sessionCli !== cli) {
+      if (inTerminal2) cli = a.sessionCli;
+      else if (a.sessionCli !== "claude") resume = void 0;
+    }
+    if (!inTerminal2) return { resumeSessionId: resume };
+    const what = a.role === "ceo" ? a.issueTitle : a.task === "qa" ? `QA \xB7 PR #${a.prNumber}` : a.task === "fix" ? `fixing PR #${a.prNumber}` : a.issueNumber ? `#${a.issueNumber} ${a.issueTitle ?? ""}` : null;
+    return { terminal: this.terminalFor(a), cli, label: `${a.name}${what ? ` \xB7 ${what}` : ""}`.slice(0, 80).trim(), resumeSessionId: resume };
+  }
+  /** The model to ask for (the Agent SDK runs Claude Code). '' lets another coding agent use its own default. */
+  modelFor(a, cli) {
+    return effectiveModel(a.model, cli ?? "claude", this.state.settings, DEFAULT_MODEL);
+  }
+  // ---------- terminals ----------
+  async loadTerminal(agentId) {
+    if (!await fs10.stat(terminalFile(agentId)).catch(() => null)) return null;
+    const t = this.newTerminal(agentId);
+    await t.load(terminalFile(agentId));
+    return t;
+  }
+  /** The agent's terminal, made the first time they run in the terminal runtime. */
+  terminalFor(a) {
+    const rt = this.agentRt.get(a.id);
+    rt.terminal ??= this.newTerminal(a.id);
+    return rt.terminal;
+  }
+  newTerminal(agentId) {
+    const t = new AgentTerminal();
+    t.onIdlePrompt = (text) => {
+      void this.message(agentId, text, true).catch(() => void 0);
+      return !!this.agentRt.get(agentId)?.session;
+    };
+    return t;
+  }
+  async saveTerminals(all = false) {
+    for (const [id, rt] of this.agentRt) {
+      if (rt.terminal && (all || rt.terminal.dirty)) await rt.terminal.save(terminalFile(id)).catch((err) => console.warn("could not save a terminal", err));
+    }
+  }
+  /** A browser opened an agent's terminal (/ws/term?agent=<id>). */
+  attachTerminal(agentId, ws) {
+    const t = this.agentRt.get(agentId)?.terminal;
+    if (!t) return ws.close(4404, "That agent has no terminal");
+    t.attach(ws);
+  }
   buildSystemAppend(a, repo, cwd, branch, fixing) {
     const linked = this.linkedRepos(repo).map((r) => `- ${r.fullName}: read-only reference clone at ${this.backend.mainDir(r.fullName)}`);
     const push = fixing ? `git push origin HEAD:${fixing.headRef}` : `git push -u origin ${branch}`;
@@ -3723,24 +5140,29 @@ Note from the manager: ${note}` : ""
     ].filter(Boolean).join("\n");
     this.startAgentSession(a, repo, cwd, prompt, this.buildSystemAppend(a, repo, cwd, branch));
   }
-  startAgentSession(a, repo, cwd, prompt, systemAppend, resumeSessionId, outputSchema) {
+  startAgentSession(a, repo, cwd, prompt, systemAppend, resumeSessionId, outputSchema, mode = null) {
     const rt = this.agentRt.get(a.id);
     a.status = "working";
+    const how = this.sessionRuntime(a, resumeSessionId);
     this.emitAgent(a);
     rt.session = this.backend.startSession(
       {
         cwd,
         prompt,
         systemAppend,
-        model: a.model || this.state.settings.defaultModel,
+        model: this.modelFor(a, how.cli),
         effort: a.effort || this.state.settings.defaultEffort,
         browserTesting: repo.browserTesting,
-        permissionMode: this.state.settings.permissionMode,
         additionalDirectories: this.linkedRepos(repo).map((r) => this.backend.mainDir(r.fullName)),
         role: a.task === "qa" ? "qa" : a.role,
         // a developer covering QA works under QA's rules
         outputSchema,
-        resumeSessionId
+        // A developer's CLI stays at its prompt afterwards, for the manager and for follow-ups; QA's closes.
+        keepAlive: a.task !== "qa",
+        typed: mode === "typed",
+        reattach: mode === "reattach",
+        agentId: a.id,
+        ...how
       },
       {
         log: (entries) => this.appendLog(a, entries),
@@ -3751,6 +5173,7 @@ Note from the manager: ${note}` : ""
         },
         sessionId: (id) => {
           a.sessionId = id;
+          a.sessionCli = how.cli ?? "claude";
         },
         browserUrl: (url) => {
           rt.browserUrl = url;
@@ -3762,13 +5185,12 @@ Note from the manager: ${note}` : ""
           rt.shots.push({ data, mime, url: rt.browserUrl, at });
           if (rt.shots.length > 12) rt.shots.shift();
           this.broadcast({ type: "screen", agentId: a.id, url: rt.browserUrl, at });
-          void removeScreens(a.id).then(() => fs5.mkdir(SCREENS_DIR, { recursive: true })).then(() => fs5.writeFile(screenFile(a.id, mime), data)).catch((err) => console.warn("could not save screenshot", err));
+          void removeScreens(a.id).then(() => fs10.mkdir(SCREENS_DIR, { recursive: true })).then(() => fs10.writeFile(screenFile(a.id, mime), data)).catch((err) => console.warn("could not save screenshot", err));
         },
         limited: (at) => this.pauseForLimit(at),
         usageWarning: (info) => this.paceForWarning(info),
         finished: (result) => void this.onFinished(a, repo, result)
-      },
-      repo.defaultBranch
+      }
     );
   }
   async onFinished(a, repo, result) {
@@ -3781,6 +5203,7 @@ Note from the manager: ${note}` : ""
     a.costUsd += result.costUsd;
     a.turns += result.turns;
     void this.backend.releaseDesk(repo.fullName, this.agentSlug(a), this.port(a)).catch(() => void 0);
+    if (result.interrupted) this.interrupted(a);
     if (a.task === "qa") await this.onQaFinished(a, repo, result);
     else if (a.task === "fix") this.onFixFinished(a, repo, result);
     else await this.onIssueFinished(a, repo, result);
@@ -3916,7 +5339,7 @@ ${repo.qaBrief}`] : [],
       "1. Read the PR description and the linked issue, and work out the acceptance criteria.",
       `2. Review the code as a careful reviewer would: git diff origin/${repo.defaultBranch}...HEAD. Look for bugs, unhandled errors and edge cases, security problems, leftover debug code, and new logic without tests.`,
       "3. Install dependencies if needed, then run the project's test suite, linters, type checks and build (whichever exist).",
-      repo.browserTesting ? `4. If the project has a UI, start it in the background on port ${this.port(a)} (reserved for you) and exercise the change in a real browser with the Playwright tools: navigate, click, type, resize to a phone size, try edge cases, and check the console for errors. Take a screenshot with browser_take_screenshot of every important state: the screenshots are attached to the PR as evidence. Stop the server afterwards.` : "4. Exercise the changed behaviour directly (run the program, call the API, write a quick script).",
+      repo.browserTesting ? `4. If the project has a UI, start it in the background on port ${this.port(a)} (reserved for you) and exercise the change in a real browser with the Playwright tools: navigate, click, type, resize to a phone size, try edge cases, and check the console for errors. Take a screenshot with browser_take_screenshot (no filename) of every important state: the screenshots are attached to the PR as evidence. Stop the server afterwards.` : "4. Exercise the changed behaviour directly (run the program, call the API, write a quick script).",
       "5. You may write throwaway scripts to probe behaviour, but do not commit them.",
       "",
       "Rules: do not modify the code under test, do not commit, push, comment on, review or merge anything on GitHub. The office posts your report on the pull request. Finish with the structured QA report: verdict, summary, the checks you performed, the commands you ran and one caption per screenshot."
@@ -4153,7 +5576,8 @@ Full report with screenshots: ${rec.commentUrl}` : "",
       this.toast("info", `${a.name} pushed fixes for PR #${rec.prNumber}; QA round ${rec.round} is queued`);
     }
   }
-  async message(id, text) {
+  /** A message for an agent: sent into their running session, or a follow-up that resumes it. typed: the manager typed it at their CLI's prompt, where it's already running. */
+  async message(id, text, typed = false) {
     const a = this.agent(id);
     if (a.role === "ceo") return this.messageCeo(text);
     const repo = this.repo(a.repoId);
@@ -4161,7 +5585,7 @@ Full report with screenshots: ${rec.commentUrl}` : "",
     const rt = this.agentRt.get(id);
     if (rt.session) {
       this.appendLog(a, [{ kind: "manager", text: `\u25B6 Manager: ${text}` }]);
-      rt.session.send(text);
+      if (!typed) rt.session.send(text);
       return;
     }
     if (a.role === "qa") throw new HttpError(409, `${a.name} isn't testing anything right now. Send a PR to QA from the Kanban board.`);
@@ -4174,20 +5598,24 @@ Full report with screenshots: ${rec.commentUrl}` : "",
     a.startedAt = Date.now();
     if (a.task === null) a.task = "issue";
     const fixing = a.task === "fix" && a.prNumber ? { pr: a.prNumber, headRef: a.branch } : void 0;
-    this.startAgentSession(a, repo, cwd, text, this.buildSystemAppend(a, repo, cwd, a.branch, fixing), a.sessionId);
+    this.startAgentSession(a, repo, cwd, text, this.buildSystemAppend(a, repo, cwd, a.branch, fixing), a.sessionId, void 0, typed ? "typed" : null);
   }
   updateSettings(patch) {
     const s = this.state.settings;
     if (patch.sessionLimit !== void 0) s.sessionLimit = Math.max(0, Math.round(Number(patch.sessionLimit)) || 0);
-    if (patch.defaultModel !== void 0) s.defaultModel = String(patch.defaultModel).trim() || DEFAULT_MODEL;
+    if (isCli(patch.defaultCli) && patch.defaultCli !== s.defaultCli) {
+      s.defaultCli = patch.defaultCli;
+      if (patch.defaultModel === void 0) s.defaultModel = s.defaultCli === "claude" ? DEFAULT_MODEL : "";
+    }
+    if (patch.defaultModel !== void 0) s.defaultModel = String(patch.defaultModel).trim() || (s.defaultCli === "claude" ? DEFAULT_MODEL : "");
     if (patch.defaultEffort !== void 0 && EFFORTS.includes(patch.defaultEffort)) s.defaultEffort = patch.defaultEffort;
-    if (patch.permissionMode === "guarded" || patch.permissionMode === "bypass") s.permissionMode = patch.permissionMode;
+    if (patch.runtime === "terminal" || patch.runtime === "sdk") s.runtime = patch.runtime;
     if (patch.hiring === "approve" || patch.hiring === "auto") s.hiring = patch.hiring;
     if (patch.teamCap !== void 0) s.teamCap = Math.max(1, Math.min(15, Math.round(Number(patch.teamCap)) || 1));
     if (patch.ceoHeartbeatMin !== void 0) s.ceoHeartbeatMin = Math.max(0, Math.min(1440, Math.round(Number(patch.ceoHeartbeatMin)) || 0));
     if (typeof patch.managerName === "string") s.managerName = patch.managerName.trim().slice(0, 40);
     if (typeof patch.companyName === "string") s.companyName = patch.companyName.trim().slice(0, 60);
-    if (typeof patch.projectsDir === "string" && patch.projectsDir.trim()) s.projectsDir = path7.resolve(patch.projectsDir.trim());
+    if (typeof patch.projectsDir === "string" && patch.projectsDir.trim()) s.projectsDir = path12.resolve(patch.projectsDir.trim());
     if (typeof patch.setupDone === "boolean") s.setupDone = patch.setupDone;
     if (patch.tutorialStep !== void 0) s.tutorialStep = Math.max(-1, Math.round(Number(patch.tutorialStep)) || 0);
     if (typeof patch.autoUpdate === "boolean") s.autoUpdate = patch.autoUpdate;
@@ -4526,6 +5954,7 @@ Full report with screenshots: ${rec.commentUrl}` : "",
         skin: pick(SKIN),
         model: CEO_MODEL,
         effort: CEO_EFFORT,
+        cli: "claude",
         status: "idle",
         issueNumber: null,
         issueTitle: null,
@@ -4537,11 +5966,12 @@ Full report with screenshots: ${rec.commentUrl}` : "",
         costUsd: 0,
         turns: 0,
         sessionId: null,
+        sessionCli: null,
         lastError: null,
         logTail: []
       };
       this.state.agents.push(a);
-      this.agentRt.set(a.id, { log: [], pending: [], session: null, currentTool: null, browserUrl: null, screenshot: null, shots: [] });
+      this.agentRt.set(a.id, { log: [], pending: [], session: null, currentTool: null, browserUrl: null, screenshot: null, shots: [], terminal: null });
       this.appendLog(a, [{ kind: "system", text: `\u{1F3DB}\uFE0F ${a.name} moved into the corner office. The CEO studies every floor, shapes its team and plans its work.` }]);
     }
     const i = interrupted.indexOf(a);
@@ -4631,13 +6061,14 @@ ${job.text}` } : job;
     this.emitAgent(a);
     this.emitCeo();
     this.save();
-    await fs5.mkdir(CEO_DIR, { recursive: true }).catch(() => void 0);
+    await fs10.mkdir(CEO_DIR, { recursive: true }).catch(() => void 0);
     if (a.status !== "working") {
       this.state.ceo.job = null;
       this.emitCeo();
       return;
     }
     const s = this.state.settings;
+    const how = this.sessionRuntime(a, job.kind === "chat" ? a.sessionId ?? void 0 : void 0);
     rt.session = this.backend.startSession(
       {
         cwd: CEO_DIR,
@@ -4646,7 +6077,7 @@ ${job.text}` } : job;
           name: a.name,
           company: s.companyName,
           manager: s.managerName,
-          notesFile: path7.join(CEO_DIR, "NOTES.md"),
+          notesFile: path12.join(CEO_DIR, "NOTES.md"),
           sessionLimit: s.sessionLimit,
           teamCap: s.teamCap,
           hiring: s.hiring
@@ -4654,12 +6085,10 @@ ${job.text}` } : job;
         model: a.model || CEO_MODEL,
         effort: a.effort || CEO_EFFORT,
         browserTesting: false,
-        permissionMode: s.permissionMode,
         additionalDirectories: this.state.repos.filter((r) => this.repoRt.get(r.id)?.cloneStatus === "ready").map((r) => this.backend.mainDir(r.fullName)),
         role: "ceo",
         office: this.officeTools(),
-        // A chat carries on from the CEO's last session, so "why did you propose that?" has an answer.
-        resumeSessionId: job.kind === "chat" ? a.sessionId ?? void 0 : void 0
+        ...how
       },
       {
         log: (entries) => this.appendLog(a, entries),
@@ -4670,6 +6099,7 @@ ${job.text}` } : job;
         },
         sessionId: (id) => {
           a.sessionId = id;
+          a.sessionCli = "claude";
         },
         browserUrl: () => void 0,
         screenshot: () => void 0,
@@ -4677,8 +6107,7 @@ ${job.text}` } : job;
         limited: (at) => this.pauseForLimit(at),
         usageWarning: (info) => this.paceForWarning(info),
         finished: (result) => this.onCeoFinished(a, result)
-      },
-      ""
+      }
     );
   }
   onCeoFinished(a, result) {
@@ -4691,6 +6120,7 @@ ${job.text}` } : job;
     a.turns += result.turns;
     const job = this.state.ceo.job;
     this.state.ceo.job = null;
+    if (result.interrupted) this.interrupted(a);
     if (a.status === "stopped") {
     } else if (!result.ok) {
       a.status = "error";
@@ -4754,7 +6184,7 @@ ${t}`);
       qa: this.state.qa.map((q) => [q.repoId, q.prNumber, q.status]),
       requests: this.state.requests.filter((r) => r.status === "pending").map((r) => r.id)
     };
-    return crypto3.createHash("sha1").update(JSON.stringify(data)).digest("hex");
+    return crypto6.createHash("sha1").update(JSON.stringify(data)).digest("hex");
   }
   maybeHeartbeat() {
     const min = this.state.settings.ceoHeartbeatMin;
@@ -4968,7 +6398,8 @@ ${t}`);
         doing: this.agentDoing(a),
         issue: a.issueNumber ? { number: a.issueNumber, title: a.issueTitle } : null,
         pullRequest: a.prNumber ? { number: a.prNumber, url: a.prUrl } : null,
-        model: a.model || (ceo ? CEO_MODEL : this.state.settings.defaultModel),
+        codingAgent: ceo ? "claude" : a.cli || this.state.settings.defaultCli,
+        model: ceo ? a.model || CEO_MODEL : this.modelFor(a, a.cli || this.state.settings.defaultCli) || "the coding agent default",
         effort: a.effort || (ceo ? CEO_EFFORT : this.state.settings.defaultEffort),
         hiredBy: a.hiredBy,
         jobDescription: a.brief || null
@@ -5011,7 +6442,7 @@ ${t}`);
     if (seated + waiting >= MAX_DESKS[role]) throw new Error(role === "qa" ? `The QA lab on floor ${repo.floor} is full.` : `Floor ${repo.floor} has no free desks.`);
     const name = this.freeName(role);
     const req = {
-      id: crypto3.randomUUID(),
+      id: crypto6.randomUUID(),
       kind: "hire",
       repoId: repo.id,
       role,
@@ -5053,7 +6484,7 @@ ${t}`);
     if (pending2.some((r) => r.kind === "let-go" && r.agentId === a.id)) throw new Error(`Letting ${a.name} go is already proposed.`);
     if (pending2.length >= MAX_PENDING_REQUESTS) throw new Error(`${pending2.length} proposals are already waiting for the manager. Wait for their decisions first.`);
     const req = {
-      id: crypto3.randomUUID(),
+      id: crypto6.randomUUID(),
       kind: "let-go",
       repoId: repo.id,
       role: a.role,
@@ -5127,8 +6558,12 @@ _Filed by ${this.ceo().name}, the cubefarm CEO._`;
 
 // server/index.ts
 var swarm = new Swarm(DEMO ? createDemoBackend() : realBackend);
+if (PORT) setOfficeUrl(`http://127.0.0.1:${PORT}`);
 await swarm.init();
 var app = express();
+app.post("/api/hooks/:token", express.json({ limit: "64mb" }), (req, res) => void res.json(handleHook(String(req.params.token), req.body)));
+app.post("/api/mcp/:token", express.json({ limit: "4mb" }), (req, res, next) => void handleMcp(String(req.params.token), req, res).catch(next));
+app.all("/api/mcp/:token", (_req, res) => void res.status(405).set("Allow", "POST").end());
 app.use(express.json({ limit: "1mb" }));
 var route = (fn) => async (req, res, next) => {
   try {
@@ -5248,10 +6683,10 @@ app.post(
   route((req) => swarm.approveRequest(String(req.params.id), { name: str(req.body?.name) || void 0, model: typeof req.body?.model === "string" ? req.body.model : void 0, effort: typeof req.body?.effort === "string" ? req.body.effort : void 0 }))
 );
 app.post("/api/requests/:id/reject", route((req) => swarm.rejectRequest(String(req.params.id), str(req.body?.note))));
-var dist = path8.resolve(import.meta.dirname, "../dist");
-if (fs6.existsSync(dist)) {
+var dist = path13.resolve(import.meta.dirname, "../dist");
+if (fs11.existsSync(dist)) {
   app.use(express.static(dist));
-  app.get(/^(?!\/api).*/, (_req, res) => res.sendFile(path8.join(dist, "index.html")));
+  app.get(/^(?!\/api).*/, (_req, res) => res.sendFile(path13.join(dist, "index.html")));
 }
 app.use((err, _req, res, _next) => {
   const parserStatus = err?.status;
@@ -5261,9 +6696,18 @@ app.use((err, _req, res, _next) => {
   res.status(status).json({ error: message });
 });
 var server = http2.createServer(app);
-var wss = new WebSocketServer({ server, path: "/ws" });
+var wss = new WebSocketServer({ noServer: true });
+var terms = new WebSocketServer({ noServer: true });
 wss.on("connection", (ws) => swarm.addClient(ws));
+terms.on("connection", (ws, req) => swarm.attachTerminal(new URL(req.url ?? "", "http://localhost").searchParams.get("agent") ?? "", ws));
+server.on("upgrade", (req, socket, head) => {
+  const { pathname } = new URL(req.url ?? "", "http://localhost");
+  const target = pathname === "/ws" ? wss : pathname === "/ws/term" ? terms : null;
+  if (!target) return void socket.destroy();
+  target.handleUpgrade(req, socket, head, (ws) => target.emit("connection", ws, req));
+});
 server.listen(PORT, "127.0.0.1", () => {
+  setOfficeUrl(`http://127.0.0.1:${server.address().port}`);
   console.log(`
   \u{1F3E2} cubefarm on http://localhost:${PORT}${DEMO ? "  (DEMO MODE: fake GitHub + fake agents)" : ""}`);
   console.log(`     state: ${STATE_FILE}`);
@@ -5277,16 +6721,18 @@ var shutdown = (signal) => {
   console.log(`
   ${signal}: stopping floor previews\u2026`);
   const force = setTimeout(() => process.exit(0), 15e3);
-  void swarm.shutdown().catch((err) => console.error(err)).finally(() => {
+  void swarm.shutdown(signal === "restart").catch((err) => console.error(err)).finally(() => {
     clearTimeout(force);
     process.exit(0);
   });
 };
 process.once("SIGINT", () => shutdown("SIGINT"));
 process.once("SIGTERM", () => shutdown("SIGTERM"));
+process.once("SIGHUP", () => shutdown("SIGHUP"));
 if (underLauncher()) {
   process.on("message", (msg) => {
-    if (msg?.type === "office:shutdown") shutdown("update");
+    const m = msg;
+    if (m?.type === "office:shutdown") shutdown(m.restart === false ? "stop" : "restart");
   });
 }
 //# sourceMappingURL=index.js.map