cubefarm 0.1.0 → 0.3.0

package/dist-server/index.js

@@ -1,7 +1,7 @@
 // server/index.ts
 import http2 from "node:http";
-import path7 from "node:path";
-import fs5 from "node:fs";
+import path13 from "node:path";
+import fs11 from "node:fs";
 import express from "express";
 import { WebSocketServer } from "ws";
 
@@ -154,6 +154,25 @@ async function createIssue(fullName, title, body, labels = []) {
   if (!match) throw new Error(`Could not read the new issue number from gh output: ${out}`);
   return Number(match[1]);
 }
+async function issueState(fullName, number) {
+  try {
+    const raw = await ghJson(["issue", "view", String(number), "-R", fullName, "--json", "state"]);
+    return raw.state === "OPEN" ? "OPEN" : "CLOSED";
+  } catch {
+    return null;
+  }
+}
+async function editIssue(fullName, number, edit) {
+  const args = ["issue", "edit", String(number), "-R", fullName];
+  if (edit.body !== void 0) args.push("--body-file", "-");
+  for (const l of edit.addLabels ?? []) {
+    await ensureLabel(fullName, l);
+    args.push("--add-label", l);
+  }
+  for (const l of edit.removeLabels ?? []) args.push("--remove-label", l);
+  if (args.length === 5) return;
+  await gh(args, edit.body !== void 0 ? { input: edit.body || " " } : void 0);
+}
 async function mergePull(fullName, number, method, headSha) {
   const pr = await ghJson(["pr", "view", String(number), "-R", fullName, "--json", "headRefName,isCrossRepository"]);
   await gh(["pr", "merge", String(number), "-R", fullName, `--${method}`, ...headSha ? ["--match-head-commit", headSha] : []], { timeoutMs: 6e4 });
@@ -282,37 +301,40 @@ async function syncMain(fullName, defaultBranch, opts) {
   const result = await withRepoLock(fullName, async () => {
     if (!await exists(path2.join(dir, ".git"))) return null;
     const g = (args, timeoutMs) => git(args, { cwd: dir, timeoutMs });
+    let behind = 0;
     try {
       await g(["fetch", "origin", "--prune"], 18e4);
       const target = `origin/${defaultBranch}`;
-      const behind = Number(await g(["rev-list", "--count", `HEAD..${target}`]));
+      behind = Number(await g(["rev-list", "--count", `HEAD..${target}`]));
       const commits = `${behind} commit${behind === 1 ? "" : "s"}`;
       const branch = await g(["symbolic-ref", "--short", "-q", "HEAD"]).catch(() => "");
-      if (branch !== defaultBranch) return { status: `on ${branch ? `branch ${branch}` : "a detached HEAD"}${behind ? ` (${defaultBranch} is ${commits} ahead)` : ""}` };
-      if (behind === 0) return { status: "in sync" };
-      if (Number(await g(["rev-list", "--count", `${target}..HEAD`])) > 0) return { status: `diverged: local commits, and ${commits} to pull` };
-      if (!opts.touch) return { status: `update ready (${commits})` };
-      if (await g(["status", "--porcelain", "--untracked-files=no"])) return { status: `${behind} behind: local changes` };
+      const stays = (status) => ({ status, behind, updatable: false });
+      if (branch !== defaultBranch) return stays(`on ${branch ? `branch ${branch}` : "a detached HEAD"}${behind ? ` (${defaultBranch} is ${commits} ahead)` : ""}`);
+      if (behind === 0) return stays("in sync");
+      if (Number(await g(["rev-list", "--count", `${target}..HEAD`])) > 0) return stays(`diverged: local commits, and ${commits} to pull`);
+      if (!opts.touch) return { status: `update ready (${commits})`, behind, updatable: true };
+      if (await g(["status", "--porcelain", "--untracked-files=no"])) return { status: `${behind} behind: local changes`, behind, updatable: true };
       const before = await g(["rev-parse", "HEAD"]);
       try {
         await g(["merge", "--ff-only", target], 12e4);
       } catch {
-        return { status: `${behind} behind: local files are in the way` };
+        return { status: `${behind} behind: local files are in the way`, behind, updatable: true };
       }
       const changed = (await g(["diff", "--name-only", before, "HEAD"])).split(/\r?\n/);
       const install = changed.some((f) => f === "package.json" || f === "package-lock.json") && await exists(path2.join(dir, "package.json"));
-      return { status: `updated to ${await g(["rev-parse", "--short", "HEAD"])}`, install };
+      return { status: `updated to ${await g(["rev-parse", "--short", "HEAD"])}`, behind: 0, updatable: false, install };
     } catch (err) {
-      return { status: `sync failed: ${err.message.split(/\r?\n/)[0].slice(0, 160)}` };
+      return { status: `sync failed: ${err.message.split(/\r?\n/)[0].slice(0, 160)}`, behind, updatable: false };
     }
   });
-  if (!result?.install) return result?.status ?? null;
+  if (!result?.install) return result;
+  const { install: _install, ...sync } = result;
   try {
     await npmInstall(dir);
-    return `${result.status} \xB7 dependencies installed`;
+    return { ...sync, status: `${sync.status} \xB7 dependencies installed` };
   } catch (err) {
     console.warn(`npm install in ${dir} failed:`, err.message);
-    return `${result.status} \xB7 npm install failed`;
+    return { ...sync, status: `${sync.status} \xB7 npm install failed` };
   }
 }
 function githubFromConfig(config) {
@@ -452,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(", ")})
@@ -473,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]
@@ -484,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 {
@@ -494,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 {
@@ -522,48 +566,37 @@ 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) {
@@ -606,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__", "");
@@ -632,6 +671,8 @@ function describeOfficeTool(action, input) {
       return `\u{1F44B} propose_let_go ${String(input.agent_id ?? "")}`;
     case "file_issue":
       return `\u{1F4DD} file_issue "${clip(String(input.title ?? ""), 70)}"${floor}${input.specialty ? ` \xB7 ${input.specialty}` : ""}`;
+    case "route_issue":
+      return `\u{1F500} route_issue #${String(input.number ?? "?")}${floor}${input.specialty !== void 0 ? ` \xB7 ${input.specialty || "no specialty"}` : ""}${Array.isArray(input.depends_on) ? ` \xB7 depends on ${input.depends_on.map((n) => `#${n}`).join(", ") || "nothing"}` : ""}`;
   }
   return `\u{1F3E2} ${action}(${clip(JSON.stringify(input), 120)})`;
 }
@@ -652,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` }];
@@ -661,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,
@@ -693,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,
@@ -702,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,
@@ -715,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;
@@ -747,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") {
@@ -764,6 +802,9 @@ function startSession(opts, callbacks, defaultBranch) {
           cb.log([{ kind: "error", text: `\u26A0 Subscription usage ${info.status === "rejected" ? "limit reached" : "warning"} (${info.rateLimitType ?? "limit"}) \xB7 resets ${when}` }]);
           const overage = info.isUsingOverage || info.overageStatus === "allowed" || info.overageStatus === "allowed_warning";
           if (info.status === "rejected" && !overage) cb.limited?.(info.resetsAt ? info.resetsAt * 1e3 : null);
+          if (info.status === "allowed_warning" && !overage) {
+            cb.usageWarning?.({ resetsAt: info.resetsAt ? info.resetsAt * 1e3 : null, rateLimitType: info.rateLimitType ?? null, utilization: info.utilization ?? null });
+          }
         }
         break;
       }
@@ -778,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);
@@ -798,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]);
@@ -856,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 });
+  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";
@@ -882,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);
@@ -894,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;
   }
@@ -910,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());
     });
@@ -935,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);
     });
   }
@@ -946,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();
@@ -958,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;
@@ -987,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, "");
@@ -1048,7 +2110,72 @@ 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 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) {
+  return typeof proc.send === "function" && proc.env.SWARM_LAUNCHER === "1";
+}
+function drainDecision(s) {
+  const idle = (state) => ({ state, drainingSince: null, send: false, timedOut: false });
+  if (s.sent) return { state: "updating", drainingSince: s.drainingSince, send: false, timedOut: false };
+  if (s.behind <= 0) return idle("none");
+  if (!s.launcher) return idle(s.failed ? "failed" : "available");
+  const postponed = s.postponedUntil !== null && s.now < s.postponedUntil && s.behind <= s.postponedBehind;
+  const failedHold = s.failed !== null && s.behind <= (s.failedBehind ?? Infinity);
+  const due = s.requested || s.autoUpdate && !postponed && !failedHold;
+  if (!due) return idle(s.failed ? "failed" : s.autoUpdate && postponed ? "waiting" : "available");
+  const since = s.drainingSince ?? s.now;
+  const timedOut = s.running > 0 && s.now - since >= DRAIN_TIMEOUT_MS;
+  return { state: "draining", drainingSince: since, send: s.running === 0 || timedOut, timedOut };
+}
+function parseLastUpdate(raw) {
+  try {
+    const u = JSON.parse(raw);
+    if (!u || typeof u.from !== "string" || typeof u.ok !== "boolean") return null;
+    return {
+      from: u.from,
+      to: typeof u.to === "string" ? u.to : "",
+      ok: u.ok,
+      error: typeof u.error === "string" ? u.error : void 0,
+      installed: !!u.installed,
+      built: !!u.built,
+      at: Number(u.at) || Date.now()
+    };
+  } catch {
+    return null;
+  }
+}
+async function takeLastUpdate(home) {
+  const file = path9.join(home, "last-update.json");
+  const raw = await fs8.readFile(file, "utf8").catch(() => null);
+  if (raw === null) return null;
+  await fs8.rm(file, { force: true, maxRetries: 3 }).catch(() => void 0);
+  return parseLastUpdate(raw);
+}
+function lastUpdateMessage(u, commits) {
+  if (!u.ok) return `\u26A0\uFE0F Update failed and was rolled back: ${u.error || "unknown error"}`;
+  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 = 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),
+  isOwnFolder: (dir) => isSamePath(dir, OFFICE_DIR),
+  commitsBetween: (from, to) => git(["rev-list", "--count", `${from}..${to}`], { cwd: OFFICE_DIR }).then(Number).catch(() => null),
+  takeLastUpdate: () => takeLastUpdate(HOME_DIR),
+  async update(from) {
+    if (!underLauncher()) throw new Error("The office was not started by the launcher");
+    await new Promise((resolve, reject) => process.send({ type: "office:update", from }, void 0, {}, (err) => err ? reject(err) : resolve()));
+    return null;
+  }
 };
 
 // server/backend.ts
@@ -1060,6 +2187,8 @@ var realBackend = {
   listIssues,
   listPulls,
   createIssue,
+  issueState,
+  editIssue,
   mergePull,
   updateBranch,
   closePull,
@@ -1079,15 +2208,21 @@ var realBackend = {
   deskDir,
   prepareDesk,
   removeDesk,
-  releaseDesk,
-  startSession,
-  previews: realPreviews
+  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 path5 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() };
@@ -1095,7 +2230,8 @@ function issue(n, title, body, fullName, labels = []) {
 var repos = /* @__PURE__ */ new Map();
 var bareRepos = /* @__PURE__ */ new Set();
 var mergedSinceSync = /* @__PURE__ */ new Map();
-var fakeSha = () => crypto2.randomBytes(20).toString("hex");
+var closedIssues = /* @__PURE__ */ new Set();
+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(() => {
@@ -1139,7 +2275,7 @@ function screenshotSvg(title, url, hue) {
 </svg>`;
 }
 function devScript(opts, cb, issueNumber, issueTitle) {
-  const branch = path5.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;
@@ -1218,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);
@@ -1277,7 +2413,7 @@ function fakeSession(opts, cb, fullName) {
         number: n,
         title,
         url,
-        headRefName: `swarm/issue-${number}-${path5.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",
@@ -1329,6 +2465,81 @@ 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;
+function fakeUsageWarning(cb) {
+  setTimeout(() => {
+    const resetsAt = Date.now() + USAGE_WARNING_MS;
+    cb.log([{ kind: "error", text: `\u26A0 Subscription usage warning (five_hour) \xB7 resets ${new Date(resetsAt).toLocaleTimeString()} (demo)` }]);
+    cb.usageWarning?.({ resetsAt, rateLimitType: "five_hour", utilization: 0.82 });
+  }, 3e3);
+}
 function createDemoBackend() {
   const deskRepo = /* @__PURE__ */ new Map();
   const folders = /* @__PURE__ */ new Map();
@@ -1379,6 +2590,16 @@ function createDemoBackend() {
       r.issues.push(issue(n, title, body, fullName, labels));
       return n;
     },
+    issueState: async (fullName, number) => {
+      const r = repos.get(fullName);
+      return r?.issues.some((i) => i.number === number) ? "OPEN" : closedIssues.has(`${fullName}#${number}`) ? "CLOSED" : null;
+    },
+    editIssue: async (fullName, number, edit) => {
+      const i = repos.get(fullName)?.issues.find((x) => x.number === number);
+      if (!i) throw new Error(`Unknown issue #${number}`);
+      if (edit.body !== void 0) i.body = edit.body;
+      i.labels = [...i.labels.filter((l) => !edit.removeLabels?.includes(l)), ...(edit.addLabels ?? []).filter((l) => !i.labels.includes(l))];
+    },
     mergePull: async (fullName, number, _method, headSha) => {
       const r = repos.get(fullName);
       const pr = r?.pulls.find((p) => p.number === number);
@@ -1387,6 +2608,7 @@ function createDemoBackend() {
       mergedSinceSync.set(fullName, (mergedSinceSync.get(fullName) ?? 0) + 1);
       pr.state = "MERGED";
       pr.mergedAt = now();
+      for (const n of pr.closesIssues) closedIssues.add(`${fullName}#${n}`);
       r.issues = r.issues.filter((i) => !pr.closesIssues.includes(i.number));
     },
     updateBranch: async (fullName, number) => {
@@ -1428,10 +2650,10 @@ Closes #${pr.closesIssues[0] ?? "?"}`,
     ensureClone: async () => new Promise((r) => setTimeout(r, 400)),
     syncMain: async (fullName, _branch, { touch }) => {
       const behind = mergedSinceSync.get(fullName) ?? 0;
-      if (behind === 0) return "in sync";
-      if (!touch) return `update ready (${behind} commit${behind === 1 ? "" : "s"})`;
+      if (behind === 0) return { status: "in sync", behind: 0, updatable: false };
+      if (!touch) return { status: `update ready (${behind} commit${behind === 1 ? "" : "s"})`, behind, updatable: true };
       mergedSinceSync.set(fullName, 0);
-      return `updated to ${fakeSha().slice(0, 7)}`;
+      return { status: `updated to ${fakeSha().slice(0, 7)}`, behind: 0, updatable: false };
     },
     mainDir: (fullName) => `/demo/${fullName}/main`,
     deskDir: (fullName, slug) => `/demo/${fullName}/desks/${slug}`,
@@ -1443,10 +2665,38 @@ Closes #${pr.closesIssues[0] ?? "?"}`,
     },
     removeDesk: async () => void 0,
     releaseDesk: async () => void 0,
-    startSession: (opts, cb) => opts.role === "ceo" ? ceoSession(opts, cb) : fakeSession(opts, cb, deskRepo.get(opts.cwd) ?? [...repos.keys()][0]),
-    previews: demoPreviews
+    startSession: (opts, cb) => {
+      if (++sessionsStarted === USAGE_WARNING_AT) fakeUsageWarning(cb);
+      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
   };
 }
+var OFFICE_REPO = "demo-co/pixel-todo";
+var DEMO_HEAD = `0ff1ce5${"0".repeat(33)}`;
+var lastFakeUpdate = { to: "", commits: 0 };
+var demoOffice = {
+  launcher: underLauncher() || process.env.SWARM_DEMO_LAUNCHER === "1",
+  head: async () => DEMO_HEAD,
+  isOwnFolder: (dir) => dir === `/demo/${OFFICE_REPO}/main`,
+  // Only its own fake updates have a count; one the real launcher did (u) gets no count rather than a wrong one.
+  commitsBetween: async (_from, to) => to === lastFakeUpdate.to ? lastFakeUpdate.commits : null,
+  takeLastUpdate: () => takeLastUpdate(HOME_DIR),
+  async update(from) {
+    await new Promise((r) => setTimeout(r, 4e3));
+    lastFakeUpdate.commits = mergedSinceSync.get(OFFICE_REPO) ?? 0;
+    mergedSinceSync.set(OFFICE_REPO, 0);
+    lastFakeUpdate.to = fakeSha();
+    return { from, to: lastFakeUpdate.to, ok: true, installed: true, built: true, at: Date.now() };
+  }
+};
 function placeholderPage(title, hue) {
   const safe = title.replace(/[<>&"]/g, "");
   return `<!doctype html>
@@ -1716,6 +2966,13 @@ Acceptance criteria:
           return `Floor ${f.floor} is overstaffed: ${devs} developers for ${f.backlog.length} open issues. I suggest letting ${idle[idle.length - 1].name} go; it's on your phone.`;
         }
       }
+      for (const f of s.floors) {
+        const specialist = f.team.find((a) => a.role === "dev" && a.specialty);
+        const unrouted = f.backlog.find((i) => !i.specialty && !i.inProgress);
+        if (!specialist || !unrouted) continue;
+        const out = await use("route_issue", { floor: f.floor, number: unrouted.number, specialty: specialist.specialty });
+        if (!out.startsWith("Refused")) return `Floor ${f.floor}: #${unrouted.number} had no specialty, so I routed it to ${specialist.specialty}, ${specialist.name}'s lane.`;
+      }
       const issues = s.floors.reduce((n, f) => n + f.backlog.length, 0);
       const prs = s.floors.reduce((n, f) => n + f.pullRequests.length, 0);
       return `All ${s.floors.length} floors look healthy: ${issues} open issues and ${prs} pull requests in flight. No changes needed.`;
@@ -1794,13 +3051,80 @@ Acceptance criteria:
 }
 
 // server/swarm.ts
-import fs4 from "node:fs/promises";
-import path6 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";
 import { z } from "zod";
+
+// shared/issues.ts
+function issueSpecialty(labels) {
+  const l = labels.find((x) => /^swarm:/i.test(x) && !/^swarm:skip$/i.test(x));
+  return l ? l.slice(6).toLowerCase() : "";
+}
+function blockers(body, open) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of (body ?? "").matchAll(/\b(?:depends\s+on|blocked\s+by)\s*:?\s*((?:#\d+(?:\s*(?:,|and|&)\s*)?)+)/gi)) {
+    for (const n of m[1].matchAll(/#(\d+)/g)) if (open.has(Number(n[1]))) out.add(Number(n[1]));
+  }
+  return [...out];
+}
+var DEPENDENCY = /\b(?:depends\s+on|blocked\s+by)\s*:?\s*(?:#\d+(?:\s*(?:,|and|&)\s*)?)+/gi;
+var STATEMENT = new RegExp(`\\s*${DEPENDENCY.source}[.;,]?`, "gi");
+function setDependsOn(body, deps) {
+  const lines = [];
+  let dropped = false;
+  for (const line of (body ?? "").split(/\r?\n/)) {
+    const rest2 = line.match(DEPENDENCY) ? line.replace(STATEMENT, "").trimEnd() : line;
+    if (rest2 !== line && !/[\p{L}\p{N}]/u.test(rest2)) {
+      dropped = true;
+      continue;
+    }
+    if (dropped && !rest2.trim() && !lines[lines.length - 1]?.trim()) continue;
+    dropped = false;
+    lines.push(rest2);
+  }
+  while (lines.length && !lines[0].trim()) lines.shift();
+  const rest = lines.join("\n");
+  if (deps.length === 0) return rest;
+  return `Depends on ${deps.map((n) => `#${n}`).join(", ")}${rest ? `
+
+${rest}` : ""}`;
+}
+function holdUps(issues) {
+  const open = new Set(issues.map((i) => i.number));
+  const waiters = /* @__PURE__ */ new Map();
+  for (const i of issues) for (const b of blockers(i.body, open)) waiters.set(b, [...waiters.get(b) ?? [], i.number]);
+  const chains = /* @__PURE__ */ new Map();
+  const visiting = /* @__PURE__ */ new Set();
+  const chain = (n) => {
+    const known = chains.get(n);
+    if (known !== void 0) return known;
+    if (visiting.has(n)) return 0;
+    visiting.add(n);
+    const longest = Math.max(0, ...(waiters.get(n) ?? []).map((w) => chain(w) + 1));
+    visiting.delete(n);
+    chains.set(n, longest);
+    return longest;
+  };
+  const out = /* @__PURE__ */ new Map();
+  for (const i of issues) {
+    const seen = /* @__PURE__ */ new Set();
+    const stack = [...waiters.get(i.number) ?? []];
+    while (stack.length) {
+      const n = stack.pop();
+      if (n === i.number || seen.has(n)) continue;
+      seen.add(n);
+      stack.push(...waiters.get(n) ?? []);
+    }
+    out.set(i.number, { chain: chain(i.number), waiting: seen.size });
+  }
+  return out;
+}
+
+// server/ceo.ts
 var EFFORT = z.enum(["low", "medium", "high", "xhigh", "max"]);
 function createOfficeTools(h) {
   const run2 = async (fn) => {
@@ -1880,11 +3204,23 @@ function createOfficeTools(h) {
         specialty: z.string().max(24).optional()
       },
       (a) => run2(() => h.fileIssue(a))
+    ),
+    tool(
+      "route_issue",
+      'Fix the routing of an open issue instead of filing a duplicate: change its specialty, rewrite its "Depends on #N" line, or both. The rest of the body stays as it is.',
+      {
+        floor: z.number().int(),
+        number: z.number().int().positive().describe("The issue number"),
+        specialty: z.string().max(24).optional().describe('Sets swarm:<specialty> and removes any other; "" for none. Someone on the floor, or a pending proposal, must have it.'),
+        depends_on: z.array(z.number().int().positive()).max(10).optional().describe("Issues it waits for; [] for none. Not for an issue in progress.")
+      },
+      (a) => run2(() => h.routeIssue(a))
     )
   ];
   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}`);
@@ -1897,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).",
     "",
@@ -1917,7 +3253,8 @@ function ceoSystemPrompt(o) {
     '- Titles are specific ("Three.js graphics engineer", not "Developer"). A specialty is a short lowercase slug ("graphics", "gameplay", "frontend", "backend", "content", "a11y", "devops"). Only route an issue to a specialty that someone on the floor has, or that you are proposing to hire.',
     "- Before proposing a hire, check the floor and the pending proposals for someone who already covers it. If the manager declined a similar proposal (recentDecisions), do not propose it again unless something has changed, and say what.",
     `- ${o.hiring === "auto" ? "Hiring is on auto: proposals within the team cap are approved immediately, so be deliberate." : "The manager approves every hire, so explain each reason in a sentence or two they can decide on."}`,
-    `- Issues: plan for parallel work. What keeps a floor busy is the number of issues that can start right now (capacity.issuesReadyToStart in company_status); aim for at least one per developer. Write "Depends on #N" only when an issue truly cannot start until #N's code is merged, because it waits until #N is closed. Keep dependency chains to two steps at most, keep foundation issues small, and split big pieces into parts that can be built side by side. The office starts the issues that hold up others first. Do not duplicate open issues. File at most 12 issues per job.`,
+    `- Issues: plan for parallel work. What keeps a floor busy is the number of issues that can start right now (capacity.issuesReadyToStart in company_status); aim for at least one per developer. Write "Depends on #N" only when an issue truly cannot start until #N's code is merged, because it waits until #N is closed. Keep dependency chains to two steps at most, keep foundation issues small, and split big pieces into parts that can be built side by side. The office starts the issues that hold up others first. Do not duplicate open issues: fix an existing issue's specialty or dependencies with route_issue. File at most 12 issues per job, or per message from the manager.`,
+    "- When company.usage in company_status says pacing or paused, Claude's usage is running low and the office is finishing open work first: file only what is needed next, not a whole milestone.",
     "- Your final message goes straight to the manager's phone. Keep it short and plain: what you found, what you proposed, what you filed, and any question you need answered. No headings, no tables."
   ].join("\n");
 }
@@ -1951,7 +3288,7 @@ ${floor.backlog === 0 ? "The backlog is empty: plan the first milestone as issue
       return [
         "Periodic review of the company. For every floor, look at:",
         "- floors without a profile or QA brief: study them and write one",
-        "- backlog against the team (capacity): fewer issues ready to start than free developers, long dependency chains, a specialty with a long queue",
+        "- backlog against the team (capacity): fewer issues ready to start than free developers, long dependency chains, a specialty with a long queue (fix those with route_issue)",
         "- pull requests stuck in QA or marked as needing a human",
         "- floors with a brief and an empty backlog: plan the next milestone",
         "Propose hires or let-gos only when clearly justified. If nothing needs doing, reply with one short sentence saying so."
@@ -1974,6 +3311,81 @@ function jobLabel(job, floor) {
       return "Replying to you";
   }
 }
+var IssueCap = class {
+  // floors that got issues, to refresh when the job ends
+  constructor(max) {
+    this.max = max;
+  }
+  max;
+  filed = 0;
+  // since the job started or the manager's last message
+  total = 0;
+  // in the whole job
+  repos = /* @__PURE__ */ new Set();
+  check() {
+    if (this.filed >= this.max) throw new Error(`You already filed ${this.max} issues in this job. That's plenty for one milestone. The manager's next message allows more.`);
+  }
+  record(repoId2) {
+    this.filed++;
+    this.total++;
+    this.repos.add(repoId2);
+  }
+  managerMessage() {
+    this.filed = 0;
+  }
+};
+function waitsDepth(n, deps, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(n)) return 0;
+  seen.add(n);
+  const depth = Math.max(0, ...(deps.get(n) ?? []).map((d) => waitsDepth(d, deps, seen) + 1));
+  seen.delete(n);
+  return depth;
+}
+function planRoute(r) {
+  const issue2 = r.issues.find((i) => i.number === r.number);
+  if (!issue2) throw new Error(r.closed(r.number) ? `#${r.number} is closed.` : `There is no open issue #${r.number} on floor ${r.floor}.`);
+  if (r.specialty === void 0 && r.dependsOn === void 0) throw new Error("Nothing to change: pass specialty, depends_on or both.");
+  const plan = { addLabels: [], removeLabels: [], body: null, summary: "" };
+  const done = [];
+  if (r.specialty !== void 0) {
+    const slug = specialtySlug(r.specialty);
+    if (r.specialty.trim() && !slug) throw new Error(`"${r.specialty}" is not a specialty. Use a short lowercase slug, or "" for none.`);
+    if (slug && !r.specialties.includes(slug)) {
+      const have = [...new Set(r.specialties)].join(", ") || "none";
+      throw new Error(`Nobody on floor ${r.floor} has the specialty "${slug}", and no pending proposal does. Specialties there: ${have}.`);
+    }
+    const label = slug ? specialtyLabel(slug) : null;
+    plan.removeLabels = issue2.labels.filter((l) => /^swarm:/i.test(l) && !/^swarm:skip$/i.test(l) && l !== label);
+    if (label && !issue2.labels.includes(label)) plan.addLabels = [label];
+    done.push(slug ? `routed to ${slug}` : "no specialty");
+  }
+  if (r.dependsOn !== void 0) {
+    if (r.inProgress) throw new Error(`#${r.number} is already in progress, so its dependencies can't change. Changing its specialty is fine.`);
+    const deps = [...new Set(r.dependsOn.map(Number))];
+    const open = new Set(r.issues.map((i) => i.number));
+    for (const d of deps) {
+      if (d === r.number) throw new Error(`#${r.number} can't depend on itself.`);
+      if (!open.has(d)) throw new Error(r.closed(d) ? `#${d} is closed, so there's nothing to wait for.` : `There is no open issue #${d} on floor ${r.floor}.`);
+    }
+    const body = setDependsOn(issue2.body, deps);
+    const after = r.issues.map((i) => i.number === r.number ? { ...i, body } : i);
+    const waits = new Map(after.map((i) => [i.number, blockers(i.body, open)]));
+    const loop = deps.find((d) => reaches(d, r.number, waits));
+    if (loop !== void 0) throw new Error(`#${loop} already waits for #${r.number}, directly or through other issues, so that would be a cycle.`);
+    const depth = waitsDepth(r.number, waits) + (holdUps(after).get(r.number)?.chain ?? 0);
+    if (depth > 2) throw new Error(`That makes a dependency chain ${depth} steps deep through #${r.number}. Keep chains to 2 steps at most: split the work so more of it can start side by side.`);
+    if (body !== issue2.body) plan.body = body;
+    done.push(deps.length ? `depends on ${deps.map((d) => `#${d}`).join(", ")}` : "no dependencies");
+  }
+  plan.summary = `#${r.number} on floor ${r.floor}: ${done.join(", ")}.`;
+  return plan;
+}
+function reaches(from, to, waits, seen = /* @__PURE__ */ new Set()) {
+  if (from === to) return true;
+  if (seen.has(from)) return false;
+  seen.add(from);
+  return (waits.get(from) ?? []).some((n) => reaches(n, to, waits, seen));
+}
 function specialtySlug(s) {
   const slug = String(s ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 24);
   return slug === "skip" ? "" : slug;
@@ -1989,6 +3401,38 @@ var HttpError = class extends Error {
   status;
 };
 
+// server/mergeGate.ts
+var MAX_MERGE_FIXES = 3;
+var CHECKS_ALERT_MS = 30 * 6e4;
+var MERGE_RETRY_MS = 10 * 6e4;
+function mergeStep(pr, rec, now2, opts) {
+  if (pr.isDraft) return { do: "wait", note: "a draft: waiting", set: {} };
+  if (!opts.detailed && (pr.mergeable === "UNKNOWN" || pr.mergeState === "UNKNOWN")) return { do: "details", set: {} };
+  const set = {};
+  if (rec.passedSha == null) set.passedSha = pr.headSha;
+  if (pr.headSha !== (set.passedSha ?? rec.passedSha)) return { do: "requeue", set };
+  const needsHuman = rec.mergeFixes >= MAX_MERGE_FIXES;
+  if (pr.mergeable === "CONFLICTING" || pr.mergeState === "DIRTY") {
+    return { do: "send-back", reason: "conflict", instructions: `It conflicts with ${opts.base}.`, needsHuman, set };
+  }
+  if (pr.checks === "failing") {
+    const instructions = pr.failedChecks.map((c) => `- ${c.name}${c.url ? `: ${c.url}` : ""}`).join("\n");
+    return { do: "send-back", reason: "checks", instructions, needsHuman, set };
+  }
+  if (pr.checks === "pending") {
+    const since = rec.pendingSince ?? now2;
+    if (rec.pendingSince == null) set.pendingSince = since;
+    const alert = now2 - since > CHECKS_ALERT_MS && !rec.alerted;
+    if (alert) set.alerted = true;
+    return { do: "wait", note: `waiting for checks: ${pr.pendingChecks.join(", ") || "running"}`, alert, set };
+  }
+  set.pendingSince = null;
+  if (pr.mergeable === "UNKNOWN") return { do: "wait", note: "GitHub is checking it can merge", set };
+  if (pr.mergeState === "BEHIND") return { do: "update-branch", set };
+  if (rec.mergeRetryAt && now2 < rec.mergeRetryAt) return { do: "wait", set };
+  return { do: "merge", set };
+}
+
 // server/previews.ts
 var PREVIEW_BASE_PORT = 6300;
 var LOG_KEEP = 200;
@@ -2189,47 +3633,232 @@ var Previews = class {
   }
 };
 
-// shared/issues.ts
-function issueSpecialty(labels) {
-  const l = labels.find((x) => /^swarm:/i.test(x) && !/^swarm:skip$/i.test(x));
-  return l ? l.slice(6).toLowerCase() : "";
+// server/pacing.ts
+var PACING_MS = 60 * 6e4;
+var DEFAULT_PACING_SESSIONS = 3;
+function mayStart(kind, c) {
+  if (c.now < c.pausedUntil) return false;
+  if (kind === "issue" && c.now < c.pacingUntil) return c.running < c.pacingSessions;
+  return true;
 }
-function blockers(body, open) {
-  const out = /* @__PURE__ */ new Set();
-  for (const m of (body ?? "").matchAll(/\b(?:depends\s+on|blocked\s+by)\s*:?\s*((?:#\d+(?:\s*(?:,|and|&)\s*)?)+)/gi)) {
-    for (const n of m[1].matchAll(/#(\d+)/g)) if (open.has(Number(n[1]))) out.add(Number(n[1]));
-  }
-  return [...out];
+function usageView(c) {
+  if (c.now < c.pausedUntil) return { state: "paused", until: c.pausedUntil };
+  if (c.now < c.pacingUntil) return { state: "pacing", until: c.pacingUntil };
+  return { state: "normal", until: null };
 }
-function holdUps(issues) {
-  const open = new Set(issues.map((i) => i.number));
-  const waiters = /* @__PURE__ */ new Map();
-  for (const i of issues) for (const b of blockers(i.body, open)) waiters.set(b, [...waiters.get(b) ?? [], i.number]);
-  const chains = /* @__PURE__ */ new Map();
-  const visiting = /* @__PURE__ */ new Set();
-  const chain = (n) => {
-    const known = chains.get(n);
-    if (known !== void 0) return known;
-    if (visiting.has(n)) return 0;
-    visiting.add(n);
-    const longest = Math.max(0, ...(waiters.get(n) ?? []).map((w) => chain(w) + 1));
-    visiting.delete(n);
-    chains.set(n, longest);
-    return longest;
-  };
-  const out = /* @__PURE__ */ new Map();
-  for (const i of issues) {
-    const seen = /* @__PURE__ */ new Set();
-    const stack = [...waiters.get(i.number) ?? []];
-    while (stack.length) {
-      const n = stack.pop();
-      if (n === i.number || seen.has(n)) continue;
-      seen.add(n);
-      stack.push(...waiters.get(n) ?? []);
+function clock(at, now2) {
+  const d = new Date(at);
+  const hm = `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+  return d.toDateString() === new Date(now2).toDateString() ? hm : `${d.toLocaleDateString("en-US", { weekday: "short" })} ${hm}`;
+}
+function usageLabel(u, now2) {
+  return u.state === "normal" || u.until === null ? "normal" : `${u.state} until ${clock(u.until, now2)}`;
+}
+function clampPacingSessions(v) {
+  const n = Math.round(Number(v));
+  return Number.isFinite(n) && n > 0 ? Math.min(32, n) : DEFAULT_PACING_SESSIONS;
+}
+var LIMIT_NAMES = {
+  five_hour: "5-hour limit",
+  seven_day: "weekly limit",
+  seven_day_opus: "weekly Opus limit",
+  seven_day_sonnet: "weekly Sonnet limit"
+};
+function pacingMessage(w, until, sessions, now2) {
+  const pct = w.utilization === null ? null : Math.round(w.utilization <= 1 ? w.utilization * 100 : w.utilization);
+  const what = [w.rateLimitType ? LIMIT_NAMES[w.rateLimitType] ?? w.rateLimitType.replace(/_/g, " ") : null, pct === null ? null : `${pct}%`].filter(Boolean).join(", ");
+  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);
     }
-    out.set(i.number, { chain: chain(i.number), waiting: seen.size });
   }
-  return out;
+  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
@@ -2279,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 = path6.join(HOME_DIR, "ceo");
-var DEFAULT_PROJECTS_DIR = defaultProjectsDir(path6.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;
@@ -2292,20 +3921,15 @@ var FREE = ["idle", "done"];
 var ERROR_COOLDOWN_MS = 2 * 6e4;
 var MAX_ISSUE_FAILURES = 2;
 var LIMIT_PAUSE_MS = 15 * 6e4;
-var MAX_MERGE_FIXES = 3;
-var CHECKS_ALERT_MS = 30 * 6e4;
-var MERGE_RETRY_MS = 10 * 6e4;
-var OFFICE_DIR = path6.resolve(import.meta.dirname, "..");
-var isSamePath = (a, b) => process.platform === "win32" ? path6.resolve(a).toLowerCase() === path6.resolve(b).toLowerCase() : path6.resolve(a) === path6.resolve(b);
 var oneLine = (err) => (err instanceof Error ? err.message : String(err)).split(/\r?\n/)[0].slice(0, 200);
-var SCREENS_DIR = path6.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) => path6.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 = path6.join(SCREENS_DIR, `${agentId}.${ext}`);
+    const file = path12.join(SCREENS_DIR, `${agentId}.${ext}`);
     try {
-      const [data, stat] = await Promise.all([fs4.readFile(file), fs4.stat(file)]);
+      const [data, stat] = await Promise.all([fs10.readFile(file), fs10.stat(file)]);
       return { data, mime, at: stat.mtimeMs };
     } catch {
     }
@@ -2313,8 +3937,11 @@ async function loadScreen(agentId) {
   return null;
 }
 async function removeScreens(agentId) {
-  await Promise.all(Object.values(MIME_EXT).map((ext) => fs4.rm(path6.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,
@@ -2357,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;
       }
@@ -2381,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, {
@@ -2397,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,
@@ -2405,7 +4035,9 @@ var Swarm = class {
       companyName: "",
       projectsDir: DEFAULT_PROJECTS_DIR,
       setupDone: false,
-      tutorialStep: 0
+      tutorialStep: 0,
+      autoUpdate: true,
+      pacingSessions: DEFAULT_PACING_SESSIONS
     },
     repos: [],
     agents: [],
@@ -2427,10 +4059,11 @@ var Swarm = class {
       updateJob: (a) => this.updateJob(a),
       proposeHire: (a) => this.proposeHire(a),
       proposeLetGo: (a) => this.proposeLetGo(a),
-      fileIssue: (a) => this.fileIssue(a)
+      fileIssue: (a) => this.fileIssue(a),
+      routeIssue: (a) => this.routeIssue(a)
     });
   }
-  ceoIssues = { filed: 0, repos: /* @__PURE__ */ new Set() };
+  ceoIssues = new IssueCap(MAX_ISSUES_PER_JOB);
   // issues filed during the current CEO job
   messageSeq = 1;
   agentRt = /* @__PURE__ */ new Map();
@@ -2442,10 +4075,26 @@ var Swarm = class {
   flushTimer = null;
   logSeq = 1;
   previews;
+  officeHead = null;
+  // the commit the office runs (null: not a git checkout, so no self-update)
+  officeUpdate = {
+    behind: 0,
+    requested: false,
+    postponedUntil: null,
+    postponedBehind: 0,
+    failed: null,
+    failedBehind: null,
+    drainingSince: null,
+    sent: false,
+    handedOver: false
+    // sessions cut off by the hand-over are the restarted office's to recover
+  };
+  lastOfficeView = "";
+  clis = [];
   // ---------- lifecycle ----------
   async init() {
     try {
-      const raw = await fs4.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 },
@@ -2468,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,
@@ -2488,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 });
       }
@@ -2505,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) {
@@ -2534,14 +4204,23 @@ 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)
     ]);
     for (const r of this.state.repos) void this.previews.refreshDefault(r);
     this.recover(interrupted);
+    this.officeHead = await this.backend.office.head();
+    const updated = await this.backend.office.takeLastUpdate().catch(() => null);
+    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);
   }
@@ -2613,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,
@@ -2660,7 +4341,11 @@ var Swarm = class {
       requests: this.state.requests,
       ceo: this.ceoInfo(),
       messages: this.state.messages.slice(-100),
-      phoneReadAt: this.state.phoneReadAt
+      phoneReadAt: this.state.phoneReadAt,
+      usage: this.usageNow(),
+      clis: this.clis,
+      officeCommit: this.officeHead?.slice(0, 7) ?? null,
+      officeUpdate: this.officeHead ? this.officeUpdateView() : void 0
     };
   }
   screenshot(agentId) {
@@ -2719,14 +4404,17 @@ var Swarm = class {
   // ---------- persistence ----------
   save() {
     if (this.saveTimer) return;
-    this.saveTimer = setTimeout(async () => {
-      this.saveTimer = null;
-      for (const a of this.state.agents) a.logTail = (this.agentRt.get(a.id)?.log ?? []).slice(-200);
-      await fs4.mkdir(path6.dirname(STATE_FILE), { recursive: true });
-      const tmp = `${STATE_FILE}.tmp`;
-      await fs4.writeFile(tmp, JSON.stringify(this.state, null, 2));
-      await fs4.rename(tmp, STATE_FILE);
-    }, 1500);
+    this.saveTimer = setTimeout(() => void this.writeState().catch((err) => console.warn("could not save the state", err)), 1500);
+  }
+  /** Write the state file now, e.g. before the office stops or hands itself to the launcher. */
+  async writeState() {
+    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 fs10.mkdir(path12.dirname(STATE_FILE), { recursive: true });
+    const tmp = `${STATE_FILE}.tmp`;
+    await fs10.writeFile(tmp, JSON.stringify(this.state, null, 2));
+    await fs10.rename(tmp, STATE_FILE);
   }
   // ---------- lookups ----------
   repo(id) {
@@ -2808,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 path6.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) {
@@ -2820,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() ? path6.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) => path6.resolve(a).toLowerCase() === path6.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) })) };
   }
@@ -2921,46 +4609,38 @@ var Swarm = class {
   }
   /** One step toward merging a QA-passed PR. Returns true when it merged. */
   async advanceMerge(repo, rec, pr) {
-    if (pr.isDraft) return this.mergeNote(rec, "a draft: waiting");
-    if (pr.mergeable === "UNKNOWN" || pr.mergeState === "UNKNOWN") {
+    let step = mergeStep(pr, rec, Date.now(), { base: repo.defaultBranch });
+    if (step.do === "details") {
       const d = await this.backend.prDetails(repo.fullName, pr.number);
       pr = { ...pr, headSha: d.headSha, mergeable: d.mergeable, mergeState: d.mergeState };
+      step = mergeStep(pr, rec, Date.now(), { base: repo.defaultBranch, detailed: true });
     }
-    rec.passedSha ??= pr.headSha;
-    if (pr.headSha !== rec.passedSha) {
+    Object.assign(rec, step.set);
+    if (step.do === "requeue") {
       this.setQa(rec, { status: "queued", round: rec.round + 1, retests: rec.retests + 1, mergeNote: null, pendingSince: null });
       setTimeout(() => this.schedule(), 200);
       return false;
     }
-    if (pr.mergeable === "CONFLICTING" || pr.mergeState === "DIRTY") {
-      return this.sendBack(repo, rec, "conflict", `It conflicts with ${repo.defaultBranch}.`);
-    }
-    if (pr.checks === "failing") {
-      return this.sendBack(repo, rec, "checks", pr.failedChecks.map((c) => `- ${c.name}${c.url ? `: ${c.url}` : ""}`).join("\n"));
-    }
-    if (pr.checks === "pending") {
-      rec.pendingSince ??= Date.now();
-      if (Date.now() - rec.pendingSince > CHECKS_ALERT_MS && !rec.alerted) {
-        rec.alerted = true;
+    if (step.do === "send-back") return this.sendBack(repo, rec, step.reason, step.instructions, step.needsHuman);
+    if (step.do === "wait") {
+      if (step.alert) {
         this.postMessage("office", `\u23F3 PR #${pr.number} on ${repo.fullName} passed QA, but its checks (${pr.pendingChecks.join(", ")}) have been running for over ${CHECKS_ALERT_MS / 6e4} minutes. It merges as soon as they finish.`);
       }
-      return this.mergeNote(rec, `waiting for checks: ${pr.pendingChecks.join(", ") || "running"}`);
+      return step.note === void 0 ? false : this.mergeNote(rec, step.note);
     }
-    rec.pendingSince = null;
-    if (pr.mergeable === "UNKNOWN") return this.mergeNote(rec, "GitHub is checking it can merge");
-    if (pr.mergeState === "BEHIND") {
+    if (step.do === "update-branch") {
       this.mergeNote(rec, `updating the branch with ${repo.defaultBranch}`);
       await this.backend.updateBranch(repo.fullName, pr.number);
       const details = await this.backend.prDetails(repo.fullName, pr.number);
       this.setQa(rec, { passedSha: details.headSha });
       return false;
     }
-    if (rec.mergeRetryAt && Date.now() < rec.mergeRetryAt) return false;
+    if (step.do !== "merge") return false;
     this.mergeNote(rec, "merging\u2026");
     let error = "";
     for (const method of ["squash", "merge", "rebase"]) {
       try {
-        await this.backend.mergePull(repo.fullName, pr.number, method, rec.passedSha);
+        await this.backend.mergePull(repo.fullName, pr.number, method, rec.passedSha ?? pr.headSha);
         error = "";
         break;
       } catch (err) {
@@ -2989,8 +4669,8 @@ var Swarm = class {
     return false;
   }
   /** QA passed, but the PR can't merge as it is: a developer fixes it, and QA re-tests if the code changed. */
-  sendBack(repo, rec, reason, fixInstructions) {
-    if (rec.mergeFixes >= MAX_MERGE_FIXES) {
+  sendBack(repo, rec, reason, fixInstructions, needsHuman) {
+    if (needsHuman) {
       this.setQa(rec, { status: "needs-human", mergeNote: null });
       this.postMessage("office", `\u26A0\uFE0F PR #${rec.prNumber} on ${repo.fullName} still ${reason === "conflict" ? `conflicts with ${repo.defaultBranch}` : "fails its checks"} after ${MAX_MERGE_FIXES} fixes, so it needs you.`);
       return false;
@@ -3003,14 +4683,16 @@ var Swarm = class {
   async syncFolder(repo) {
     const rt = this.repoRt.get(repo.id);
     if (!rt || rt.cloneStatus !== "ready") return rt?.folderSync ?? null;
-    const own = isSamePath(this.backend.mainDir(repo.fullName), OFFICE_DIR);
-    const status = await this.backend.syncMain(repo.fullName, repo.defaultBranch, { touch: !own }).catch((err) => `sync failed: ${oneLine(err)}`);
+    const own = this.backend.office.isOwnFolder(this.backend.mainDir(repo.fullName));
+    const sync = await this.backend.syncMain(repo.fullName, repo.defaultBranch, { touch: !own }).catch((err) => ({ status: `sync failed: ${oneLine(err)}`, behind: 0, updatable: false }));
+    const status = sync?.status ?? null;
+    if (own && sync) this.setOfficeBehind(sync.updatable ? sync.behind : 0);
     if (!this.repoRt.has(repo.id)) return null;
     const before = rt.folderSync;
     rt.folderSync = status;
     this.emitRepo(repo);
     if (status && status !== before) {
-      const name = repo.localPath ? path6.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}`);
     }
@@ -3029,9 +4711,15 @@ 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. */
-  shutdown() {
-    return this.previews.stopAll(this.state.repos);
+  /**
+   * 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) {
     const repo = this.state.repos.find((r) => r.id === id);
@@ -3141,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,
@@ -3157,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,
@@ -3168,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` : ""}` }] : []
@@ -3195,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);
@@ -3222,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;
@@ -3248,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`);
@@ -3255,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();
@@ -3289,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}`;
@@ -3380,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),
@@ -3408,6 +5173,7 @@ Note from the manager: ${note}` : ""
         },
         sessionId: (id) => {
           a.sessionId = id;
+          a.sessionCli = how.cli ?? "claude";
         },
         browserUrl: (url) => {
           rt.browserUrl = url;
@@ -3419,23 +5185,25 @@ 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(() => fs4.mkdir(SCREENS_DIR, { recursive: true })).then(() => fs4.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) {
     const rt = this.agentRt.get(a.id);
     if (!rt || !this.state.agents.includes(a)) return;
+    if (this.officeUpdate.handedOver) return;
     rt.session = null;
     rt.currentTool = null;
     a.endedAt = Date.now();
     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);
@@ -3571,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."
@@ -3808,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);
@@ -3816,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.`);
@@ -3829,22 +5598,28 @@ 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 = path6.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;
+    if (patch.pacingSessions !== void 0) s.pacingSessions = clampPacingSessions(patch.pacingSessions);
     this.save();
     this.broadcast({ type: "settings", settings: s });
     this.emitCeo();
@@ -3879,6 +5654,9 @@ Full report with screenshots: ${rec.commentUrl}` : "",
   // `${repoId}#${issue}`: its developer was asked once to finish the missing PR
   pausedUntil = 0;
   // Claude's usage limit was hit: nothing new starts before this
+  pacingUntil = 0;
+  // Claude warned about usage: new issues are paced until this
+  lastUsage = "";
   /** Backlog issues that can start now, most urgent first: the ones holding up the longest chain of other issues, then the oldest. */
   readyIssues(repo) {
     const issues = this.repoRt.get(repo.id).issues;
@@ -3938,7 +5716,7 @@ Full report with screenshots: ${rec.commentUrl}` : "",
    * free developer is least needed elsewhere, so nobody sits idle while there is work that can start.
    */
   startIssueWork(repo) {
-    if (!repo.autoAssign) return false;
+    if (!repo.autoAssign || !this.mayStart("issue")) return false;
     const free = this.available(repo, "dev");
     const ready = free.length ? this.readyIssues(repo) : [];
     if (ready.length === 0) return false;
@@ -3958,6 +5736,39 @@ Full report with screenshots: ${rec.commentUrl}` : "",
     const fresh = Date.now() >= this.pausedUntil;
     this.pausedUntil = until;
     if (fresh) this.postMessage("office", `\u23F8 Claude's usage limit was reached. The office starts no new work until ${new Date(until).toLocaleTimeString()}; sessions already running carry on.`);
+    this.emitUsage();
+  }
+  /** Claude warned that usage is getting high: pace new issues until the window resets, rather than run into the limit. */
+  paceForWarning(info) {
+    const now2 = Date.now();
+    const until = info.resetsAt && info.resetsAt > now2 ? info.resetsAt : now2 + PACING_MS;
+    if (until <= this.pacingUntil) return;
+    const fresh = now2 >= this.pacingUntil;
+    this.pacingUntil = until;
+    if (fresh) this.postMessage("office", pacingMessage(info, until, this.state.settings.pacingSessions, now2));
+    this.emitUsage();
+  }
+  /** May work of this kind start now, as far as Claude's usage goes? */
+  mayStart(kind) {
+    return mayStart(kind, { now: Date.now(), pausedUntil: this.pausedUntil, pacingUntil: this.pacingUntil, running: this.running(), pacingSessions: this.state.settings.pacingSessions });
+  }
+  usageNow() {
+    return usageView({ now: Date.now(), pausedUntil: this.pausedUntil, pacingUntil: this.pacingUntil });
+  }
+  emitUsage() {
+    const usage = this.usageNow();
+    const key = JSON.stringify(usage);
+    if (key === this.lastUsage) return;
+    this.lastUsage = key;
+    this.broadcast({ type: "usage", usage });
+  }
+  /** Pacing and pauses run out on their own: say so when pacing ends. */
+  tickUsage() {
+    if (this.pacingUntil && Date.now() >= this.pacingUntil) {
+      this.pacingUntil = 0;
+      this.postMessage("office", "\u2705 Claude's usage is back to normal. The office starts new work at full speed again.");
+    }
+    this.emitUsage();
   }
   /** A failed session releases its issue for someone else; an issue that keeps failing waits for the manager. */
   issueFailed(repo, n) {
@@ -3975,6 +5786,8 @@ Full report with screenshots: ${rec.commentUrl}` : "",
    * so no repo can hog the slots.
    */
   schedule() {
+    this.tickUsage();
+    if (this.officeUpdateTick()) return;
     if (this.limited()) return;
     this.maybeHeartbeat();
     this.startCeoWork();
@@ -3996,6 +5809,126 @@ Full report with screenshots: ${rec.commentUrl}` : "",
       }
     }
   }
+  // ---------- the office's own update ----------
+  drainInput() {
+    const u = this.officeUpdate;
+    return {
+      now: Date.now(),
+      behind: this.officeHead ? u.behind : 0,
+      launcher: this.backend.office.launcher,
+      autoUpdate: this.state.settings.autoUpdate !== false,
+      requested: u.requested,
+      postponedUntil: u.postponedUntil,
+      postponedBehind: u.postponedBehind,
+      failed: u.failed,
+      failedBehind: u.failedBehind,
+      drainingSince: u.drainingSince,
+      sent: u.sent,
+      running: this.running()
+    };
+  }
+  officeUpdateView() {
+    const u = this.officeUpdate;
+    const input = this.drainInput();
+    const d = drainDecision(input);
+    const until = u.postponedUntil ? new Date(u.postponedUntil).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" }) : "";
+    const detail = d.state === "failed" ? u.failed : d.state === "waiting" ? `Postponed until ${until}, or until a newer commit lands.` : null;
+    return { state: d.state, behind: input.behind, launcher: input.launcher, drainingSince: u.drainingSince ?? d.drainingSince, running: input.running, detail };
+  }
+  emitOfficeUpdate() {
+    if (!this.officeHead) return;
+    const view = this.officeUpdateView();
+    const key = JSON.stringify(view);
+    if (key === this.lastOfficeView) return;
+    this.lastOfficeView = key;
+    this.broadcast({ type: "officeUpdate", officeUpdate: view });
+  }
+  /** The own-folder check found the office this many commits behind GitHub. */
+  setOfficeBehind(behind) {
+    const u = this.officeUpdate;
+    if (u.failed && u.failedBehind === null) u.failedBehind = behind;
+    u.behind = behind;
+    if (behind === 0) Object.assign(u, { requested: false, failed: null, failedBehind: null });
+    this.officeUpdateTick();
+  }
+  /**
+   * Take the office's own update one step (see drainDecision): drain, and once nothing is running, or the drain timed
+   * out, hand it to the launcher. True while nothing new may start.
+   */
+  officeUpdateTick() {
+    if (!this.officeHead) return false;
+    const u = this.officeUpdate;
+    const d = drainDecision(this.drainInput());
+    if (d.state === "draining" && u.drainingSince === null) {
+      const running = this.running();
+      this.postMessage(
+        "office",
+        `\u2B06\uFE0F Updating the office (${u.behind} new commit${u.behind === 1 ? "" : "s"}). Nothing new starts${running ? ` while ${running} running session${running === 1 ? "" : "s"} finish` : ""}; then it installs and restarts.`
+      );
+    }
+    u.drainingSince = d.drainingSince;
+    if (d.send) void this.handOver(d.timedOut);
+    this.emitOfficeUpdate();
+    return d.state === "draining" || d.state === "updating";
+  }
+  /** Drained: hand the update to the launcher. Sessions still running after the timeout stop the way a restart stops them. */
+  async handOver(timedOut) {
+    const u = this.officeUpdate;
+    const from = this.officeHead;
+    u.sent = true;
+    const busy = this.state.agents.filter((a) => BUSY.includes(a.status));
+    if (timedOut) this.postMessage("office", `\u23F1 ${busy.length} session${busy.length === 1 ? " was" : "s were"} still running after 20 minutes. Stopped; the work goes back to the queue after the update.`);
+    this.emitOfficeUpdate();
+    u.handedOver = true;
+    await this.writeState().catch((err) => console.warn("could not save the state", err));
+    for (const a of busy) this.agentRt.get(a.id)?.session?.stop();
+    try {
+      const result = await this.backend.office.update(from);
+      if (result) await this.afterUpdate(result);
+    } catch (err) {
+      await this.afterUpdate({ from, to: from, ok: false, error: `the launcher didn't take the update: ${oneLine(err)}`, installed: false, built: false, at: Date.now() });
+    }
+  }
+  /** An update that didn't restart the office (the demo, or a failed hand-over): recover like a restart would, then report it. */
+  async afterUpdate(result) {
+    const u = this.officeUpdate;
+    Object.assign(u, { sent: false, handedOver: false, requested: false, drainingSince: null });
+    const interrupted = this.state.agents.filter((a) => BUSY.includes(a.status));
+    for (const a of interrupted) {
+      Object.assign(a, { status: "stopped", lastError: "The office updated itself while this agent was working." });
+      const rt = this.agentRt.get(a.id);
+      if (rt) Object.assign(rt, { session: null, currentTool: null });
+    }
+    this.ensureCeo(interrupted);
+    this.recover(interrupted);
+    interrupted.forEach((a) => this.emitAgent(a));
+    await this.reportUpdate(result);
+    if (!result.ok) u.failedBehind = u.behind;
+    const own = this.state.repos.find((r) => this.backend.office.isOwnFolder(this.backend.mainDir(r.fullName)));
+    if (own) await this.syncFolder(own);
+    this.emitCeo();
+    this.save();
+    setTimeout(() => this.schedule(), 300);
+  }
+  /** One phone message about the last update (the launcher's last-update.json, or the demo's fake). */
+  async reportUpdate(result) {
+    const commits = result.ok && result.to ? await this.backend.office.commitsBetween(result.from, result.to) : null;
+    this.postMessage("office", lastUpdateMessage(result, commits));
+    Object.assign(this.officeUpdate, { failed: result.ok ? null : result.error || "unknown error", failedBehind: null });
+  }
+  /** The manager's Update now (drain now, even with automatic updates off) or Later (not for 2 hours, or until a newer commit). */
+  updateOffice(action) {
+    if (action !== "now" && action !== "later") throw new HttpError(400, 'action must be "now" or "later"');
+    const u = this.officeUpdate;
+    if (!this.officeHead || !this.backend.office.launcher) throw new HttpError(409, "The office can only update itself when its launcher started it (npm run dev or npm start).");
+    if (u.sent) throw new HttpError(409, "The update is already under way.");
+    if (u.behind <= 0) throw new HttpError(409, "The office is up to date: there is nothing to update.");
+    if (action === "now") Object.assign(u, { requested: true, postponedUntil: null });
+    else Object.assign(u, { requested: false, postponedUntil: Date.now() + POSTPONE_MS, postponedBehind: u.behind });
+    this.officeUpdateTick();
+    setTimeout(() => this.schedule(), 200);
+    return this.officeUpdateView();
+  }
   // ---------- the CEO ----------
   ceo() {
     return this.state.agents.find((a) => a.id === CEO_ID);
@@ -4021,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,
@@ -4032,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);
@@ -4122,17 +6057,18 @@ ${job.text}` } : job;
       this.state.ceo.lastReviewAt = Date.now();
       this.state.ceo.lastFingerprint = this.fingerprint();
     }
-    this.ceoIssues = { filed: 0, repos: /* @__PURE__ */ new Set() };
+    this.ceoIssues = new IssueCap(MAX_ISSUES_PER_JOB);
     this.emitAgent(a);
     this.emitCeo();
     this.save();
-    await fs4.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,
@@ -4141,7 +6077,7 @@ ${job.text}` } : job;
           name: a.name,
           company: s.companyName,
           manager: s.managerName,
-          notesFile: path6.join(CEO_DIR, "NOTES.md"),
+          notesFile: path12.join(CEO_DIR, "NOTES.md"),
           sessionLimit: s.sessionLimit,
           teamCap: s.teamCap,
           hiring: s.hiring
@@ -4149,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),
@@ -4165,19 +6099,20 @@ ${job.text}` } : job;
         },
         sessionId: (id) => {
           a.sessionId = id;
+          a.sessionCli = "claude";
         },
         browserUrl: () => void 0,
         screenshot: () => void 0,
         turn: (text) => this.postMessage("ceo", text),
         limited: (at) => this.pauseForLimit(at),
+        usageWarning: (info) => this.paceForWarning(info),
         finished: (result) => this.onCeoFinished(a, result)
-      },
-      ""
+      }
     );
   }
   onCeoFinished(a, result) {
     const rt = this.agentRt.get(a.id);
-    if (!rt) return;
+    if (!rt || this.officeUpdate.handedOver) return;
     rt.session = null;
     rt.currentTool = null;
     a.endedAt = Date.now();
@@ -4185,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";
@@ -4194,7 +6130,7 @@ ${job.text}` } : job;
       this.postMessage("office", `\u26A0\uFE0F ${a.name} hit a problem while ${what}: ${a.lastError.slice(0, 240)}`);
     } else {
       a.status = "done";
-      const filed = this.ceoIssues.filed ? ` \xB7 ${this.ceoIssues.filed} issue${this.ceoIssues.filed === 1 ? "" : "s"} filed` : "";
+      const filed = this.ceoIssues.total ? ` \xB7 ${this.ceoIssues.total} issue${this.ceoIssues.total === 1 ? "" : "s"} filed` : "";
       this.appendLog(a, [{ kind: "done", text: `\u2714 Done in ${this.minutes(a)}m \xB7 ${a.turns} turns${filed}` }]);
     }
     for (const id of this.ceoIssues.repos) void this.syncRepo(id);
@@ -4212,6 +6148,7 @@ ${job.text}` } : job;
     const rt = this.agentRt.get(a.id);
     if (rt.session) {
       this.appendLog(a, [{ kind: "manager", text: `\u25B6 Manager: ${t}` }]);
+      this.ceoIssues.managerMessage();
       rt.session.send(`Message from the manager (they read your reply on their phone, so keep it short):
 ${t}`);
       return;
@@ -4247,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;
@@ -4434,6 +6371,7 @@ ${t}`);
           teamCap: s.teamCap,
           sessionLimit: s.sessionLimit || "none",
           sessionsRunning: this.running(),
+          usage: usageLabel(this.usageNow(), Date.now()),
           deskLimits: { dev: MAX_DESKS.dev, qa: MAX_DESKS.qa }
         },
         floors,
@@ -4460,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
@@ -4503,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,
@@ -4545,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,
@@ -4577,7 +6516,7 @@ ${t}`);
   }
   async fileIssue(x) {
     const repo = this.floorRepo(x.floor);
-    if (this.ceoIssues.filed >= MAX_ISSUES_PER_JOB) throw new Error(`You already filed ${MAX_ISSUES_PER_JOB} issues in this job. That's plenty for one milestone.`);
+    this.ceoIssues.check();
     const title = String(x.title ?? "").trim().slice(0, 120);
     if (!title) throw new Error("An issue needs a title.");
     const slug = specialtySlug(x.specialty);
@@ -4586,16 +6525,45 @@ ${t}`);
 ---
 _Filed by ${this.ceo().name}, the cubefarm CEO._`;
     const n = await this.backend.createIssue(repo.fullName, title, body, slug ? [specialtyLabel(slug)] : []);
-    this.ceoIssues.filed++;
-    this.ceoIssues.repos.add(repo.id);
+    this.ceoIssues.record(repo.id);
     return `Filed #${n} on floor ${repo.floor}: ${title}${slug ? ` (routed to ${slug})` : ""}.`;
   }
+  /** Change an open issue's specialty and/or dependencies (see planRoute for what is refused). */
+  async routeIssue(x) {
+    const repo = this.floorRepo(x.floor);
+    const issues = this.repoRt.get(repo.id)?.issues ?? [];
+    const asked = [Number(x.number), ...(x.depends_on ?? []).map(Number)].filter((n) => !issues.some((i) => i.number === n));
+    const states = new Map(await Promise.all([...new Set(asked)].map(async (n) => [n, await this.backend.issueState(repo.fullName, n).catch(() => null)])));
+    const specialties = [
+      ...this.state.agents.filter((a) => a.repoId === repo.id && a.specialty).map((a) => a.specialty.toLowerCase()),
+      ...this.state.requests.filter((r) => r.status === "pending" && r.kind === "hire" && r.repoId === repo.id && r.specialty).map((r) => r.specialty)
+    ];
+    const plan = planRoute({
+      floor: repo.floor,
+      number: Number(x.number),
+      specialty: x.specialty,
+      dependsOn: x.depends_on,
+      issues,
+      closed: (n) => states.get(n) === "CLOSED",
+      inProgress: this.issueTaken(repo, Number(x.number)),
+      specialties
+    });
+    if (plan.body !== null || plan.addLabels.length || plan.removeLabels.length) {
+      await this.backend.editIssue(repo.fullName, Number(x.number), { body: plan.body ?? void 0, addLabels: plan.addLabels, removeLabels: plan.removeLabels });
+      await this.syncRepo(repo.id);
+    }
+    return plan.summary;
+  }
 };
 
 // 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 {
@@ -4706,6 +6674,7 @@ app.get("/api/agents/:id/screen", (req, res) => {
   res.end(shot.data);
 });
 app.patch("/api/settings", route((req) => swarm.updateSettings(req.body ?? {})));
+app.post("/api/office/update", route((req) => swarm.updateOffice(req.body?.action)));
 app.post("/api/ceo/message", route((req) => swarm.messageCeo(str(req.body.text))));
 app.post("/api/ceo/review", route(() => swarm.requestReview()));
 app.post("/api/phone/read", route((req) => swarm.markPhoneRead(Number(req.body?.at) || Date.now())));
@@ -4714,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 = path7.resolve(import.meta.dirname, "../dist");
-if (fs5.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(path7.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;
@@ -4727,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}`);
@@ -4743,11 +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) => {
+    const m = msg;
+    if (m?.type === "office:shutdown") shutdown(m.restart === false ? "stop" : "restart");
+  });
+}
 //# sourceMappingURL=index.js.map