cubefarm 0.1.0

package/dist-server/index.js

@@ -0,0 +1,4753 @@
+// server/index.ts
+import http2 from "node:http";
+import path7 from "node:path";
+import fs5 from "node:fs";
+import express from "express";
+import { WebSocketServer } from "ws";
+
+// server/config.ts
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var PORT = Number(process.env.SWARM_PORT ?? 4317);
+var VERSION = JSON.parse(fs.readFileSync(path.resolve(import.meta.dirname, "..", "package.json"), "utf8")).version;
+var HOME_DIR = process.env.SWARM_HOME ?? path.join(os.homedir(), ".cubefarm");
+var WORKSPACE_ROOT = path.join(HOME_DIR, "workspaces");
+var DEMO = process.argv.includes("--demo") || process.env.SWARM_DEMO === "1" || process.env.SWARM_DEMO === "true";
+var STATE_FILE = path.join(HOME_DIR, DEMO ? "demo-state.json" : "state.json");
+var SYNC_INTERVAL_MS = 45e3;
+var SCHEDULER_INTERVAL_MS = 8e3;
+var LOG_BUFFER = 600;
+function defaultProjectsDir(appDir, home = os.homedir()) {
+  if (!appDir.split(/[\\/]/).includes("node_modules")) return path.resolve(appDir, "..");
+  const names = ["Projects", "projects", "code", "Code", "dev", "Developer", "src", "repos", "git", "GitHub"];
+  return names.map((n) => path.join(home, n)).find((d) => fs.existsSync(d)) ?? path.join(home, "Projects");
+}
+
+// server/exec.ts
+import { execFile } from "node:child_process";
+var CommandError = class extends Error {
+  constructor(message, stderr, code) {
+    super(message);
+    this.stderr = stderr;
+    this.code = code;
+  }
+  stderr;
+  code;
+};
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const child = execFile(
+      cmd,
+      args,
+      {
+        cwd: opts.cwd,
+        timeout: opts.timeoutMs ?? 12e4,
+        maxBuffer: 32 * 1024 * 1024,
+        windowsHide: true,
+        env: { ...process.env, GH_PROMPT_DISABLED: "1", GIT_TERMINAL_PROMPT: "0", NO_COLOR: "1" }
+      },
+      (err, stdout, stderr) => {
+        if (err) {
+          const detail = (stderr || err.message).toString().trim();
+          reject(new CommandError(`${cmd} ${args.slice(0, 3).join(" ")} failed: ${detail}`, stderr?.toString() ?? "", err.code ?? null));
+          return;
+        }
+        resolve(stdout.toString().trim());
+      }
+    );
+    if (opts.input !== void 0) {
+      child.stdin?.end(opts.input);
+    }
+  });
+}
+var gh = (args, opts) => run("gh", args, opts);
+var git = (args, opts) => run("git", args, opts);
+async function ghJson(args, opts) {
+  const out = await gh(args, opts);
+  return out ? JSON.parse(out) : null;
+}
+
+// server/github.ts
+async function currentUser() {
+  return gh(["api", "user", "--jq", ".login"]);
+}
+async function listMyRepos(owner) {
+  const args = ["repo", "list"];
+  if (owner) args.push(owner);
+  args.push("--limit", "200", "--json", "nameWithOwner,description,visibility,updatedAt");
+  const repos2 = await ghJson(args);
+  return repos2.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+async function repoMeta(fullName) {
+  const raw = await ghJson([
+    "repo",
+    "view",
+    fullName,
+    "--json",
+    "nameWithOwner,description,url,defaultBranchRef"
+  ]);
+  return {
+    nameWithOwner: raw.nameWithOwner,
+    description: raw.description ?? "",
+    url: raw.url,
+    defaultBranch: raw.defaultBranchRef?.name || "main"
+  };
+}
+async function listIssues(fullName) {
+  const raw = await ghJson(["issue", "list", "-R", fullName, "--state", "open", "--limit", "100", "--json", "number,title,body,url,labels,createdAt"]);
+  return raw.map((i) => ({ number: i.number, title: i.title, body: i.body ?? "", url: i.url, labels: i.labels.map((l) => l.name), createdAt: i.createdAt })).sort((a, b) => a.number - b.number);
+}
+var PR_FIELDS = "number,title,url,headRefName,headRefOid,state,isDraft,mergeable,mergeStateStatus,reviewDecision,closingIssuesReferences,createdAt,mergedAt,additions,deletions,statusCheckRollup";
+var BAD = ["FAILURE", "ERROR", "CANCELLED", "TIMED_OUT", "ACTION_REQUIRED", "STARTUP_FAILURE"];
+var failed = (c) => BAD.includes(c.conclusion ?? "") || BAD.includes(c.state ?? "");
+var pending = (c) => !!c.status && c.status !== "COMPLETED" || c.state === "PENDING" || c.state === "EXPECTED";
+var checkName = (c) => c.name || c.context || "check";
+function checksOf(rollup) {
+  if (!rollup || rollup.length === 0) return "none";
+  if (rollup.some(failed)) return "failing";
+  if (rollup.some(pending)) return "pending";
+  return "passing";
+}
+function toPull(p) {
+  return {
+    number: p.number,
+    title: p.title,
+    url: p.url,
+    headRefName: p.headRefName,
+    state: p.state,
+    isDraft: p.isDraft,
+    mergeable: p.mergeable,
+    reviewDecision: p.reviewDecision || null,
+    closesIssues: (p.closingIssuesReferences ?? []).map((r) => r.number),
+    createdAt: p.createdAt,
+    mergedAt: p.mergedAt,
+    additions: p.additions,
+    deletions: p.deletions,
+    checks: checksOf(p.statusCheckRollup),
+    headSha: p.headRefOid,
+    mergeState: p.mergeStateStatus || "UNKNOWN",
+    failedChecks: (p.statusCheckRollup ?? []).filter(failed).map((c) => ({ name: checkName(c), url: c.detailsUrl || c.targetUrl || null })),
+    pendingChecks: (p.statusCheckRollup ?? []).filter(pending).map(checkName)
+  };
+}
+async function listPulls(fullName) {
+  const [open, merged] = await Promise.all([
+    ghJson(["pr", "list", "-R", fullName, "--state", "open", "--limit", "50", "--json", PR_FIELDS]),
+    ghJson(["pr", "list", "-R", fullName, "--state", "merged", "--limit", "8", "--json", PR_FIELDS])
+  ]);
+  return [...open, ...merged].map(toPull);
+}
+var labelsMade = /* @__PURE__ */ new Set();
+async function ensureLabel(fullName, name) {
+  const key = `${fullName}#${name}`;
+  if (labelsMade.has(key)) return;
+  await gh(["label", "create", name, "-R", fullName, "--color", "c77dff", "--description", "cubefarm: routed to this specialty", "--force"]);
+  labelsMade.add(key);
+}
+async function createIssue(fullName, title, body, labels = []) {
+  for (const l of labels) await ensureLabel(fullName, l);
+  const args = ["issue", "create", "-R", fullName, "--title", title, "--body-file", "-"];
+  for (const l of labels) args.push("--label", l);
+  const out = await gh(args, { input: body || " " });
+  const match = out.match(/\/issues\/(\d+)/);
+  if (!match) throw new Error(`Could not read the new issue number from gh output: ${out}`);
+  return Number(match[1]);
+}
+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 });
+  if (!pr.isCrossRepository && pr.headRefName.startsWith("swarm/")) {
+    await gh(["api", "-X", "DELETE", `repos/${fullName}/git/refs/heads/${pr.headRefName}`]).catch(() => void 0);
+  }
+}
+async function updateBranch(fullName, number) {
+  await gh(["pr", "update-branch", String(number), "-R", fullName], { timeoutMs: 6e4 });
+}
+async function closePull(fullName, number) {
+  await gh(["pr", "close", String(number), "-R", fullName]);
+}
+async function prForBranch(fullName, branch) {
+  const list = await ghJson(["pr", "list", "-R", fullName, "--head", branch, "--state", "all", "--json", "number,url", "--limit", "1"]);
+  return list[0] ?? null;
+}
+async function prDetails(fullName, number) {
+  const raw = await ghJson(["pr", "view", String(number), "-R", fullName, "--json", "number,title,body,url,headRefName,headRefOid,isCrossRepository,closingIssuesReferences,state,mergeable,mergeStateStatus"]);
+  return {
+    number: raw.number,
+    title: raw.title,
+    body: raw.body ?? "",
+    url: raw.url,
+    headRefName: raw.headRefName,
+    headSha: raw.headRefOid,
+    isCrossRepository: raw.isCrossRepository,
+    closesIssues: (raw.closingIssuesReferences ?? []).map((r) => r.number),
+    state: raw.state,
+    mergeable: raw.mergeable,
+    mergeState: raw.mergeStateStatus || "UNKNOWN"
+  };
+}
+async function issueDetails(fullName, number) {
+  const raw = await ghJson(["issue", "view", String(number), "-R", fullName, "--json", "title,body"]);
+  return { title: raw.title, body: raw.body ?? "" };
+}
+async function commentPull(fullName, number, body) {
+  const out = await gh(["pr", "comment", String(number), "-R", fullName, "--body-file", "-"], { input: body });
+  return out.match(/https:\/\/github\.com\/\S+/)?.[0] ?? "";
+}
+var EVIDENCE_BRANCH = "swarm-qa-evidence";
+var evidenceReady = /* @__PURE__ */ new Set();
+var ghApiJson = (method, endpoint, body) => gh(["api", "-X", method, endpoint, "-H", "Content-Type: application/json", "--input", "-"], { input: JSON.stringify(body), timeoutMs: 12e4 }).then(
+  (out) => out ? JSON.parse(out) : null
+);
+async function ensureEvidenceBranch(fullName) {
+  if (evidenceReady.has(fullName)) return;
+  try {
+    await gh(["api", `repos/${fullName}/git/ref/heads/${EVIDENCE_BRANCH}`]);
+  } catch {
+    const readme = "# QA evidence\n\nScreenshots attached to pull request QA reports by cubefarm QA agents.\nThis branch has no shared history with the code and is never merged.\n";
+    const newTree = await ghApiJson("POST", `repos/${fullName}/git/trees`, {
+      tree: [{ path: "README.md", mode: "100644", type: "blob", content: readme }]
+    });
+    const commit = await ghApiJson("POST", `repos/${fullName}/git/commits`, { message: "QA evidence branch (cubefarm)", tree: newTree.sha, parents: [] });
+    await ghApiJson("POST", `repos/${fullName}/git/refs`, { ref: `refs/heads/${EVIDENCE_BRANCH}`, sha: commit.sha });
+  }
+  evidenceReady.add(fullName);
+}
+async function uploadEvidence(fullName, filePath, data) {
+  await ensureEvidenceBranch(fullName);
+  await ghApiJson("PUT", `repos/${fullName}/contents/${filePath}`, {
+    message: `QA evidence: ${filePath}`,
+    content: data.toString("base64"),
+    branch: EVIDENCE_BRANCH
+  });
+  return `https://github.com/${fullName}/raw/${EVIDENCE_BRANCH}/${filePath}`;
+}
+
+// server/workspace.ts
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+var locks = /* @__PURE__ */ new Map();
+var localRoots = /* @__PURE__ */ new Map();
+function withRepoLock(fullName, fn) {
+  const prev = locks.get(fullName) ?? Promise.resolve();
+  const next = prev.catch(() => void 0).then(fn);
+  locks.set(fullName, next);
+  return next;
+}
+var repoDir = (fullName) => path2.join(WORKSPACE_ROOT, fullName.replace("/", "__"));
+var mainDir = (fullName) => localRoots.get(fullName.toLowerCase()) ?? path2.join(repoDir(fullName), "main");
+var deskDir = (fullName, agentSlug) => path2.join(repoDir(fullName), "desks", agentSlug);
+function setLocalPath(fullName, dir) {
+  if (dir) localRoots.set(fullName.toLowerCase(), path2.resolve(dir));
+  else localRoots.delete(fullName.toLowerCase());
+}
+async function exists(p) {
+  return fs2.access(p).then(() => true).catch(() => false);
+}
+var LOCAL_EXCLUDES = [".playwright-mcp/", ".preview-tmp/"];
+async function addLocalExcludes(main) {
+  const file = path2.join(main, ".git", "info", "exclude");
+  const current = await fs2.readFile(file, "utf8").catch(() => "");
+  const missing = LOCAL_EXCLUDES.filter((l) => !current.split(/\r?\n/).includes(l));
+  if (missing.length === 0) return;
+  await fs2.mkdir(path2.dirname(file), { recursive: true });
+  await fs2.appendFile(file, `${current && !current.endsWith("\n") ? "\n" : ""}# added by cubefarm
+${missing.join("\n")}
+`);
+}
+var ensureLocalExcludes = (fullName) => addLocalExcludes(mainDir(fullName));
+function ensureClone(fullName) {
+  return withRepoLock(fullName, async () => {
+    const dir = mainDir(fullName);
+    if (await exists(path2.join(dir, ".git"))) {
+      await git(["fetch", "origin", "--prune"], { cwd: dir, timeoutMs: 18e4 });
+    } else {
+      await fs2.mkdir(path2.dirname(dir), { recursive: true });
+      await gh(["repo", "clone", fullName, dir], { timeoutMs: 6e5 });
+    }
+    await addLocalExcludes(dir);
+  });
+}
+var installs = /* @__PURE__ */ new Map();
+function npmInstall(dir) {
+  const prev = installs.get(dir) ?? Promise.resolve();
+  const opts = { cwd: dir, timeoutMs: 6e5 };
+  const next = prev.catch(() => void 0).then(() => process.platform === "win32" ? run("cmd.exe", ["/d", "/s", "/c", "npm install --no-audit --no-fund"], opts) : run("npm", ["install", "--no-audit", "--no-fund"], opts));
+  installs.set(dir, next);
+  return next;
+}
+async function syncMain(fullName, defaultBranch, opts) {
+  const dir = mainDir(fullName);
+  const result = await withRepoLock(fullName, async () => {
+    if (!await exists(path2.join(dir, ".git"))) return null;
+    const g = (args, timeoutMs) => git(args, { cwd: dir, timeoutMs });
+    try {
+      await g(["fetch", "origin", "--prune"], 18e4);
+      const target = `origin/${defaultBranch}`;
+      const 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 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` };
+      }
+      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 };
+    } catch (err) {
+      return { status: `sync failed: ${err.message.split(/\r?\n/)[0].slice(0, 160)}` };
+    }
+  });
+  if (!result?.install) return result?.status ?? null;
+  try {
+    await npmInstall(dir);
+    return `${result.status} \xB7 dependencies installed`;
+  } catch (err) {
+    console.warn(`npm install in ${dir} failed:`, err.message);
+    return `${result.status} \xB7 npm install failed`;
+  }
+}
+function githubFromConfig(config) {
+  const url = config.match(/\[remote "origin"\][^[]*?url\s*=\s*(\S+)/)?.[1];
+  const m = url?.match(/github\.com[:/]([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/i);
+  return m ? `${m[1]}/${m[2]}` : null;
+}
+async function inspectFolder(dir) {
+  const full = path2.resolve(dir);
+  const stat = await fs2.stat(full).catch(() => null);
+  if (!stat?.isDirectory()) throw new Error(`${full} is not a folder`);
+  const dotGit = path2.join(full, ".git");
+  const gitStat = await fs2.stat(dotGit).catch(() => null);
+  let config = "";
+  if (gitStat?.isDirectory()) config = await fs2.readFile(path2.join(dotGit, "config"), "utf8").catch(() => "");
+  else if (gitStat) {
+    const ref = (await fs2.readFile(dotGit, "utf8").catch(() => "")).match(/gitdir:\s*(.+)/)?.[1]?.trim();
+    if (ref) {
+      const gitDir = path2.resolve(full, ref);
+      config = await fs2.readFile(path2.join(gitDir, "config"), "utf8").catch(() => fs2.readFile(path2.join(gitDir, "..", "..", "config"), "utf8").catch(() => ""));
+    }
+  }
+  return { name: path2.basename(full), path: full, git: !!gitStat, github: githubFromConfig(config), modified: stat.mtimeMs };
+}
+async function scanProjects(root) {
+  const entries = await fs2.readdir(root, { withFileTypes: true }).catch(() => {
+    throw new Error(`Can't read the projects folder ${root}`);
+  });
+  const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules");
+  const folders = await Promise.all(dirs.map((e) => inspectFolder(path2.join(root, e.name)).catch(() => null)));
+  return folders.filter((f) => !!f).sort((a, b) => b.modified - a.modified);
+}
+async function commitReadme(dir, title, description) {
+  const readme = path2.join(dir, "README.md");
+  if (!await exists(readme)) await fs2.writeFile(readme, `# ${title}
+
+${description.trim()}
+`);
+  await git(["add", "README.md"], { cwd: dir });
+  try {
+    await git(["commit", "-m", "Initial commit"], { cwd: dir });
+  } catch (err) {
+    if (!/tell me who you are|user\.(name|email)/i.test(err.message)) throw err;
+    const login = await gh(["api", "user", "--jq", ".login"]);
+    await git(["-c", `user.name=${login}`, "-c", `user.email=${login}@users.noreply.github.com`, "commit", "-m", "Initial commit"], { cwd: dir });
+  }
+}
+async function publishFolder(dir, opts) {
+  const full = path2.resolve(dir);
+  const info = await inspectFolder(full);
+  if (info.github) return info.github;
+  if (!info.git) await git(["init", "-b", "main"], { cwd: full });
+  const hasCommit = await git(["rev-parse", "--verify", "HEAD"], { cwd: full }).then(
+    () => true,
+    () => false
+  );
+  if (!hasCommit) {
+    const files = (await fs2.readdir(full)).filter((f) => f !== ".git" && f !== "README.md");
+    if (files.length) {
+      throw new Error(`${info.name} has files but no commits yet. Commit what you want on GitHub first (git add, git commit), then publish it.`);
+    }
+    await commitReadme(full, opts.name, opts.description ?? "");
+  }
+  const origin = await git(["remote", "get-url", "origin"], { cwd: full }).catch(() => "");
+  if (origin) throw new Error(`${info.name}'s origin (${origin}) isn't on GitHub. cubefarm needs GitHub for issues and pull requests.`);
+  const target = opts.owner ? `${opts.owner}/${opts.name}` : opts.name;
+  const args = ["repo", "create", target, `--${opts.visibility}`, "--source", full, "--remote", "origin", "--push"];
+  if (opts.description) args.push("--description", opts.description);
+  const out = await gh(args, { cwd: full, timeoutMs: 12e4 });
+  return out.match(/github\.com\/([^/\s]+\/[^/\s]+?)(?:\.git)?(?:\s|$)/)?.[1] ?? (await inspectFolder(full)).github ?? target;
+}
+async function createProject(root, name, opts) {
+  const dir = path2.join(root, name);
+  if (await exists(dir)) {
+    const inside = await fs2.readdir(dir).catch(() => ["?"]);
+    if (inside.length) throw new Error(`${dir} already exists. Pick another name, or connect that folder instead.`);
+  }
+  await fs2.mkdir(dir, { recursive: true });
+  await git(["init", "-b", "main"], { cwd: dir });
+  await commitReadme(dir, name, opts.description ?? "");
+  const fullName = await publishFolder(dir, { name, ...opts });
+  return { fullName, path: dir };
+}
+async function removeDir(dir) {
+  await fs2.rm(dir, { recursive: true, force: true, maxRetries: 8, retryDelay: 250 });
+}
+function prepareDesk(fullName, base, agentSlug, branch) {
+  return withRepoLock(fullName, async () => {
+    const main = mainDir(fullName);
+    await git(["fetch", "origin", "--prune"], { cwd: main, timeoutMs: 18e4 });
+    let ref = `origin/${base.defaultBranch}`;
+    if (base.pr) {
+      ref = `origin/pr/${base.pr}`;
+      await git(["fetch", "origin", `+refs/pull/${base.pr}/head:refs/remotes/${ref}`], { cwd: main, timeoutMs: 18e4 });
+    }
+    try {
+      await git(["rev-parse", "--verify", ref], { cwd: main });
+    } catch {
+      throw new Error(
+        base.pr ? `Could not fetch pull request #${base.pr} of ${fullName}.` : `${fullName} has no ${base.defaultBranch} branch yet. Push an initial commit (or create the repo with a README) before assigning work.`
+      );
+    }
+    const wt = deskDir(fullName, agentSlug);
+    if (await exists(path2.join(wt, ".git"))) {
+      try {
+        await git(["checkout", "--force", "-B", branch, ref], { cwd: wt });
+        await git(["reset", "--hard", ref], { cwd: wt });
+        await git(["clean", "-fd"], { cwd: wt }).catch(() => void 0);
+        return wt;
+      } catch {
+      }
+    }
+    if (await exists(wt)) {
+      await git(["worktree", "remove", "--force", wt], { cwd: main }).catch(() => void 0);
+      try {
+        await removeDir(wt);
+      } catch (err) {
+        throw new Error(
+          `Could not clear the desk folder ${wt}: ${err.message}. A program started by the previous task is probably still running there. Close it and try again.`
+        );
+      }
+    }
+    await git(["worktree", "prune"], { cwd: main });
+    await fs2.mkdir(path2.dirname(wt), { recursive: true });
+    await git(["worktree", "add", "-B", branch, wt, ref], { cwd: main });
+    return wt;
+  });
+}
+function removeDesk(fullName, agentSlug) {
+  return withRepoLock(fullName, async () => {
+    const main = mainDir(fullName);
+    const wt = deskDir(fullName, agentSlug);
+    if (!await exists(wt)) return;
+    await git(["worktree", "remove", "--force", wt], { cwd: main }).catch(() => void 0);
+    await removeDir(wt).catch(() => void 0);
+    await git(["worktree", "prune"], { cwd: main }).catch(() => void 0);
+  });
+}
+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) {
+  const desk = deskDir(fullName, agentSlug);
+  if (process.platform === "win32") {
+    const variants = [desk, desk.replaceAll("\\", "/")].map((d) => `'${d.toLowerCase().replaceAll("'", "''")}'`).join(", ");
+    const script = `
+$ErrorActionPreference = 'SilentlyContinue'
+$seed = @()
+Get-NetTCPConnection -LocalPort ${port} -State Listen | ForEach-Object { $seed += [int]$_.OwningProcess }
+$desks = @(${variants})
+$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()
+  foreach ($d in $desks) { if ($cmd.Contains($d)) { $seed += [int]$p.ProcessId } }
+}
+$launchers = @(${LAUNCHERS.map((n) => `'${n}'`).join(", ")})
+$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())) {
+    [void]$kill.Add([int]$cur.ProcessId)
+    $first = $false
+    $cur = $byId[[int]$cur.ParentProcessId]
+  }
+}
+foreach ($id in $kill) { taskkill /PID $id /T /F 2>&1 | Out-Null }
+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)) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+}
+
+// server/agentRunner.ts
+import path3 from "node:path";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+var InputQueue = class {
+  items = [];
+  waiters = [];
+  closed = false;
+  push(text) {
+    if (this.closed) return;
+    const msg = { type: "user", message: { role: "user", content: text }, parent_tool_use_id: null };
+    const waiter = this.waiters.shift();
+    if (waiter) waiter({ value: msg, done: false });
+    else this.items.push(msg);
+  }
+  close() {
+    this.closed = true;
+    for (const w of this.waiters.splice(0)) w({ value: void 0, done: true });
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        const item = this.items.shift();
+        if (item) return Promise.resolve({ value: item, done: false });
+        if (this.closed) return Promise.resolve({ value: void 0, done: true });
+        return new Promise((resolve) => this.waiters.push(resolve));
+      }
+    };
+  }
+};
+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 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.` };
+      }
+    }
+    return { behavior: "allow", updatedInput: input };
+  };
+}
+var clip = (s, n) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
+function rel(cwd, p) {
+  const s = String(p ?? "");
+  if (!s) return "";
+  const r = path3.relative(cwd, s);
+  return r && !r.startsWith("..") ? r.replaceAll("\\", "/") : s;
+}
+var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function tidyPaths(cwd, text) {
+  let out = text;
+  for (const v of /* @__PURE__ */ new Set([cwd, cwd.replaceAll("\\", "/")])) {
+    out = out.replace(new RegExp(`^cd\\s+"?${escapeRe(v)}"?\\s*(&&|;)\\s*`, "i"), "");
+    out = out.replace(new RegExp(`${escapeRe(v)}[\\\\/]?`, "gi"), "./");
+  }
+  return out;
+}
+function describeTool(cwd, name, input) {
+  switch (name) {
+    case "Bash":
+    case "PowerShell":
+      return `$ ${clip(tidyPaths(cwd, String(input.command ?? "")).split("\n")[0], 220)}`;
+    case "Read":
+      return `Read ${rel(cwd, input.file_path)}`;
+    case "Write":
+      return `Write ${rel(cwd, input.file_path)}`;
+    case "Edit":
+    case "MultiEdit":
+      return `Edit ${rel(cwd, input.file_path)}`;
+    case "Glob":
+      return `Glob ${input.pattern}`;
+    case "Grep":
+      return `Grep "${clip(String(input.pattern ?? ""), 80)}"`;
+    case "WebFetch":
+      return `Fetch ${input.url}`;
+    case "WebSearch":
+      return `Search "${input.query}"`;
+    case "Task":
+    case "Agent":
+      return `Subagent: ${input.description ?? ""}`;
+    case "TodoWrite":
+      return "Update todo list";
+  }
+  if (name.startsWith("mcp__playwright__")) {
+    const action = name.replace("mcp__playwright__browser_", "").replace("mcp__playwright__", "");
+    const detail = input.url ?? input.element ?? input.text ?? "";
+    return `\u{1F310} ${action}${detail ? ` ${clip(String(detail), 120)}` : ""}`;
+  }
+  if (name.startsWith("mcp__office__")) return describeOfficeTool(name.slice("mcp__office__".length), input);
+  return `${name}(${clip(JSON.stringify(input), 140)})`;
+}
+function describeOfficeTool(action, input) {
+  const floor = input.floor != null ? ` \u2192 floor ${input.floor}` : "";
+  switch (action) {
+    case "company_status":
+      return "\u{1F3E2} company_status";
+    case "agent_detail":
+      return `\u{1F50E} agent_detail ${String(input.agent_id ?? "")}`;
+    case "set_floor_profile":
+      return `\u{1F5C2}\uFE0F set_floor_profile${floor}${input.summary ? `: ${clip(String(input.summary), 90)}` : ""}`;
+    case "update_job":
+      return `\u{1FAAA} update_job ${input.title ? `"${clip(String(input.title), 60)}"` : String(input.agent_id ?? "")}`;
+    case "propose_hire":
+      return `\u{1F91D} propose_hire ${input.role === "qa" ? "QA " : ""}"${clip(String(input.title ?? ""), 60)}"${floor}`;
+    case "propose_let_go":
+      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}` : ""}`;
+  }
+  return `\u{1F3E2} ${action}(${clip(JSON.stringify(input), 120)})`;
+}
+function todoLines(input) {
+  const todos = Array.isArray(input.todos) ? input.todos : [];
+  return todos.slice(0, 12).map((t) => ({
+    kind: "result",
+    text: `  ${t.status === "completed" ? "\u2612" : t.status === "in_progress" ? "\u25D0" : "\u2610"} ${clip(t.content ?? "", 150)}`
+  }));
+}
+function resultText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((b) => b?.type === "text").map((b) => b.text).join("\n");
+  }
+  return "";
+}
+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 === "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` }];
+  const lines = tidyPaths(cwd, text).replace(/\r/g, "").split("\n").filter((l) => l.trim() !== "");
+  if (lines.length === 0) return [{ kind: "result", text: "  \u23BF (no output)" }];
+  const shown = lines.slice(0, 3).map((l, i) => ({ kind: "result", text: `${i === 0 ? "  \u23BF " : "    "}${clip(l, 170)}` }));
+  if (lines.length > 3) shown.push({ kind: "result", text: `    \u2026 +${lines.length - 3} lines` });
+  return shown;
+}
+function startSession(opts, callbacks, defaultBranch) {
+  let done = false;
+  const cb = {
+    ...callbacks,
+    finished: (r) => {
+      if (done) return;
+      done = true;
+      callbacks.finished(r);
+    }
+  };
+  const input = new InputQueue();
+  const abort = new AbortController();
+  let pendingTurns = 1;
+  let stopped = false;
+  let lastCost = 0;
+  let lastTurns = 0;
+  const toolNames = /* @__PURE__ */ new Map();
+  input.push(opts.prompt);
+  const env = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (/^(ANTHROPIC_|CLAUDE)/i.test(k) && k !== "CLAUDE_CONFIG_DIR") continue;
+    env[k] = v;
+  }
+  env.CLAUDE_AGENT_SDK_CLIENT_APP = `cubefarm/${VERSION}`;
+  const mcpServers = {};
+  if (opts.browserTesting) {
+    const args = ["-y", "@playwright/mcp@latest", "--headless", "--isolated", "--init-script", path3.join(import.meta.dirname, "browser-init.js")];
+    mcpServers.playwright = process.platform === "win32" ? { command: "cmd", args: ["/c", "npx", ...args] } : { command: "npx", args };
+  }
+  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,
+    abortController: abort,
+    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 },
+    systemPrompt: { type: "preset", preset: "claude_code", append: opts.systemAppend },
+    mcpServers,
+    disallowedTools,
+    resume: opts.resumeSessionId,
+    stderr: (data) => {
+      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) },
+    ...opts.outputSchema ? { outputFormat: { type: "json_schema", schema: opts.outputSchema } } : {}
+  };
+  let emptyTurn;
+  const answered = (msg) => {
+    pendingTurns -= 1;
+    if (pendingTurns > 0) return;
+    input.close();
+    const ok = msg.subtype === "success" && !msg.is_error;
+    cb.finished({
+      ok,
+      text: msg.subtype === "success" ? msg.result : "",
+      costUsd: lastCost,
+      turns: lastTurns,
+      errors: msg.subtype === "success" ? [] : msg.errors,
+      structured: msg.subtype === "success" ? msg.structured_output : void 0
+    });
+  };
+  const handle = (msg) => {
+    clearTimeout(emptyTurn);
+    if (done && msg.type === "assistant" && !stopped) {
+      stopped = true;
+      cb.log([{ kind: "system", text: "\u25A0 This session kept working after it had finished, so it was stopped." }]);
+      abort.abort();
+      return;
+    }
+    switch (msg.type) {
+      case "system": {
+        if (msg.subtype === "init") {
+          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: `  cwd ${msg.cwd}${mcp ? ` \xB7 mcp ${mcp}` : ""}` }
+          ]);
+        } else if (msg.subtype === "api_retry") {
+          cb.log([{ kind: "system", text: `\u2026 API retry ${msg.attempt}/${msg.max_retries} in ${Math.round(msg.retry_delay_ms / 1e3)}s` }]);
+        } else if (msg.subtype === "compact_boundary") {
+          cb.log([{ kind: "system", text: "\u273B Conversation compacted" }]);
+        }
+        break;
+      }
+      case "rate_limit_event": {
+        const info = msg.rate_limit_info;
+        if (info.status !== "allowed") {
+          const when = info.resetsAt ? new Date(info.resetsAt * 1e3).toLocaleTimeString() : "later";
+          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);
+        }
+        break;
+      }
+      case "assistant": {
+        if (msg.parent_tool_use_id) break;
+        const out = [];
+        for (const block of msg.message.content) {
+          if (block.type === "text" && block.text.trim()) {
+            const lines = block.text.trim().split("\n");
+            lines.slice(0, 30).forEach((l, i) => out.push({ kind: "text", text: `${i === 0 ? "\u25CF " : "  "}${l}` }));
+            if (lines.length > 30) out.push({ kind: "text", text: `  \u2026 (${lines.length - 30} more lines)` });
+          } else if (block.type === "thinking") {
+            out.push({ kind: "thinking", text: "\u273B Thinking\u2026" });
+          } else if (block.type === "tool_use") {
+            const toolInput = 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));
+            cb.tool(block.name);
+            if (block.name === "mcp__playwright__browser_navigate" && typeof toolInput.url === "string") cb.browserUrl(toolInput.url);
+          }
+        }
+        if (out.length) cb.log(out);
+        break;
+      }
+      case "user": {
+        if (msg.parent_tool_use_id) break;
+        const content = msg.message.content;
+        if (!Array.isArray(content)) break;
+        const out = [];
+        for (const block of content) {
+          if (block.type !== "tool_result") continue;
+          const name = toolNames.get(block.tool_use_id) ?? "";
+          const text = resultText(block.content);
+          if (Array.isArray(block.content)) {
+            for (const part of block.content) {
+              if (part.type === "image" && part.source.type === "base64") {
+                cb.screenshot(Buffer.from(part.source.data, "base64"), part.source.media_type);
+              }
+            }
+          }
+          if (name.startsWith("mcp__playwright__")) {
+            const url = text.match(/Page URL:\s*(\S+)/);
+            if (url) cb.browserUrl(url[1]);
+          }
+          if (name === "TodoWrite") continue;
+          if (block.is_error) out.push({ kind: "error", text: `  \u23BF ${clip(tidyPaths(opts.cwd, text).split("\n")[0] || "Error", 200)}` });
+          else out.push(...summariseResult(opts.cwd, name, text));
+        }
+        cb.tool(null);
+        if (out.length) cb.log(out);
+        break;
+      }
+      case "result": {
+        lastCost = msg.total_cost_usd;
+        lastTurns = msg.num_turns;
+        if (msg.subtype === "success" && !msg.is_error && msg.num_turns === 0) {
+          emptyTurn = setTimeout(() => answered(msg), 3e4);
+          break;
+        }
+        if (msg.subtype === "success" && !msg.is_error && msg.result.trim()) cb.turn?.(msg.result.trim());
+        answered(msg);
+        break;
+      }
+    }
+  };
+  (async () => {
+    try {
+      for await (const msg of query({ prompt: input, options })) handle(msg);
+      if (pendingTurns > 0) {
+        cb.finished({ ok: false, text: "", costUsd: lastCost, turns: lastTurns, errors: [stopped ? "Stopped by manager" : "Session ended unexpectedly"] });
+      }
+    } catch (err) {
+      input.close();
+      const message = stopped ? "Stopped by manager" : err instanceof Error ? err.message : String(err);
+      cb.finished({ ok: false, text: "", costUsd: lastCost, turns: lastTurns, errors: [message] });
+    }
+  })();
+  return {
+    send(text) {
+      pendingTurns += 1;
+      input.push(text);
+    },
+    stop() {
+      stopped = true;
+      clearTimeout(emptyTurn);
+      input.close();
+      abort.abort();
+    }
+  };
+}
+
+// server/previewRunner.ts
+import { spawn } from "node:child_process";
+import crypto from "node:crypto";
+import fs3 from "node:fs/promises";
+import net from "node:net";
+import path4 from "node:path";
+var PREVIEW_SLUG = "preview";
+var PREVIEW_BRANCH = "swarm-preview";
+var PREVIEW_TMP = ".preview-tmp";
+var INSTALL_MARKER = ".cubefarm-preview-install";
+var START_TIMEOUT_MS = 3 * 6e4;
+var INSTALL_TIMEOUT_MS = 15 * 6e4;
+var fillPlaceholders = (s, port, tmp) => s.replaceAll("{port}", String(port)).replaceAll("{tmp}", tmp);
+function previewEnv(extra, port, tmp) {
+  const env = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v === void 0 || /^(ANTHROPIC_|CLAUDE|SWARM_)/i.test(k)) continue;
+    env[k] = v;
+  }
+  env.BROWSER = "none";
+  for (const [k, v] of Object.entries(extra)) env[k] = fillPlaceholders(v, port, tmp);
+  env.PORT = String(port);
+  return env;
+}
+async function portOpen(port) {
+  const probe = (host) => new Promise((resolve) => {
+    const sock = net.connect({ port, host });
+    const done = (ok) => {
+      sock.destroy();
+      resolve(ok);
+    };
+    sock.setTimeout(800, () => done(false));
+    sock.once("connect", () => done(true));
+    sock.once("error", () => done(false));
+  });
+  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));
+async function readJson(file) {
+  try {
+    return JSON.parse(await fs3.readFile(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function defaultCommand(pkg) {
+  const scripts = pkg?.scripts ?? {};
+  const name = ["dev", "start", "preview"].find((s) => typeof scripts[s] === "string" && scripts[s].trim());
+  if (!name) return null;
+  const script = scripts[name];
+  const vite = /^\s*vite(\s|$)/.test(script) && !/--port\b/.test(script);
+  return `npm run ${name}${vite ? " -- --port {port} --strictPort" : ""}`;
+}
+function killTree(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" });
+      tk.once("error", () => resolve());
+      tk.once("close", () => resolve());
+    });
+  }
+  try {
+    process.kill(-child.pid, "SIGKILL");
+  } catch {
+    child.kill("SIGKILL");
+  }
+  return Promise.resolve();
+}
+var Stopped = class extends Error {
+};
+var RealPreview = class {
+  constructor(job, cb) {
+    this.job = job;
+    this.cb = cb;
+    void this.run().catch((err) => {
+      if (this.stopped || err instanceof Stopped) return;
+      this.stopped = true;
+      if (this.child) void killTree(this.child);
+      this.cb.failed(err.message);
+    });
+  }
+  job;
+  cb;
+  child = null;
+  stopped = false;
+  partial = "";
+  async stop() {
+    this.stopped = true;
+    if (this.child) await killTree(this.child);
+  }
+  check() {
+    if (this.stopped) throw new Stopped();
+  }
+  async run() {
+    const { job, cb } = this;
+    cb.status("preparing");
+    const wt = await prepareDesk(job.fullName, { defaultBranch: job.defaultBranch, pr: job.pr ?? void 0 }, PREVIEW_SLUG, PREVIEW_BRANCH);
+    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 command = job.command ?? defaultCommand(pkg);
+    if (!command) {
+      this.stopped = true;
+      cb.failed(
+        pkg ? "package.json has no dev, start or preview script. Set a preview command for this floor." : "Nothing to run: this floor has no preview command and no package.json.",
+        true
+      );
+      return;
+    }
+    const env = previewEnv(job.env, job.port, tmp);
+    if (pkg) {
+      cb.status("installing");
+      await this.install(wt, env);
+      this.check();
+    }
+    cb.status("starting");
+    const cmd = fillPlaceholders(command, job.port, tmp);
+    cb.log([`$ ${cmd}`]);
+    const exited = this.spawn(cmd, wt, env);
+    const deadline = Date.now() + START_TIMEOUT_MS;
+    let exitCode;
+    void exited.then((code2) => exitCode = code2);
+    while (!await portOpen(job.port)) {
+      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);
+    }
+    this.check();
+    cb.status("running");
+    const code = await exited;
+    while (!this.stopped && await portOpen(job.port)) await sleep(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) {
+      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")]);
+    this.check();
+    if (code === "timeout") {
+      if (this.child) await killTree(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);
+  }
+  /** 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"] });
+    this.child = child;
+    const onData = (buf) => {
+      const text = this.partial + buf.toString().replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "");
+      const lines = text.split(/\r?\n|\r/);
+      this.partial = lines.pop() ?? "";
+      const out = lines.filter((l) => l.trim());
+      if (out.length) this.cb.log(out);
+    };
+    child.stdout?.on("data", onData);
+    child.stderr?.on("data", onData);
+    return new Promise((resolve) => {
+      child.once("error", (err) => {
+        this.cb.log([err.message]);
+        resolve(-1);
+      });
+      child.once("close", (code) => {
+        if (this.partial.trim()) this.cb.log([this.partial]);
+        this.partial = "";
+        resolve(code);
+      });
+    });
+  }
+};
+var realPreviews = {
+  start: (job, cb) => new RealPreview(job, cb),
+  hasDefault: async (fullName) => fs3.access(path4.join(mainDir(fullName), "package.json")).then(() => true).catch(() => false)
+};
+
+// server/backend.ts
+var realBackend = {
+  demo: false,
+  user: currentUser,
+  listMyRepos,
+  repoMeta,
+  listIssues,
+  listPulls,
+  createIssue,
+  mergePull,
+  updateBranch,
+  closePull,
+  prForBranch,
+  prDetails,
+  issueDetails,
+  commentPull,
+  uploadEvidence,
+  ensureClone,
+  syncMain,
+  setLocalPath,
+  scanProjects,
+  inspectFolder,
+  publishFolder,
+  createProject,
+  mainDir,
+  deskDir,
+  prepareDesk,
+  removeDesk,
+  releaseDesk,
+  startSession,
+  previews: realPreviews
+};
+
+// server/demo.ts
+import crypto2 from "node:crypto";
+import http from "node:http";
+import path5 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() };
+}
+var repos = /* @__PURE__ */ new Map();
+var bareRepos = /* @__PURE__ */ new Set();
+var mergedSinceSync = /* @__PURE__ */ new Map();
+var fakeSha = () => crypto2.randomBytes(20).toString("hex");
+function runChecks(pr, fail = Math.random() < 0.2) {
+  Object.assign(pr, { checks: "pending", pendingChecks: ["CI / build", "Vercel"], failedChecks: [] });
+  setTimeout(() => {
+    Object.assign(pr, {
+      checks: fail ? "failing" : "passing",
+      pendingChecks: [],
+      failedChecks: fail ? [{ name: "CI / build", url: `${pr.url}/checks` }] : []
+    });
+  }, 12e3 + Math.random() * 1e4);
+}
+function seed(fullName, description, titles) {
+  const r = { fullName, description, issues: [], pulls: [], nextNumber: 1 };
+  for (const [title, body] of titles) r.issues.push(issue(r.nextNumber++, title, body, fullName));
+  repos.set(fullName, r);
+}
+seed("demo-co/pixel-todo", "A cheerful todo app", [
+  ["Add dark mode toggle", "Users want a dark theme. Persist the choice in localStorage."],
+  ["Todos should support due dates", "Add an optional due date and highlight overdue items."],
+  ["Drag and drop to reorder", "Let users reorder todos by dragging."],
+  ["Empty state illustration", "Show a friendly illustration when the list is empty."],
+  ["Keyboard shortcuts", "N for new todo, / to search, ? for help."],
+  ["Fix: completed count off by one", "The footer shows one more completed item than there is."]
+]);
+seed("demo-co/weather-api", "Tiny weather REST API", [
+  ["Add /forecast endpoint", "Return a 5-day forecast for a city."],
+  ["Rate limit anonymous callers", "60 requests per minute per IP."],
+  ["OpenAPI spec", "Publish an OpenAPI 3.1 document at /openapi.json."]
+]);
+function screenshotSvg(title, url, hue) {
+  const safe = (s) => s.replace(/[<>&"]/g, "");
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="640" height="400" viewBox="0 0 640 400">
+  <rect width="640" height="400" fill="hsl(${hue},60%,97%)"/>
+  <rect width="640" height="56" fill="hsl(${hue},70%,55%)"/>
+  <text x="24" y="37" font-family="Segoe UI, Arial" font-size="22" font-weight="700" fill="#fff">${safe(title)}</text>
+  <text x="620" y="36" text-anchor="end" font-family="Segoe UI, Arial" font-size="13" fill="#fff">${safe(url)}</text>
+  ${[0, 1, 2, 3].map(
+    (i) => `<rect x="24" y="${84 + i * 70}" width="592" height="56" rx="10" fill="#fff" stroke="hsl(${hue},40%,85%)"/>
+  <circle cx="54" cy="${112 + i * 70}" r="11" fill="none" stroke="hsl(${hue},60%,55%)" stroke-width="3"/>
+  <rect x="80" y="${104 + i * 70}" width="${180 + i * 97 % 220}" height="14" rx="7" fill="hsl(${hue},25%,80%)"/>`
+  ).join("\n")}
+</svg>`;
+}
+function devScript(opts, cb, issueNumber, issueTitle) {
+  const branch = path5.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;
+  return [
+    [{ kind: "text", text: `\u25CF I'll start by getting familiar with the codebase for "${issueTitle}".` }],
+    [{ kind: "tool", tool: "Glob", text: "\u23FA Glob src/**/*.{ts,tsx}" }, { kind: "result", text: "  \u23BF Found 23 files" }],
+    [{ kind: "tool", tool: "Read", text: `\u23FA Read ${file}` }, { kind: "result", text: "  \u23BF Read 184 lines" }],
+    [{ kind: "thinking", text: "\u273B Thinking\u2026" }],
+    [
+      { kind: "tool", tool: "TodoWrite", text: "\u23FA Update todo list" },
+      { kind: "result", text: "  \u25D0 Understand current behaviour" },
+      { kind: "result", text: "  \u2610 Implement the change" },
+      { kind: "result", text: "  \u2610 Add tests" },
+      { kind: "result", text: "  \u2610 Verify in the browser" }
+    ],
+    [{ kind: "tool", tool: "Grep", text: '\u23FA Grep "useTodos"' }, { kind: "result", text: "  \u23BF Found 6 matches in 4 files" }],
+    [{ kind: "text", text: "\u25CF The state lives in a single hook. I'll extend it and keep the API backwards compatible." }],
+    [{ kind: "tool", tool: "Edit", text: `\u23FA Edit ${file}` }, { kind: "result", text: "  \u23BF Updated" }],
+    [{ kind: "tool", tool: "Write", text: "\u23FA Write src/__tests__/feature.test.ts" }, { kind: "result", text: "  \u23BF Saved" }],
+    [{ kind: "tool", tool: "Bash", text: "\u23FA $ npm test -- --run" }],
+    [
+      { kind: "result", text: "  \u23BF \u2713 src/__tests__/feature.test.ts (4 tests) 38ms" },
+      { kind: "result", text: "    Test Files  7 passed (7)" }
+    ],
+    [{ kind: "tool", tool: "Bash", text: `\u23FA $ npm run dev -- --port ${port} &` }, { kind: "result", text: "  \u23BF VITE ready in 412 ms" }],
+    () => cb.browserUrl(`http://localhost:${port}/`),
+    [{ kind: "tool", tool: "mcp__playwright__browser_navigate", text: `\u23FA \u{1F310} navigate http://localhost:${port}/` }, { kind: "result", text: `  \u23BF Page URL: http://localhost:${port}/` }],
+    () => cb.screenshot(Buffer.from(screenshotSvg(issueTitle, `localhost:${port}`, hue)), "image/svg+xml"),
+    [{ kind: "tool", tool: "mcp__playwright__browser_take_screenshot", text: "\u23FA \u{1F310} take_screenshot" }, { kind: "result", text: "  \u23BF Took a screenshot of the current page" }],
+    [{ kind: "text", text: "\u25CF Looks right in the browser. Committing and opening a PR." }],
+    [{ kind: "tool", tool: "Bash", text: `\u23FA $ git commit -am "feat: ${issueTitle.toLowerCase()}"` }, { kind: "result", text: `  \u23BF [${branch} 3f2a91c] feat: ${issueTitle.toLowerCase()}` }],
+    [{ kind: "tool", tool: "Bash", text: "\u23FA $ git push -u origin HEAD" }, { kind: "result", text: "  \u23BF branch set up to track origin" }],
+    [{ kind: "tool", tool: "Bash", text: `\u23FA $ gh pr create --title "${issueTitle}" --body "Closes #${issueNumber}"` }]
+  ];
+}
+function qaScript(cb, pr, title, round) {
+  const port = 5600 + pr % 50;
+  const hue = pr * 41 % 360;
+  return [
+    [{ kind: "text", text: `\u25CF Testing PR #${pr} "${title}" (round ${round}). First, the acceptance criteria from the issue.` }],
+    [{ kind: "tool", tool: "Bash", text: "\u23FA $ git diff origin/main...HEAD --stat" }, { kind: "result", text: "  \u23BF  3 files changed, 82 insertions(+), 9 deletions(-)" }],
+    [{ kind: "tool", tool: "Bash", text: "\u23FA $ npm ci && npm test -- --run" }],
+    [
+      { kind: "result", text: "  \u23BF Test Files  8 passed (8)" },
+      { kind: "result", text: "    Tests  41 passed (41)" }
+    ],
+    [{ kind: "tool", tool: "Bash", text: "\u23FA $ npm run lint && npm run build" }, { kind: "result", text: "  \u23BF \u2713 built in 1.84s" }],
+    [{ kind: "tool", tool: "Bash", text: `\u23FA $ npm run preview -- --port ${port} &` }, { kind: "result", text: `  \u23BF Local: http://localhost:${port}/` }],
+    () => cb.browserUrl(`http://localhost:${port}/`),
+    [{ kind: "tool", tool: "mcp__playwright__browser_navigate", text: `\u23FA \u{1F310} navigate http://localhost:${port}/` }, { kind: "result", text: `  \u23BF Page URL: http://localhost:${port}/` }],
+    () => cb.screenshot(Buffer.from(screenshotSvg(`QA \xB7 ${title}`, `localhost:${port}`, hue)), "image/svg+xml"),
+    [{ kind: "tool", tool: "mcp__playwright__browser_take_screenshot", text: "\u23FA \u{1F310} take_screenshot" }, { kind: "result", text: "  \u23BF Took a screenshot of the current page" }],
+    [{ kind: "tool", tool: "mcp__playwright__browser_click", text: '\u23FA \u{1F310} click "Add todo" button' }, { kind: "result", text: "  \u23BF Clicked" }],
+    [{ kind: "tool", tool: "mcp__playwright__browser_resize", text: "\u23FA \u{1F310} resize 375x740" }, { kind: "result", text: "  \u23BF Resized" }],
+    () => cb.screenshot(Buffer.from(screenshotSvg(`QA \xB7 mobile \xB7 ${title}`, `localhost:${port}`, (hue + 40) % 360)), "image/svg+xml"),
+    [{ kind: "tool", tool: "mcp__playwright__browser_take_screenshot", text: "\u23FA \u{1F310} take_screenshot" }, { kind: "result", text: "  \u23BF Took a screenshot of the current page" }],
+    [{ kind: "tool", tool: "mcp__playwright__browser_console_messages", text: "\u23FA \u{1F310} console_messages" }, { kind: "result", text: "  \u23BF No errors" }]
+  ];
+}
+function fixScript(pr) {
+  return [
+    [{ kind: "text", text: `\u25CF Reading the QA report for PR #${pr}. The toolbar overflows on phones; I'll let it wrap.` }],
+    [{ kind: "tool", tool: "Read", text: "\u23FA Read src/styles.css" }, { kind: "result", text: "  \u23BF Read 212 lines" }],
+    [{ kind: "tool", tool: "Edit", text: "\u23FA Edit src/styles.css" }, { kind: "result", text: "  \u23BF Updated" }],
+    [{ kind: "tool", tool: "Bash", text: "\u23FA $ npm test -- --run" }, { kind: "result", text: "  \u23BF Test Files  8 passed (8)" }],
+    [{ kind: "tool", tool: "Bash", text: '\u23FA $ git commit -am "fix: wrap toolbar on narrow screens" && git push origin HEAD' }, { kind: "result", text: "  \u23BF pushed" }]
+  ];
+}
+function fakeSession(opts, cb, fullName) {
+  const timers = [];
+  let stopped = false;
+  const kind = opts.role === "qa" ? "qa" : /FAILED|taking over pull request|git push origin HEAD:/.test(opts.prompt) ? "fix" : "issue";
+  const prMatch = opts.prompt.match(/pull request #(\d+)(?::\s*(.+))?/);
+  const issueMatch = opts.prompt.match(/#(\d+):\s*(.+)/);
+  const number = Number((kind === "issue" ? issueMatch?.[1] : prMatch?.[1]) ?? 0);
+  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: `  cwd ${opts.cwd}` }
+  ];
+  const body = kind === "qa" ? qaScript(cb, number, title, round) : kind === "fix" ? fixScript(number) : devScript(opts, cb, number, title);
+  const script = [header, ...body];
+  const finish = () => {
+    const costUsd = 0.3 + Math.random();
+    const turns = 15 + Math.floor(Math.random() * 20);
+    cb.tool(null);
+    if (kind === "qa") {
+      const pass = round > 1 || Math.random() > 0.35;
+      cb.log([{ kind: "text", text: pass ? "\u25CF Everything checks out. Writing up the report." : "\u25CF The toolbar overflows on a 375px screen. Failing this round." }]);
+      cb.finished({
+        ok: true,
+        text: "",
+        costUsd,
+        turns,
+        errors: [],
+        structured: {
+          verdict: pass ? "pass" : "fail",
+          summary: pass ? "The change does what the issue asks: the feature works on desktop and mobile, all 41 tests pass, and lint and build are clean." : "The feature works on desktop, but on a 375px-wide screen the toolbar overflows and the new button is cut off.",
+          checks: [
+            { name: "Unit tests", result: "pass", details: "41 passed, 0 failed" },
+            { name: "Lint + build", result: "pass", details: "No lint errors; production build succeeds" },
+            { name: "Feature works on desktop", result: "pass", details: "Clicked through the new flow at 1280x800" },
+            { name: "Mobile layout (375px)", result: pass ? "pass" : "fail", details: pass ? "Layout wraps correctly" : "Toolbar overflows horizontally; button unreachable" },
+            { name: "Console errors", result: "pass", details: "None" }
+          ],
+          commands: [
+            { command: "npm test -- --run", result: "41 passed" },
+            { command: "npm run lint && npm run build", result: "clean, built in 1.84s" }
+          ],
+          screenshots: ["Desktop view after the change", "Mobile view at 375px"],
+          fixInstructions: pass ? void 0 : "Make the toolbar wrap (flex-wrap: wrap) below 480px so every button stays visible."
+        }
+      });
+      return;
+    }
+    if (kind === "fix") {
+      const pr = repos.get(fullName)?.pulls.find((p) => p.number === number);
+      if (pr) {
+        pr.headSha = fakeSha();
+        pr.mergeState = "CLEAN";
+        pr.mergeable = "MERGEABLE";
+        runChecks(pr, false);
+      }
+      cb.log([{ kind: "text", text: `\u25CF Fixed PR #${number} and pushed. Ready for another QA round.` }]);
+      cb.finished({ ok: true, text: "", costUsd, turns, errors: [] });
+      return;
+    }
+    const repo = repos.get(fullName);
+    let url = "";
+    if (repo && number) {
+      const n = repo.nextNumber++;
+      url = `https://github.com/${fullName}/pull/${n}`;
+      repo.pulls.unshift({
+        number: n,
+        title,
+        url,
+        headRefName: `swarm/issue-${number}-${path5.basename(opts.cwd).replace(/-[0-9a-f]{4}$/, "")}`,
+        state: "OPEN",
+        isDraft: false,
+        mergeable: "MERGEABLE",
+        reviewDecision: null,
+        closesIssues: [number],
+        createdAt: now(),
+        mergedAt: null,
+        additions: 40 + number * 13 % 200,
+        deletions: number * 7 % 40,
+        checks: "pending",
+        headSha: fakeSha(),
+        mergeState: "CLEAN",
+        failedChecks: [],
+        pendingChecks: []
+      });
+      runChecks(repo.pulls[0]);
+      cb.log([{ kind: "result", text: `  \u23BF ${url}` }]);
+    }
+    cb.log([{ kind: "text", text: `\u25CF Opened ${url || "the pull request"}. It closes #${number} and includes tests.` }]);
+    cb.finished({ ok: true, text: url, costUsd, turns, errors: [] });
+  };
+  let i = 0;
+  const step = () => {
+    if (stopped) return;
+    if (i >= script.length) return finish();
+    const s = script[i++];
+    if (typeof s === "function") s();
+    else {
+      const tool2 = s.find((e) => e.kind === "tool");
+      cb.tool(tool2?.tool ?? null);
+      cb.log(s);
+    }
+    timers.push(setTimeout(step, 1600 + Math.random() * 3800));
+  };
+  timers.push(setTimeout(step, 600));
+  return {
+    send(text) {
+      timers.push(
+        setTimeout(() => {
+          if (stopped) return;
+          cb.log([{ kind: "text", text: `\u25CF Got it \u2014 "${text.slice(0, 60)}". Adjusting my approach.` }]);
+        }, 1500)
+      );
+    },
+    stop() {
+      stopped = true;
+      timers.forEach(clearTimeout);
+      cb.finished({ ok: false, text: "", costUsd: 0.1, turns: i, errors: ["Stopped by manager"] });
+    }
+  };
+}
+function createDemoBackend() {
+  const deskRepo = /* @__PURE__ */ new Map();
+  const folders = /* @__PURE__ */ new Map();
+  const addFolder = (name, github, git2 = true) => folders.set(name, { name, path: `/demo/projects/${name}`, git: git2, github, modified: Date.now() - folders.size * 36e5 });
+  for (const r of repos.values()) addFolder(r.fullName.split("/")[1], r.fullName);
+  addFolder("sketchbook", null);
+  addFolder("recipe-notes", null, false);
+  const newRepo = (name, description = "") => {
+    const fullName = `demo-co/${name}`;
+    if (!repos.has(fullName)) {
+      repos.set(fullName, { fullName, description, issues: [], pulls: [], nextNumber: 1 });
+      bareRepos.add(fullName);
+    }
+    addFolder(name, fullName);
+    return fullName;
+  };
+  const folderOf = (dir) => {
+    const f = folders.get(dir.replace(/\\/g, "/").split("/").pop() ?? "");
+    if (!f) throw new Error(`${dir} is not a folder`);
+    return f;
+  };
+  return {
+    demo: true,
+    user: async () => "demo-manager",
+    listMyRepos: async () => [...repos.values()].map((r) => ({ nameWithOwner: r.fullName, description: r.description, visibility: "PUBLIC", updatedAt: now() })),
+    repoMeta: async (fullName) => {
+      const r = repos.get(fullName);
+      if (!r) throw new Error(`Unknown demo repo ${fullName}`);
+      return { nameWithOwner: fullName, description: r.description, url: `https://github.com/${fullName}`, defaultBranch: "main" };
+    },
+    setLocalPath: () => void 0,
+    scanProjects: async () => [...folders.values()].sort((a, b) => b.modified - a.modified),
+    inspectFolder: async (dir) => folderOf(dir),
+    publishFolder: async (dir, opts) => {
+      const f = folderOf(dir);
+      return f.github ?? newRepo(f.name, opts.description);
+    },
+    createProject: async (_root, name, opts) => {
+      if (folders.has(name)) throw new Error(`/demo/projects/${name} already exists. Pick another name, or connect that folder instead.`);
+      return { fullName: newRepo(name, opts.description), path: `/demo/projects/${name}` };
+    },
+    listIssues: async (fullName) => [...repos.get(fullName)?.issues ?? []],
+    listPulls: async (fullName) => [...repos.get(fullName)?.pulls ?? []],
+    createIssue: async (fullName, title, body, labels = []) => {
+      const r = repos.get(fullName);
+      if (!r) throw new Error("Unknown repo");
+      const n = r.nextNumber++;
+      r.issues.push(issue(n, title, body, fullName, labels));
+      return n;
+    },
+    mergePull: async (fullName, number, _method, headSha) => {
+      const r = repos.get(fullName);
+      const pr = r?.pulls.find((p) => p.number === number);
+      if (!r || !pr) throw new Error("Unknown PR");
+      if (headSha && pr.headSha !== headSha) throw new Error("Head branch was modified. Review and try the merge again.");
+      mergedSinceSync.set(fullName, (mergedSinceSync.get(fullName) ?? 0) + 1);
+      pr.state = "MERGED";
+      pr.mergedAt = now();
+      r.issues = r.issues.filter((i) => !pr.closesIssues.includes(i.number));
+    },
+    updateBranch: async (fullName, number) => {
+      const pr = repos.get(fullName)?.pulls.find((p) => p.number === number);
+      if (!pr) throw new Error("Unknown PR");
+      Object.assign(pr, { headSha: fakeSha(), mergeState: "CLEAN" });
+      runChecks(pr, false);
+    },
+    closePull: async (fullName, number) => {
+      const pr = repos.get(fullName)?.pulls.find((p) => p.number === number);
+      if (pr) pr.state = "CLOSED";
+    },
+    prForBranch: async () => null,
+    prDetails: async (fullName, number) => {
+      const pr = repos.get(fullName)?.pulls.find((p) => p.number === number);
+      if (!pr) throw new Error(`Unknown PR #${number}`);
+      return {
+        number,
+        title: pr.title,
+        body: `Implements the change.
+
+Closes #${pr.closesIssues[0] ?? "?"}`,
+        url: pr.url,
+        headRefName: pr.headRefName,
+        headSha: pr.headSha,
+        isCrossRepository: false,
+        closesIssues: pr.closesIssues,
+        state: pr.state,
+        mergeable: pr.mergeable,
+        mergeState: pr.mergeState
+      };
+    },
+    issueDetails: async (fullName, number) => {
+      const i = repos.get(fullName)?.issues.find((x) => x.number === number);
+      return { title: i?.title ?? `Issue #${number}`, body: i?.body ?? "" };
+    },
+    commentPull: async (fullName, number) => `https://github.com/${fullName}/pull/${number}#issuecomment-${Date.now()}`,
+    uploadEvidence: async (fullName, filePath) => `https://github.com/${fullName}/raw/swarm-qa-evidence/${filePath}`,
+    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"})`;
+      mergedSinceSync.set(fullName, 0);
+      return `updated to ${fakeSha().slice(0, 7)}`;
+    },
+    mainDir: (fullName) => `/demo/${fullName}/main`,
+    deskDir: (fullName, slug) => `/demo/${fullName}/desks/${slug}`,
+    prepareDesk: async (fullName, _base, slug) => {
+      await new Promise((r) => setTimeout(r, 900));
+      const dir = `/demo/${fullName}/desks/${slug}`;
+      deskRepo.set(dir, fullName);
+      return dir;
+    },
+    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
+  };
+}
+function placeholderPage(title, hue) {
+  const safe = title.replace(/[<>&"]/g, "");
+  return `<!doctype html>
+<html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${safe}</title><link rel="icon" href="data:,">
+<style>
+  body { margin: 0; min-height: 100vh; display: grid; place-items: center; font-family: 'Segoe UI', Arial, sans-serif; background: hsl(${hue},60%,96%); color: #222; }
+  main { text-align: center; padding: 32px 40px; background: #fff; border-radius: 18px; box-shadow: 0 8px 30px hsla(${hue},50%,40%,.18); }
+  h1 { margin: 0 0 6px; font-size: 26px; color: hsl(${hue},60%,38%); }
+  p { margin: 0 0 22px; color: #666; }
+  button { font: inherit; font-size: 18px; padding: 10px 26px; border: 0; border-radius: 999px; background: hsl(${hue},70%,55%); color: #fff; cursor: pointer; }
+  button:active { transform: scale(.97); }
+  #count { display: block; margin-top: 16px; font-size: 15px; color: #444; }
+</style></head>
+<body><main>
+  <h1>${safe}</h1>
+  <p>A placeholder app served by the demo office.</p>
+  <button id="btn" type="button">Click me</button>
+  <span id="count">Clicked 0 times</span>
+</main>
+<script>
+  let n = 0;
+  document.getElementById('btn').addEventListener('click', () => {
+    n++;
+    document.getElementById('count').textContent = 'Clicked ' + n + (n === 1 ? ' time' : ' times');
+  });
+</script>
+</body></html>`;
+}
+var DEMO_PROGRAMS = ["npm", "npx", "node", "pnpm", "yarn", "bun", "deno", "vite", "next", "python", "python3", "py", "php", "ruby", "go", "cargo", "dotnet"];
+var demoPreviews = {
+  hasDefault: async (fullName) => !bareRepos.has(fullName),
+  start(job, cb) {
+    let stopped = false;
+    let server2 = null;
+    const timers = [];
+    const later = (ms, fn) => timers.push(setTimeout(() => !stopped && fn(), ms));
+    const hue = [...job.fullName].reduce((h, c) => (h * 31 + c.charCodeAt(0)) % 360, 7);
+    const sha = (job.pr ? repos.get(job.fullName)?.pulls.find((p) => p.number === job.pr)?.headRefName ?? String(job.pr) : job.fullName + job.defaultBranch).split("").reduce((h, c) => h * 33 + c.charCodeAt(0) >>> 0, 5381).toString(16).padStart(7, "0").slice(0, 7);
+    cb.status("preparing");
+    later(700, () => {
+      cb.commit(sha);
+      cb.log([`HEAD is now at ${sha} (${job.pr ? `PR #${job.pr}` : job.defaultBranch})`]);
+      if (!job.command && bareRepos.has(job.fullName)) {
+        stopped = true;
+        cb.failed("Nothing to run: this floor has no preview command and no package.json.", true);
+        return;
+      }
+      cb.status("installing");
+      cb.log(["$ npm ci", "added 214 packages in 1s (demo)"]);
+    });
+    later(1600, () => {
+      cb.status("starting");
+      cb.log([`$ ${job.command ?? "npm run dev"}`.replaceAll("{port}", String(job.port))]);
+      const program = job.command?.trim().split(/\s+/)[0] ?? "npm";
+      if (!DEMO_PROGRAMS.includes(program.toLowerCase())) {
+        later(400, () => {
+          cb.log([`'${program}' is not recognized as an internal or external command,`, "operable program or batch file."]);
+          stopped = true;
+          cb.failed(`The app exited (code 1) before it listened on port ${job.port}.`);
+        });
+        return;
+      }
+      server2 = http.createServer((req, res) => {
+        if (req.url !== "/" && !req.url?.startsWith("/?")) return void res.writeHead(404).end("Not found");
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" });
+        res.end(placeholderPage(job.title, hue));
+      });
+      server2.once("error", (err) => {
+        if (stopped) return;
+        stopped = true;
+        cb.failed(`Could not listen on port ${job.port}: ${err.message}`);
+      });
+      server2.listen(job.port, "127.0.0.1", () => {
+        if (stopped) return void server2?.close();
+        later(500, () => {
+          cb.log([`  \u279C  Local:   http://localhost:${job.port}/`]);
+          cb.status("running");
+        });
+      });
+    });
+    return {
+      async stop() {
+        stopped = true;
+        timers.forEach(clearTimeout);
+        const s = server2;
+        server2 = null;
+        if (!s?.listening) return;
+        s.closeAllConnections();
+        await new Promise((resolve) => s.close(() => resolve()));
+      }
+    };
+  }
+};
+var PROFILES = {
+  "pixel-todo": {
+    summary: "Todo web app \xB7 React + Vite + TypeScript",
+    qa: "- Add, complete, edit and delete todos; they survive a reload\n- Keyboard only: every action reachable, focus always visible\n- Phone width (375px): nothing overflows or gets cut off\n- No errors in the browser console",
+    qaTitle: "UI QA tester",
+    qaJob: "You test every PR the way a picky user would: click through the whole flow, try it on a phone-sized screen and with the keyboard only.",
+    devTitle: "React UI engineer",
+    devSpecialty: "frontend",
+    devJob: "You own the React components and styling. Keep components small, reuse the existing hooks, and check every change at desktop and phone widths.",
+    hires: [
+      {
+        title: "Accessibility engineer",
+        specialty: "a11y",
+        job_description: "You make the app work for **everyone**:\n\n- Keyboard navigation and focus management\n- ARIA roles, checked with `axe`\n- Colour contrast (WCAG AA)\n\nTest with the keyboard only. The [WAI-ARIA practices](https://www.w3.org/WAI/ARIA/apg/) are your reference.",
+        reason: "Keyboard shortcuts and drag-and-drop are in the backlog, and both are *easy to get wrong* for keyboard and screen-reader users."
+      }
+    ]
+  },
+  "weather-api": {
+    summary: "REST API \xB7 Node + Express",
+    qa: "- Every endpoint: happy path, bad input (400), unknown city (404)\n- Response shapes match the OpenAPI document\n- Rate limiting returns 429 with Retry-After\n- Tests and lint pass",
+    qaTitle: "API QA tester",
+    qaJob: "You test the API from the outside: curl every endpoint, try bad input and edge cases, and compare responses with the OpenAPI document.",
+    devTitle: "Backend engineer",
+    devSpecialty: "backend",
+    devJob: "You own the routes and data layer. Validate input at the edge, return consistent error shapes, and add tests for every endpoint you touch.",
+    hires: [
+      {
+        title: "API reliability engineer",
+        specialty: "reliability",
+        job_description: "You own rate limiting, caching and error handling. Measure before you optimise and document every limit in the OpenAPI spec.",
+        reason: "Rate limiting is in the backlog and the forecast endpoint will call an upstream service that needs caching and timeouts."
+      }
+    ]
+  }
+};
+var GENERIC = {
+  summary: "Web project \xB7 early stage",
+  qa: "- The app builds and starts\n- The changed feature works end to end in the browser\n- Phone width: nothing overflows\n- No console errors",
+  qaTitle: "QA tester",
+  qaJob: "You check every PR end to end in the browser, at desktop and phone widths.",
+  devTitle: "Full-stack engineer",
+  devSpecialty: "fullstack",
+  devJob: "You build features end to end, from the UI down to the data.",
+  hires: [
+    {
+      title: "Frontend engineer",
+      specialty: "frontend",
+      job_description: "You own the UI:\n\n1. Layout and components\n2. Styling, checked at **desktop and phone** widths",
+      reason: "The project needs someone who owns the UI from the start."
+    }
+  ]
+};
+function ceoSession(opts, cb) {
+  const office = opts.office;
+  const timers = [];
+  let stopped = false;
+  let done = false;
+  const wait = (ms) => new Promise((resolve) => timers.push(setTimeout(resolve, ms)));
+  const step = async (entries, ms = 900 + Math.random() * 1500) => {
+    if (stopped) throw new Error("Stopped by manager");
+    cb.tool(entries.find((e) => e.tool)?.tool ?? null);
+    cb.log(entries);
+    await wait(ms);
+  };
+  const status = async () => {
+    await step([{ kind: "tool", tool: "mcp__office__company_status", text: `\u23FA ${describeOfficeTool("company_status", {})}` }]);
+    const s = JSON.parse(await office.call("company_status", {}));
+    const people = s.floors.reduce((n, f) => n + f.team.length, 0);
+    const issues = s.floors.reduce((n, f) => n + f.backlog.length, 0);
+    cb.log([{ kind: "result", text: `  \u23BF ${s.floors.length} floors \xB7 ${people} people \xB7 ${issues} open issues \xB7 ${s.pendingProposals.length} proposals pending` }]);
+    return s;
+  };
+  const use = async (name, args) => {
+    await step([{ kind: "tool", tool: `mcp__office__${name}`, text: `\u23FA ${describeOfficeTool(name, args)}` }]);
+    const out = await office.call(name, args);
+    cb.log([{ kind: out.startsWith("Refused") ? "error" : "result", text: `  \u23BF ${out.split("\n")[0].slice(0, 170)}` }]);
+    return out;
+  };
+  const read = (file, lines) => step([{ kind: "tool", tool: "Read", text: `\u23FA Read ${file}` }, { kind: "result", text: `  \u23BF Read ${lines} lines` }]);
+  const think = (text) => step([{ kind: "thinking", text: "\u273B Thinking\u2026" }, { kind: "text", text: `\u25CF ${text}` }], 1800);
+  const short = (s, n = 48) => s.length > n ? `${s.slice(0, n - 1).trim()}\u2026` : s;
+  const planIssues = async (floor, mission, team) => {
+    const first = await use("file_issue", {
+      floor,
+      title: "Set up the project skeleton",
+      body: `Scaffold the app so the rest of the milestone has something to build on.
+
+Brief: ${mission}
+
+Acceptance criteria:
+- The dev server starts
+- A placeholder home page renders
+- Lint, tests and build scripts exist`,
+      specialty: "frontend"
+    });
+    const n = Number(first.match(/#(\d+)/)?.[1] ?? 0);
+    await use("file_issue", {
+      floor,
+      title: `Build the core: ${short(mission, 60)}`,
+      body: `${n ? `Depends on #${n}
+
+` : ""}Implement the heart of the brief.
+
+Acceptance criteria:
+- The main flow works end to end
+- Covered by tests`,
+      specialty: "frontend"
+    });
+    await use("file_issue", {
+      floor,
+      title: "Polish: phone layout and empty states",
+      body: `${n ? `Depends on #${n}
+
+` : ""}Make every screen work at 375px and add friendly empty states.`,
+      specialty: "frontend"
+    });
+    if (!team.some((a) => a.specialty === "frontend")) {
+      await use("propose_hire", { floor, role: "dev", ...GENERIC.hires[0], reason: "All three issues are UI work and nobody on the floor owns the frontend yet." });
+    }
+    return n;
+  };
+  const scripts = {
+    async onboard(floor, fullName) {
+      const s = await status();
+      const f = s.floors.find((x) => x.floor === floor);
+      if (!f) return "That floor has gone, so there was nothing to onboard.";
+      const p = PROFILES[fullName.split("/")[1] ?? ""] ?? GENERIC;
+      await read(`${f.repo}/README.md`, 48);
+      await step([{ kind: "tool", tool: "Glob", text: "\u23FA Glob src/**/*" }, { kind: "result", text: "  \u23BF Found 23 files" }]);
+      await read("package.json", 36);
+      await think(`${p.summary}. Let me shape the team around that.`);
+      await use("set_floor_profile", { floor, summary: p.summary, qa_brief: p.qa });
+      const qa = f.team.find((a) => a.role === "qa");
+      if (qa) {
+        await step([{ kind: "tool", tool: "mcp__office__agent_detail", text: `\u23FA ${describeOfficeTool("agent_detail", { agent_id: qa.id })}` }]);
+        const d = JSON.parse(await office.call("agent_detail", { agent_id: qa.id }));
+        cb.log([{ kind: "result", text: `  \u23BF ${d.title} \xB7 job description ${d.jobDescription?.length ?? 0} chars` }]);
+        await use("update_job", { agent_id: qa.id, title: p.qaTitle, job_description: p.qaJob });
+      }
+      const dev = f.team.find((a) => a.role === "dev" && !a.specialty);
+      if (dev) await use("update_job", { agent_id: dev.id, title: p.devTitle, specialty: p.devSpecialty, job_description: p.devJob });
+      const proposed = [];
+      for (const h of p.hires) if (!(await use("propose_hire", { floor, role: "dev", ...h })).startsWith("Refused")) proposed.push(h.title);
+      let planned = "";
+      if (f.brief && f.backlog.length === 0) {
+        const n = await planIssues(floor, f.brief, f.team);
+        planned = ` I also turned your brief into three issues; #${n} sets up the skeleton and the other two wait for it.`;
+      }
+      return [
+        `Floor ${floor}: ${p.summary}.`,
+        `I wrote a QA brief for it${qa ? `, made ${qa.name} our ${p.qaTitle}` : ""}${dev ? ` and ${dev.name} our ${p.devTitle}` : ""}.`,
+        proposed.length ? `I've proposed hiring: ${proposed.join(", ")}. The resume${proposed.length === 1 ? " is" : "s are"} waiting on your phone.` : "",
+        planned
+      ].filter(Boolean).join(" ");
+    },
+    async plan(floor, mission) {
+      const s = await status();
+      const f = s.floors.find((x) => x.floor === floor);
+      if (!f) return "That floor has gone, so there was nothing to plan.";
+      await read(`${f.repo}/README.md`, 12);
+      await think("Foundation first, so the parallel work doesn't collide.");
+      const n = await planIssues(floor, mission, f.team);
+      return `I turned the brief into three issues on floor ${floor}. #${n} sets up the skeleton; the other two say "Depends on #${n}", so nobody starts them early.`;
+    },
+    async review() {
+      const s = await status();
+      await think("Checking each floor for idle people and stuck work.");
+      for (const f of s.floors) {
+        const idle = f.team.filter((a) => a.role === "dev" && !a.specialty && (a.status === "idle" || a.status === "done"));
+        const devs = f.team.filter((a) => a.role === "dev").length;
+        if (devs >= 6 && idle.length >= 2 && f.backlog.length < devs) {
+          await use("propose_let_go", { agent_id: idle[idle.length - 1].id, reason: `Floor ${f.floor} has ${devs} developers for ${f.backlog.length} open issues; ${idle.length} of them are idle.` });
+          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.`;
+        }
+      }
+      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.`;
+    },
+    async chat(text) {
+      const s = await status();
+      await think("Reading your message.");
+      const people = s.floors.reduce((n, f) => n + f.team.length, 0);
+      const issues = s.floors.reduce((n, f) => n + f.backlog.length, 0);
+      const pending2 = s.pendingProposals.length;
+      const rows = s.floors.map((f) => `| ${f.floor} | \`${f.repo.split("/").pop()}\` | ${f.team.length} | ${f.backlog.length} | ${f.pullRequests.length} |`);
+      return [
+        `**Quick status:** ${s.floors.length} floor${s.floors.length === 1 ? "" : "s"}, ${people} people and ${issues} open issues.`,
+        "",
+        "- The team is *heads down* on the backlog",
+        `- ${pending2 ? `**${pending2}** proposal${pending2 === 1 ? " is" : "s are"} waiting for you in Hires` : "No hiring decisions waiting on you"}`,
+        "  - QA re-tests every PR after a fix",
+        "",
+        "| Floor | Repo | People | Issues | PRs |",
+        "| ---: | --- | ---: | ---: | ---: |",
+        ...rows.length ? rows : ["| \u2013 | no projects yet | 0 | 0 | 0 |"],
+        "",
+        "What I would do next:",
+        "",
+        "1. Merge anything that passed QA",
+        "2. Run `npm run build` on each floor before the next milestone",
+        "3. Hire only where the backlog is piling up",
+        "",
+        "```bash",
+        "SWARM_HOME=/tmp/cubefarm-demo SWARM_PORT=5260 node --import tsx server/index.ts --demo",
+        "```",
+        "",
+        `> I'm the demo CEO, so I can't act on "${short(text)}", but the real one would. See the [Claude Code docs](https://docs.claude.com/en/docs/claude-code/overview).`
+      ].join("\n");
+    }
+  };
+  const prompt = opts.prompt;
+  const where = prompt.match(/[Ff]loor (\d+) \(([^,)]+)/);
+  const run2 = /just joined the company/.test(prompt) ? () => scripts.onboard(Number(where?.[1]), where?.[2] ?? "") : /has a brief for floor/.test(prompt) ? () => scripts.plan(Number(where?.[1]), prompt.match(/"""([\s\S]*?)"""/)?.[1]?.trim() ?? "") : /Periodic review/.test(prompt) ? () => scripts.review() : () => scripts.chat(prompt.split("\n").slice(1).join(" ").trim() || prompt);
+  const finish = (ok, text, error) => {
+    if (done) return;
+    done = true;
+    cb.tool(null);
+    cb.finished({ ok, text, costUsd: ok ? 0.4 + Math.random() : 0.05, turns: 6 + Math.floor(Math.random() * 10), errors: error ? [error] : [] });
+  };
+  timers.push(
+    setTimeout(async () => {
+      try {
+        cb.log([{ kind: "system", text: `\u273B Claude Code (demo) \xB7 ${opts.model} \xB7 ${opts.effort} effort \xB7 CEO` }]);
+        const reply = await run2();
+        cb.log([{ kind: "text", text: `\u25CF ${reply}` }]);
+        cb.turn?.(reply);
+        finish(true, reply);
+      } catch (err) {
+        finish(false, "", stopped ? "Stopped by manager" : err.message);
+      }
+    }, 500)
+  );
+  return {
+    send(text) {
+      timers.push(
+        setTimeout(() => {
+          if (stopped || done) return;
+          const said = text.split("\n").slice(1).join(" ").trim() || text;
+          cb.log([{ kind: "text", text: `\u25CF Noted: "${short(said, 70)}"` }]);
+          cb.turn?.(`Noted, I'll factor that in: "${short(said, 90)}"`);
+        }, 1500)
+      );
+    },
+    stop() {
+      stopped = true;
+      timers.forEach(clearTimeout);
+      finish(false, "", "Stopped by manager");
+    }
+  };
+}
+
+// server/swarm.ts
+import fs4 from "node:fs/promises";
+import path6 from "node:path";
+import crypto3 from "node:crypto";
+
+// server/ceo.ts
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+var EFFORT = z.enum(["low", "medium", "high", "xhigh", "max"]);
+function createOfficeTools(h) {
+  const run2 = async (fn) => {
+    try {
+      return { content: [{ type: "text", text: await fn() }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Refused: ${err.message}` }], isError: true };
+    }
+  };
+  const defs = [
+    tool(
+      "company_status",
+      "Everything about the company right now: settings, every floor (repo, clone path, brief, profile, QA brief), its team, backlog, pull requests and QA, pending proposals and recent decisions by the manager. Call this first.",
+      {},
+      () => run2(() => h.companyStatus())
+    ),
+    tool(
+      "agent_detail",
+      "One agent in full: title, specialty, role, status, current task, model and effort, and their complete job description (company_status shortens long ones). Read it before rewriting someone's job description.",
+      { agent_id: z.string().describe("An id (or name) from company_status") },
+      (a) => run2(() => h.agentDetail(a))
+    ),
+    tool(
+      "set_floor_profile",
+      "Record your read of a floor's project: a one-line summary (kind of project and stack), the QA brief that tells QA testers what to check for this kind of project, and how to run the app for the floor's preview monitor.",
+      {
+        floor: z.number().int().describe("Floor number"),
+        summary: z.string().max(140).optional().describe('e.g. "3D browser game \xB7 Three.js + Vite + TypeScript"'),
+        qa_brief: z.string().max(2500).optional().describe("What QA must check on every PR for this project, as short bullet points"),
+        preview_command: z.string().max(2e3).optional().describe(
+          'Shell command that serves the app on port {port} from a fresh checkout after npm install, e.g. "npm run dev -- --port {port} --strictPort". PORT={port} is always set. {tmp} is a scratch folder. Empty string: back to the default (npm run dev, else start, else preview). Only set it when the default would not serve the app on PORT.'
+        ),
+        // Not z.record(): the SDK can't turn it into JSON Schema, and one bad tool empties the whole tools/list.
+        preview_env: z.object({}).catchall(z.string()).optional().describe("Extra environment variables for the preview; {port} and {tmp} are replaced in the values. Replaces the whole set.")
+      },
+      (a) => run2(() => h.setFloorProfile(a))
+    ),
+    tool(
+      "update_job",
+      "Change an existing agent's job title, specialty or job description so it fits the project. Takes effect from their next task.",
+      {
+        agent_id: z.string(),
+        title: z.string().max(60).optional(),
+        specialty: z.string().max(24).optional().describe('Short lowercase slug, e.g. "graphics"; "" for a generalist'),
+        job_description: z.string().max(2500).optional()
+      },
+      (a) => run2(() => h.updateJob(a))
+    ),
+    tool(
+      "propose_hire",
+      "Propose hiring a developer or QA tester for a floor. The manager approves or declines (or it is auto-approved if hiring is set to auto and the floor is under its team cap).",
+      {
+        floor: z.number().int(),
+        role: z.enum(["dev", "qa"]).describe("dev = builds issues into pull requests; qa = tests pull requests"),
+        title: z.string().max(60).describe('Specific job title, e.g. "Three.js graphics engineer"'),
+        specialty: z.string().max(24).describe('Short lowercase slug used to label issues swarm:<specialty>, e.g. "graphics"'),
+        job_description: z.string().max(2500).describe("What this person owns on this project and how they should work. Written to them, second person."),
+        reason: z.string().max(600).describe("Why the floor needs them now. The manager reads this."),
+        model: z.string().optional().describe("Leave out to use the default model"),
+        effort: EFFORT.optional().describe("Leave out to use the default effort")
+      },
+      (a) => run2(() => h.proposeHire(a))
+    ),
+    tool(
+      "propose_let_go",
+      "Propose letting an agent go (overstaffed floor, specialty no longer needed). The manager decides.",
+      { agent_id: z.string(), reason: z.string().max(600) },
+      (a) => run2(() => h.proposeLetGo(a))
+    ),
+    tool(
+      "file_issue",
+      'File a GitHub issue on a floor. A specialty routes it to that specialist first; when none is free, any free developer takes it. Write "Depends on #N" in the body only when it cannot start until #N is merged: the office will not start it until #N is closed.',
+      {
+        floor: z.number().int(),
+        title: z.string().max(120),
+        body: z.string().max(6e3).describe("Context, what to build, acceptance criteria"),
+        specialty: z.string().max(24).optional()
+      },
+      (a) => run2(() => h.fileIssue(a))
+    )
+  ];
+  const server2 = createSdkMcpServer({ name: "office", version: "1.0.0", tools: defs });
+  return {
+    server: server2,
+    async call(name, args) {
+      const def = defs.find((d) => d.name === name);
+      if (!def) throw new Error(`No office tool ${name}`);
+      const res = await def.handler(args, void 0);
+      return res.content.map((c) => c.text ?? "").join("\n");
+    }
+  };
+}
+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.`,
+    "",
+    "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.`,
+    "- 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).",
+    "",
+    "How you work:",
+    "- Call mcp__office__company_status first. It lists every floor, its clone path, team, backlog, pull requests and your pending proposals.",
+    "- Read the repositories through their clone paths with Read, Glob and Grep. They are read-only to you. You cannot run shell commands.",
+    `- Keep durable notes about the company in ${o.notesFile}: read it at the start, and update it at the end with decisions and anything worth remembering next time.`,
+    "- Change things only through the mcp__office__ tools.",
+    "- Before update_job rewrites someone's job description, read the full one with mcp__office__agent_detail and keep what still applies, especially its safety rules.",
+    "",
+    "Rules:",
+    "- Every floor keeps at least one QA tester.",
+    '- 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.`,
+    "- 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");
+}
+function ceoJobPrompt(job, floor) {
+  switch (job.kind) {
+    case "onboard":
+      if (!floor) return 'A floor was added but has since been removed. Reply "Nothing to do."';
+      return [
+        `Floor ${floor.floor} (${floor.fullName}) just joined the company. Its read-only clone is at ${floor.clone}.`,
+        "Study it: README, package manifest, source layout, tests, and how far along it is. Then:",
+        "1. set_floor_profile with a one-line summary and a QA brief for this project. If npm run dev / start / preview wouldn't serve the app on PORT, also set preview_command (and preview_env) so the floor's preview monitor can run it.",
+        "2. update_job for the people already on the floor so their titles, specialties and job descriptions fit this project (every floor starts with a generalist QA tester).",
+        "3. Propose the hires this project needs. Usually two to four developers with distinct specialties is plenty.",
+        floor.mission ? `4. The manager's brief for this floor: """${floor.mission}"""
+${floor.backlog === 0 ? "The backlog is empty: plan the first milestone as issues." : `There are ${floor.backlog} open issues: add issues only for what the brief needs and the backlog does not cover.`}` : floor.backlog === 0 ? "4. There is no brief and the backlog is empty. Do not invent work; suggest in your final message what the manager might want next." : `4. There are ${floor.backlog} open issues. Label nothing retroactively; just make sure the team can cover them.`
+      ].join("\n");
+    case "plan":
+      if (!floor) return 'A floor you were asked to plan has been removed. Reply "Nothing to do."';
+      return [
+        `The manager has a brief for floor ${floor.floor} (${floor.fullName}, clone at ${floor.clone}):`,
+        `"""${floor.mission}"""`,
+        "",
+        "Plan the next milestone toward it:",
+        `- Read the current code and the ${floor.backlog} open issues first, so you build on what exists and do not duplicate anything.`,
+        "- If the repository is empty or nearly empty, the first issue sets up a small project skeleton, and the others depend on it. Everything after that should be able to run side by side.",
+        "- File the issues, each routed to a specialty.",
+        "- Make sure the floor has the specialists those issues need; propose hires if not.",
+        "- Update the floor profile and QA brief if the brief changes what the project is."
+      ].join("\n");
+    case "review":
+      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",
+        "- 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."
+      ].join("\n");
+    case "chat":
+      return `Message from the manager (they're reading your reply on their phone):
+${job.text ?? ""}`;
+  }
+}
+function jobLabel(job, floor) {
+  const where = floor ? `floor ${floor.floor} \xB7 ${floor.fullName.split("/")[1] ?? floor.fullName}` : "a removed floor";
+  switch (job.kind) {
+    case "onboard":
+      return `Onboarding ${where}`;
+    case "plan":
+      return `Planning ${where}`;
+    case "review":
+      return "Reviewing the company";
+    case "chat":
+      return "Replying to you";
+  }
+}
+function specialtySlug(s) {
+  const slug = String(s ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 24);
+  return slug === "skip" ? "" : slug;
+}
+var specialtyLabel = (slug) => `swarm:${slug}`;
+
+// server/httpError.ts
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+
+// server/previews.ts
+var PREVIEW_BASE_PORT = 6300;
+var LOG_KEEP = 200;
+var LOG_VIEW = 40;
+var ACTIVE = ["preparing", "installing", "starting", "running"];
+var forbidden = (p) => p === PORT || p === 4317 || p === 5317 || p >= 5200 && p <= 5899;
+var DEFAULT_PREVIEW = { command: null, env: {} };
+function parsePreviewPatch(command, env) {
+  const out = {};
+  if (command !== void 0) {
+    if (command !== null && typeof command !== "string") throw new HttpError(400, "previewCommand must be a string or null");
+    const c = (command ?? "").trim();
+    if (c.length > 2e3) throw new HttpError(400, "previewCommand is too long");
+    out.command = c || null;
+  }
+  if (env !== void 0) {
+    if (env === null) out.env = {};
+    else {
+      if (typeof env !== "object" || Array.isArray(env)) throw new HttpError(400, "previewEnv must be an object of string values");
+      const entries = Object.entries(env);
+      if (entries.length > 50) throw new HttpError(400, "previewEnv has too many variables");
+      for (const [k, v] of entries) {
+        if (typeof v !== "string") throw new HttpError(400, `previewEnv.${k} must be a string`);
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(k)) throw new HttpError(400, `"${k}" is not a valid environment variable name`);
+        if (/^(ANTHROPIC_|CLAUDE)/i.test(k)) throw new HttpError(400, `${k} can't be set on a preview: Claude credentials never reach the apps the office runs`);
+        if (v.length > 4e3) throw new HttpError(400, `previewEnv.${k} is too long`);
+      }
+      out.env = Object.fromEntries(entries);
+    }
+  }
+  return out;
+}
+var Previews = class {
+  constructor(backend, hooks) {
+    this.backend = backend;
+    this.hooks = hooks;
+  }
+  backend;
+  hooks;
+  runs = /* @__PURE__ */ new Map();
+  hasDefault = /* @__PURE__ */ new Map();
+  // floor id -> package.json in its checkout
+  emitTimers = /* @__PURE__ */ new Map();
+  run(id) {
+    let r = this.runs.get(id);
+    if (!r) {
+      r = { status: "stopped", port: null, ref: null, pr: null, commit: null, startedAt: null, error: null, log: [], handle: null, gen: 0 };
+      this.runs.set(id, r);
+    }
+    return r;
+  }
+  /** The floor's reserved port: 6300 + floor, moved up by 100 while it clashes with the office or another preview. */
+  portFor(f) {
+    const active = this.runs.get(f.id);
+    if (active?.port && ACTIVE.includes(active.status)) return active.port;
+    const taken = new Set([...this.runs.entries()].filter(([id, r]) => id !== f.id && r.port && ACTIVE.includes(r.status)).map(([, r]) => r.port));
+    let p = PREVIEW_BASE_PORT + f.floor;
+    while (forbidden(p) || taken.has(p)) p += 100;
+    return p;
+  }
+  view(f) {
+    const r = this.runs.get(f.id);
+    let status = r?.status ?? "stopped";
+    if (status === "stopped" && !f.preview.command && this.hasDefault.get(f.id) === false) status = "unconfigured";
+    const port = r?.port ?? this.portFor(f);
+    return {
+      status,
+      port,
+      url: status === "running" ? `http://localhost:${port}/` : null,
+      ref: r?.ref ?? null,
+      pr: r?.pr ?? null,
+      commit: r?.commit ?? null,
+      startedAt: r?.startedAt ?? null,
+      error: r?.error ?? null,
+      logTail: (r?.log ?? []).slice(-LOG_VIEW)
+    };
+  }
+  /** Re-check whether a floor without a command has a package.json to fall back on. */
+  async refreshDefault(f) {
+    const has = await this.backend.previews.hasDefault(f.fullName).catch(() => true);
+    if (this.hasDefault.get(f.id) === has) return;
+    this.hasDefault.set(f.id, has);
+    this.hooks.emit(f.id);
+  }
+  /** Start the floor's preview on the default branch or an open PR, replacing whatever it is running now. */
+  async start(f, title, pr) {
+    if (pr !== void 0 && pr !== null && (!Number.isInteger(pr) || pr <= 0)) throw new HttpError(400, `Invalid pull request number: ${pr}`);
+    if (pr) await this.checkOpen(f, pr);
+    const r = this.run(f.id);
+    const gen = ++r.gen;
+    await this.halt(f, r);
+    if (gen !== r.gen) return this.view(f);
+    const port = this.portFor(f);
+    const ref = pr ? `PR #${pr}` : f.defaultBranch;
+    Object.assign(r, { port, ref, pr: pr ?? null, commit: null, startedAt: Date.now(), error: null, log: [] });
+    if (await portOpen(port)) {
+      if (gen !== r.gen) return this.view(f);
+      Object.assign(r, { status: "error", error: `Port ${port} is already in use by another program. The office won't stop it; free the port and try again.` });
+      this.hooks.emit(f.id);
+      throw new HttpError(409, r.error);
+    }
+    if (gen !== r.gen) return this.view(f);
+    r.status = "preparing";
+    this.hooks.emit(f.id);
+    const live = () => gen === r.gen;
+    r.handle = this.backend.previews.start(
+      { fullName: f.fullName, defaultBranch: f.defaultBranch, pr: pr ?? null, port, command: f.preview.command, env: { ...f.preview.env }, title: `${title} \xB7 ${ref}` },
+      {
+        status: (s) => {
+          if (!live()) return;
+          r.status = s;
+          this.hooks.emit(f.id);
+        },
+        commit: (sha) => {
+          if (!live()) return;
+          r.commit = sha || null;
+          this.hooks.emit(f.id);
+        },
+        log: (lines) => {
+          if (!live()) return;
+          r.log.push(...lines.map((l) => l.slice(0, 500)));
+          if (r.log.length > LOG_KEEP) r.log.splice(0, r.log.length - LOG_KEEP);
+          this.emitSoon(f.id);
+        },
+        failed: (message, unconfigured) => {
+          if (!live()) return;
+          r.handle = null;
+          Object.assign(r, { status: unconfigured ? "unconfigured" : "error", error: message });
+          if (unconfigured) this.hasDefault.set(f.id, false);
+          this.hooks.emit(f.id);
+          void this.backend.releaseDesk(f.fullName, PREVIEW_SLUG, port).catch(() => void 0);
+        }
+      }
+    );
+    return this.view(f);
+  }
+  /** Stop the floor's preview and free its port. */
+  async stop(f) {
+    const r = this.run(f.id);
+    r.gen++;
+    await this.halt(f, r);
+    Object.assign(r, { status: "stopped", error: null, startedAt: null });
+    this.hooks.emit(f.id);
+    return this.view(f);
+  }
+  /** The floor is leaving the building: stop its preview and remove the preview worktree. */
+  async remove(f) {
+    const r = this.runs.get(f.id);
+    if (r) {
+      r.gen++;
+      await this.halt(f, r);
+    }
+    this.runs.delete(f.id);
+    this.hasDefault.delete(f.id);
+    clearTimeout(this.emitTimers.get(f.id));
+    await this.backend.removeDesk(f.fullName, PREVIEW_SLUG).catch(() => void 0);
+  }
+  /** Server shutdown: stop every running preview. */
+  async stopAll(floors) {
+    await Promise.all(
+      floors.map((f) => {
+        const r = this.runs.get(f.id);
+        if (!r) return;
+        r.gen++;
+        return this.halt(f, r);
+      })
+    );
+  }
+  /** Server start: nothing is running yet, so anything alive in a preview worktree or on a preview port is an orphan. */
+  async clearOrphans(floors) {
+    await Promise.all(floors.map((f) => this.backend.releaseDesk(f.fullName, PREVIEW_SLUG, this.portFor(f)).catch(() => void 0)));
+  }
+  async halt(f, r) {
+    const handle = r.handle;
+    r.handle = null;
+    if (!handle) return;
+    await handle.stop().catch(() => void 0);
+    if (!r.port) return;
+    await this.backend.releaseDesk(f.fullName, PREVIEW_SLUG, r.port).catch(() => void 0);
+    for (let i = 0; i < 20 && await portOpen(r.port); i++) await new Promise((res) => setTimeout(res, 250));
+  }
+  async checkOpen(f, pr) {
+    const known = this.hooks.pulls(f.id).find((p) => p.number === pr);
+    const state = known?.state ?? await this.backend.prDetails(f.fullName, pr).then((d) => d.state).catch(() => null);
+    if (!state) throw new HttpError(404, `${f.fullName} has no pull request #${pr}`);
+    if (state !== "OPEN") throw new HttpError(400, `Pull request #${pr} is ${state.toLowerCase()}, not open`);
+  }
+  /** Log lines arrive in bursts (npm install); send them at most once a second. */
+  emitSoon(id) {
+    if (this.emitTimers.has(id)) return;
+    this.emitTimers.set(
+      id,
+      setTimeout(() => {
+        this.emitTimers.delete(id);
+        if (this.runs.has(id)) this.hooks.emit(id);
+      }, 1e3)
+    );
+  }
+};
+
+// 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];
+}
+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;
+}
+
+// shared/types.ts
+var CEO_ID = "ceo";
+
+// server/swarm.ts
+var FLOOR_COLORS = ["#ff8a5b", "#4fb3e8", "#8fd14f", "#c77dff", "#ffc93c", "#ff6fb5", "#2ec4b6", "#f25f5c"];
+var SHIRTS = ["#e63946", "#457b9d", "#2a9d8f", "#f4a261", "#9b5de5", "#f15bb5", "#00bbf9", "#06d6a0", "#ffbe0b", "#8338ec", "#fb5607", "#3a86ff"];
+var HAIR = ["#2b2118", "#6b4226", "#c68642", "#f2d16b", "#d94f30", "#1c1c1c", "#8e8e8e", "#5b3cc4", "#e76f51"];
+var SKIN = ["#ffdbac", "#f1c27d", "#e0ac69", "#c68642", "#8d5524", "#ffe0bd"];
+var DEV_NAMES = [
+  "Ada",
+  "Linus",
+  "Grace",
+  "Alan",
+  "Margaret",
+  "Dennis",
+  "Barbara",
+  "Ken",
+  "Radia",
+  "Guido",
+  "Hedy",
+  "Tim",
+  "Katherine",
+  "Bjarne",
+  "Frances",
+  "Edsger",
+  "Anita",
+  "Donald",
+  "Sophie",
+  "Yukihiro",
+  "Jean",
+  "Niklaus",
+  "Karen",
+  "Brendan"
+];
+var QA_NAMES = ["Sherlock", "Marple", "Poirot", "Nancy", "Columbo", "Fletcher", "Watson", "Morse", "Holmes", "Maigret"];
+var FEMININE_NAMES = new Set(
+  "ada grace margaret barbara radia hedy katherine frances anita sophie jean karen marple nancy fletcher alice amanda amelia amy ana anna anne aisha astrid ava bella beth carla caroline charlotte chloe claire clara diana elena elizabeth ella ellie emily emma eva fatima fiona freya georgia hannah harper helen holly ingrid iris isabella ivy jane jasmine jessica julia kate laura leah leila lena lily linda lisa lucy maria marie mary maya mei mia mila monica naomi natalie nina nora olivia paula priya rachel rose ruby sandra sara sarah scarlett sofia stella susan tess tessa tina vera victoria yuki zara zoe".split(" ")
+);
+var lookFor = (name) => FEMININE_NAMES.has(name.trim().split(/\s+/)[0].toLowerCase()) ? "feminine" : "masculine";
+var LOOKS = ["feminine", "masculine"];
+var MAX_DESKS = { dev: 12, qa: 3, ceo: 1 };
+var MAX_QA_ROUNDS = 3;
+var DEFAULT_MODEL = "claude-opus-5-5";
+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 MAX_PENDING_REQUESTS = 8;
+var MAX_ISSUES_PER_JOB = 12;
+var KEEP_MESSAGES = 200;
+var KEEP_DECIDED_REQUESTS = 40;
+var pick = (arr) => arr[Math.floor(Math.random() * arr.length)];
+var slugify = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "agent";
+var BUSY = ["preparing", "working"];
+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 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"}`);
+async function loadScreen(agentId) {
+  for (const [mime, ext] of Object.entries(MIME_EXT)) {
+    const file = path6.join(SCREENS_DIR, `${agentId}.${ext}`);
+    try {
+      const [data, stat] = await Promise.all([fs4.readFile(file), fs4.stat(file)]);
+      return { data, mime, at: stat.mtimeMs };
+    } catch {
+    }
+  }
+  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 })));
+}
+var QA_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["verdict", "summary", "checks", "commands", "screenshots"],
+  properties: {
+    verdict: { type: "string", enum: ["pass", "fail"], description: "pass only if the change works and meets the issue requirements" },
+    summary: { type: "string", description: "Two to four sentences for the pull request comment." },
+    checks: {
+      type: "array",
+      description: "Each acceptance criterion, test run or scenario you verified.",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["name", "result", "details"],
+        properties: {
+          name: { type: "string" },
+          result: { type: "string", enum: ["pass", "fail", "skip"] },
+          details: { type: "string", description: "What you did and what you observed." }
+        }
+      }
+    },
+    commands: {
+      type: "array",
+      description: "Test suites, linters, builds and other commands you ran.",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["command", "result"],
+        properties: { command: { type: "string" }, result: { type: "string", description: 'e.g. "42 passed, 0 failed"' } }
+      }
+    },
+    screenshots: {
+      type: "array",
+      description: "One short caption per screenshot you took with browser_take_screenshot, in the order you took them.",
+      items: { type: "string" }
+    },
+    fixInstructions: { type: "string", description: "When the verdict is fail: precise, actionable instructions for the developer." }
+  }
+};
+function parseReport(result) {
+  let raw = result.structured;
+  if (!raw && result.text) {
+    const json = result.text.match(/\{[\s\S]*\}/);
+    if (json) {
+      try {
+        raw = JSON.parse(json[0]);
+      } catch {
+        raw = null;
+      }
+    }
+  }
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  if (r.verdict !== "pass" && r.verdict !== "fail") return null;
+  return {
+    verdict: r.verdict,
+    summary: String(r.summary ?? ""),
+    checks: Array.isArray(r.checks) ? r.checks.map((c) => ({ name: String(c.name ?? ""), result: c.result === "fail" ? "fail" : c.result === "skip" ? "skip" : "pass", details: String(c.details ?? "") })) : [],
+    commands: Array.isArray(r.commands) ? r.commands.map((c) => ({ command: String(c.command ?? ""), result: String(c.result ?? "") })) : [],
+    screenshots: Array.isArray(r.screenshots) ? r.screenshots.map(String) : [],
+    fixInstructions: r.fixInstructions ? String(r.fixInstructions) : void 0
+  };
+}
+var cell = (s) => s.replace(/\|/g, "\\|").replace(/\r?\n/g, "<br>");
+var ICON = { pass: "\u2705", fail: "\u274C", skip: "\u23ED\uFE0F" };
+var Swarm = class {
+  constructor(backend) {
+    this.backend = backend;
+    this.previews = new Previews(backend, {
+      emit: (id) => {
+        const r = this.state.repos.find((x) => x.id === id);
+        if (r && this.repoRt.has(id)) this.emitRepo(r);
+      },
+      pulls: (id) => this.repoRt.get(id)?.pulls ?? []
+    });
+  }
+  backend;
+  state = {
+    settings: {
+      sessionLimit: 0,
+      defaultModel: DEFAULT_MODEL,
+      defaultEffort: "medium",
+      permissionMode: "guarded",
+      hiring: "approve",
+      teamCap: 6,
+      ceoHeartbeatMin: 60,
+      managerName: "",
+      companyName: "",
+      projectsDir: DEFAULT_PROJECTS_DIR,
+      setupDone: false,
+      tutorialStep: 0
+    },
+    repos: [],
+    agents: [],
+    qa: [],
+    requests: [],
+    ceo: { queue: [], job: null, lastReviewAt: null, lastFingerprint: null },
+    messages: [],
+    phoneReadAt: 0
+  };
+  /**
+   * The CEO's office tools. Every session gets its own server: one can only be connected to one session at a time, so
+   * a shared one left the next session connected but without any tools while an earlier session still held it.
+   */
+  officeTools() {
+    return createOfficeTools({
+      companyStatus: () => this.companyStatus(),
+      agentDetail: (a) => this.agentDetail(a),
+      setFloorProfile: (a) => this.setFloorProfile(a),
+      updateJob: (a) => this.updateJob(a),
+      proposeHire: (a) => this.proposeHire(a),
+      proposeLetGo: (a) => this.proposeLetGo(a),
+      fileIssue: (a) => this.fileIssue(a)
+    });
+  }
+  ceoIssues = { filed: 0, repos: /* @__PURE__ */ new Set() };
+  // issues filed during the current CEO job
+  messageSeq = 1;
+  agentRt = /* @__PURE__ */ new Map();
+  repoRt = /* @__PURE__ */ new Map();
+  clients = /* @__PURE__ */ new Set();
+  user = null;
+  ghError;
+  saveTimer = null;
+  flushTimer = null;
+  logSeq = 1;
+  previews;
+  // ---------- lifecycle ----------
+  async init() {
+    try {
+      const raw = await fs4.readFile(STATE_FILE, "utf8");
+      const loaded = JSON.parse(raw);
+      this.state = {
+        settings: { ...this.state.settings, ...loaded.settings },
+        repos: (loaded.repos ?? []).map((r) => ({
+          ...r,
+          autoMerge: r.autoMerge ?? true,
+          links: r.links ?? [],
+          mission: r.mission ?? "",
+          summary: r.summary ?? "",
+          qaBrief: r.qaBrief ?? "",
+          localPath: r.localPath ?? null,
+          preview: { command: r.preview?.command ?? null, env: { ...r.preview?.env } }
+        })),
+        agents: (loaded.agents ?? []).map((a) => ({
+          ...a,
+          effort: a.effort ?? "",
+          role: a.role ?? "dev",
+          title: a.title ?? "",
+          specialty: a.specialty ?? "",
+          brief: a.brief ?? "",
+          hiredBy: a.hiredBy ?? "manager",
+          look: a.look ?? lookFor(a.name),
+          task: a.task ?? (a.issueNumber ? "issue" : null)
+        })),
+        qa: (loaded.qa ?? []).map((q) => ({
+          ...q,
+          testedSha: q.testedSha ?? null,
+          passedSha: q.passedSha ?? null,
+          fixReason: q.fixReason ?? null,
+          mergeFixes: q.mergeFixes ?? 0,
+          retests: q.retests ?? 0,
+          pendingSince: q.pendingSince ?? null,
+          mergeRetryAt: q.mergeRetryAt ?? null,
+          alerted: q.alerted ?? false,
+          mergeNote: null
+        })),
+        requests: loaded.requests ?? [],
+        ceo: { ...this.state.ceo, ...loaded.ceo },
+        messages: loaded.messages ?? [],
+        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";
+      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;
+      }
+      if (loaded.settings && loaded.settings.setupDone === void 0 && this.state.repos.length > 0) {
+        Object.assign(this.state.settings, { setupDone: true, tutorialStep: -1 });
+      }
+    } catch {
+    }
+    for (const r of this.state.repos) if (r.localPath) this.backend.setLocalPath(r.fullName, r.localPath);
+    const interrupted = [];
+    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);
+      }
+    }
+    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 });
+    try {
+      this.user = await this.backend.user();
+    } catch (err) {
+      this.ghError = `GitHub CLI is not ready: ${err.message}. Run "gh auth login".`;
+      console.warn(this.ghError);
+    }
+    if (this.backend.demo && this.state.repos.length === 0) {
+      Object.assign(this.state.settings, { setupDone: true, managerName: "Demo Manager", companyName: "Demo Co." });
+      for (const r of await this.backend.listMyRepos()) {
+        const repo = await this.connectRepo(r.nameWithOwner);
+        for (let i = 0; i < (repo.floor === 1 ? 5 : 3); i++) this.hireAgent(repo.id, {});
+        this.updateRepo(repo.id, { autoAssign: true });
+      }
+    }
+    for (const r of this.state.repos) this.ensureQaTester(r);
+    this.ensureCeo(interrupted);
+    for (const r of this.state.repos) void this.cloneRepo(r.id);
+    await Promise.all(this.state.repos.map((r) => this.syncRepo(r.id)));
+    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;
+      }),
+      this.previews.clearOrphans(this.state.repos)
+    ]);
+    for (const r of this.state.repos) void this.previews.refreshDefault(r);
+    this.recover(interrupted);
+    setInterval(() => this.state.repos.forEach((r, i) => setTimeout(() => void this.syncRepo(r.id), i * 1500)), SYNC_INTERVAL_MS);
+    setInterval(() => this.schedule(), SCHEDULER_INTERVAL_MS);
+    this.save();
+    setTimeout(() => this.schedule(), 1e3);
+  }
+  /** Agents cut off by a server restart pick their Claude Code session back up (QA and demo agents start over). */
+  recover(agents) {
+    for (const a of agents) {
+      if (a.task === "qa" || this.backend.demo || !a.sessionId || !a.branch) {
+        this.appendLog(a, [{ kind: "system", text: "\u21BA The office server restarted. Starting over from the queue." }]);
+        const rec = a.task === "qa" ? this.state.qa.find((q) => q.qaAgentId === a.id && q.status === "testing") : void 0;
+        if (rec) this.setQa(rec, { status: "queued" });
+        const fix = a.task === "fix" ? this.state.qa.find((q) => q.devAgentId === a.id && q.status === "fixing") : void 0;
+        if (fix) this.setQa(fix, { status: "failed" });
+        this.clearTask(a);
+        continue;
+      }
+      if (this.slotsFull()) continue;
+      void this.message(a.id, "The office server restarted while you were working. Check the state of your worktree and continue where you left off.").catch(
+        (err) => console.warn(`could not resume ${a.name}`, err)
+      );
+    }
+  }
+  // ---------- views ----------
+  repoView(r) {
+    const rt = this.repoRt.get(r.id);
+    return {
+      id: r.id,
+      fullName: r.fullName,
+      description: r.description,
+      url: r.url,
+      defaultBranch: r.defaultBranch,
+      floor: r.floor,
+      color: r.color,
+      autoAssign: r.autoAssign,
+      autoMerge: r.autoMerge,
+      folderSync: rt.folderSync,
+      browserTesting: r.browserTesting,
+      links: r.links,
+      mission: r.mission,
+      summary: r.summary,
+      qaBrief: r.qaBrief,
+      localPath: r.localPath,
+      checkoutPath: this.backend.mainDir(r.fullName),
+      cloneStatus: rt.cloneStatus,
+      cloneError: rt.cloneError,
+      issues: rt.issues,
+      pulls: rt.pulls,
+      lastSync: rt.lastSync,
+      syncError: rt.syncError,
+      previewConfig: r.preview,
+      preview: this.previews.view(r)
+    };
+  }
+  agentView(a, withLog) {
+    const rt = this.agentRt.get(a.id);
+    return {
+      id: a.id,
+      name: a.name,
+      repoId: a.repoId,
+      role: a.role,
+      title: a.title,
+      specialty: a.specialty,
+      brief: a.brief,
+      hiredBy: a.hiredBy,
+      look: a.look,
+      task: a.task,
+      desk: a.desk,
+      color: a.color,
+      hair: a.hair,
+      skin: a.skin,
+      model: a.model,
+      effort: a.effort,
+      status: a.status,
+      issueNumber: a.issueNumber,
+      issueTitle: a.issueTitle,
+      branch: a.branch,
+      prNumber: a.prNumber,
+      prUrl: a.prUrl,
+      currentTool: rt.currentTool,
+      startedAt: a.startedAt,
+      endedAt: a.endedAt,
+      costUsd: a.costUsd,
+      turns: a.turns,
+      browserUrl: rt.browserUrl,
+      hasScreenshot: !!rt.screenshot,
+      screenshotAt: rt.screenshot?.at ?? null,
+      lastError: a.lastError,
+      log: withLog ? rt.log : []
+    };
+  }
+  qaView(q) {
+    return {
+      repoId: q.repoId,
+      prNumber: q.prNumber,
+      status: q.status,
+      round: q.round,
+      devAgentId: q.devAgentId,
+      qaAgentId: q.qaAgentId,
+      summary: q.summary,
+      checks: q.checks,
+      commentUrl: q.commentUrl,
+      mergeNote: q.mergeNote,
+      updatedAt: q.updatedAt
+    };
+  }
+  snapshot() {
+    return {
+      user: this.user,
+      ghReady: !this.ghError,
+      ghError: this.ghError,
+      demo: this.backend.demo,
+      workspaceRoot: WORKSPACE_ROOT,
+      settings: this.state.settings,
+      repos: this.state.repos.map((r) => this.repoView(r)),
+      agents: this.state.agents.map((a) => this.agentView(a, true)),
+      qa: this.state.qa.map((q) => this.qaView(q)),
+      requests: this.state.requests,
+      ceo: this.ceoInfo(),
+      messages: this.state.messages.slice(-100),
+      phoneReadAt: this.state.phoneReadAt
+    };
+  }
+  screenshot(agentId) {
+    return this.agentRt.get(agentId)?.screenshot ?? null;
+  }
+  // ---------- clients ----------
+  addClient(ws) {
+    this.clients.add(ws);
+    ws.on("close", () => this.clients.delete(ws));
+    this.send(ws, { type: "snapshot", data: this.snapshot() });
+  }
+  send(ws, ev) {
+    if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(ev));
+  }
+  broadcast(ev) {
+    const msg = JSON.stringify(ev);
+    for (const ws of this.clients) if (ws.readyState === ws.OPEN) ws.send(msg);
+  }
+  toast(level, text) {
+    this.broadcast({ type: "toast", level, text });
+  }
+  emitRepo(r) {
+    this.broadcast({ type: "repo", repo: this.repoView(r) });
+  }
+  emitAgent(a) {
+    if (!this.agentRt.has(a.id)) return;
+    const { log: _log, ...rest } = this.agentView(a, false);
+    this.broadcast({ type: "agent", agent: rest });
+  }
+  setQa(rec, patch) {
+    Object.assign(rec, patch, { updatedAt: Date.now() });
+    this.broadcast({ type: "qa", qa: this.qaView(rec) });
+    this.save();
+  }
+  appendLog(a, entries) {
+    const rt = this.agentRt.get(a.id);
+    if (!rt) return;
+    const t = Date.now();
+    for (const e of entries) {
+      const line = { id: this.logSeq++, t, kind: e.kind, text: e.text, tool: e.tool };
+      rt.log.push(line);
+      rt.pending.push(line);
+    }
+    if (rt.log.length > LOG_BUFFER) rt.log.splice(0, rt.log.length - LOG_BUFFER);
+    if (!this.flushTimer) this.flushTimer = setTimeout(() => this.flushLogs(), 120);
+  }
+  flushLogs() {
+    this.flushTimer = null;
+    for (const [agentId, rt] of this.agentRt) {
+      if (rt.pending.length === 0) continue;
+      this.broadcast({ type: "log", agentId, lines: rt.pending });
+      rt.pending = [];
+    }
+    this.save();
+  }
+  // ---------- 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);
+  }
+  // ---------- lookups ----------
+  repo(id) {
+    const r = this.state.repos.find((x) => x.id === id);
+    if (!r) throw new HttpError(404, `Repo ${id} is not connected`);
+    return r;
+  }
+  agent(id) {
+    const a = this.state.agents.find((x) => x.id === id);
+    if (!a) throw new HttpError(404, `No agent ${id}`);
+    return a;
+  }
+  running() {
+    return this.state.agents.filter((a) => BUSY.includes(a.status)).length;
+  }
+  /** True when the manager has set a session limit and every slot is taken. */
+  slotsFull() {
+    const limit = this.state.settings.sessionLimit;
+    return limit > 0 && this.running() >= limit;
+  }
+  agentSlug(a) {
+    return `${slugify(a.name)}-${a.id.slice(0, 4)}`;
+  }
+  clearTask(a) {
+    Object.assign(a, { status: "idle", task: null, issueNumber: null, issueTitle: null, branch: null, prNumber: null, prUrl: null, lastError: null });
+    this.emitAgent(a);
+  }
+  // ---------- GitHub / repos ----------
+  listGithubRepos(owner) {
+    return this.backend.listMyRepos(owner);
+  }
+  /**
+   * Give a GitHub repo a floor. Its main checkout is one of your own folders: the one you picked, else the folder in
+   * your projects folder that already has it as origin, else a fresh clone into your projects folder.
+   */
+  async connectRepo(fullName, opts = {}) {
+    const existing = this.state.repos.find((r) => r.id.toLowerCase() === fullName.toLowerCase());
+    if (existing) throw new HttpError(409, `${fullName} is already floor ${existing.floor}`);
+    const meta = await this.backend.repoMeta(fullName);
+    const folder = opts.localPath ?? await this.projectFolderFor(meta.nameWithOwner);
+    const floor = this.state.repos.reduce((m, r) => Math.max(m, r.floor), 0) + 1;
+    const repo = {
+      id: meta.nameWithOwner,
+      fullName: meta.nameWithOwner,
+      description: meta.description,
+      url: meta.url,
+      defaultBranch: meta.defaultBranch,
+      floor,
+      color: FLOOR_COLORS[(floor - 1) % FLOOR_COLORS.length],
+      autoAssign: !!opts.autoAssign,
+      autoMerge: true,
+      browserTesting: true,
+      links: [],
+      localPath: folder,
+      mission: (opts.mission ?? "").trim().slice(0, 4e3),
+      summary: "",
+      qaBrief: "",
+      preview: { ...DEFAULT_PREVIEW, env: {} },
+      addedAt: Date.now()
+    };
+    this.backend.setLocalPath(repo.fullName, folder);
+    this.state.repos.push(repo);
+    this.repoRt.set(repo.id, { issues: [], pulls: [], lastSync: null, syncing: false, cloneStatus: "pending", lastMergedAt: null, folderSync: null, merging: false });
+    this.save();
+    this.emitRepo(repo);
+    this.toast("success", `${repo.fullName} moved into floor ${floor}`);
+    this.ensureQaTester(repo);
+    void this.cloneRepo(repo.id);
+    void this.syncRepo(repo.id);
+    this.enqueueCeo({ kind: "onboard", repoId: repo.id, at: Date.now() });
+    return this.repoView(repo);
+  }
+  /** Where a GitHub repo's checkout goes when you connect it without picking a folder. */
+  async projectFolderFor(fullName) {
+    const root = this.state.settings.projectsDir;
+    const folders = await this.backend.scanProjects(root).catch(() => []);
+    const match = folders.find((f) => f.github?.toLowerCase() === fullName.toLowerCase());
+    if (match) return match.path;
+    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);
+  }
+  /** A brand-new project: a folder in your projects folder, pushed to a new GitHub repo. */
+  async createRepo(name, opts) {
+    if (!/^[A-Za-z0-9._-]+$/.test(name)) throw new HttpError(400, 'Project names may only contain letters, numbers, ".", "-" and "_"');
+    const created = await this.backend.createProject(this.state.settings.projectsDir, name, opts).catch((err) => {
+      throw new HttpError(400, err.message);
+    });
+    return this.connectRepo(created.fullName, { mission: opts.mission, autoAssign: opts.autoAssign, localPath: created.path });
+  }
+  /** 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 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 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) })) };
+  }
+  /** Give one of your folders a floor. It must already be on GitHub; otherwise publish it first. */
+  async connectFolder(dir, opts = {}) {
+    const f = await this.backend.inspectFolder(dir).catch((err) => {
+      throw new HttpError(400, err.message);
+    });
+    if (!f.github) throw new HttpError(400, `${f.name} ${f.git ? "isn't on GitHub yet" : "isn't a git repository yet"}. Publish it to GitHub first.`);
+    return this.connectRepo(f.github, { ...opts, localPath: f.path });
+  }
+  /** Put one of your folders on GitHub (only what's committed goes up), then give it a floor. */
+  async publishFolder(dir, opts) {
+    const f = await this.backend.inspectFolder(dir).catch((err) => {
+      throw new HttpError(400, err.message);
+    });
+    const name = (opts.name?.trim() || f.name).replace(/[^A-Za-z0-9._-]+/g, "-");
+    const fullName = await this.backend.publishFolder(f.path, { name, visibility: opts.visibility, description: opts.description }).catch((err) => {
+      throw new HttpError(400, err.message);
+    });
+    return this.connectRepo(fullName, { mission: opts.mission, autoAssign: opts.autoAssign, localPath: f.path });
+  }
+  disconnectRepo(id) {
+    const repo = this.repo(id);
+    this.state.ceo.queue = this.state.ceo.queue.filter((j) => j.repoId !== id);
+    for (const r of this.state.requests.filter((x) => x.repoId === id && x.status === "pending")) {
+      this.decide(r, { status: "rejected", note: "The floor was disconnected.", decidedBy: null });
+    }
+    for (const a of this.state.agents.filter((x) => x.repoId === id)) this.fireAgent(a.id, true);
+    void this.previews.remove({ ...repo });
+    this.state.repos = this.state.repos.filter((r) => r.id !== id);
+    for (const q of this.state.qa.filter((x) => x.repoId === id)) this.broadcast({ type: "qaRemoved", repoId: id, prNumber: q.prNumber });
+    this.state.qa = this.state.qa.filter((q) => q.repoId !== id);
+    for (const r of this.state.repos) r.links = r.links.filter((l) => l !== id);
+    this.repoRt.delete(id);
+    this.state.repos.sort((a, b) => a.floor - b.floor).forEach((r, i) => r.floor = i + 1);
+    this.backend.setLocalPath(repo.fullName, null);
+    this.save();
+    this.broadcast({ type: "repoRemoved", repoId: id });
+    for (const r of this.state.repos) this.emitRepo(r);
+    this.toast("info", repo.localPath ? `${repo.fullName} left the building. Your folder ${repo.localPath} is untouched.` : `${repo.fullName} disconnected (its clone stays on disk)`);
+  }
+  updateRepo(id, patch) {
+    const repo = this.repo(id);
+    const preview = parsePreviewPatch(patch.previewCommand, patch.previewEnv);
+    repo.preview = { ...repo.preview, ...preview };
+    if (preview.command === null) void this.previews.refreshDefault(repo);
+    if (patch.autoAssign !== void 0) repo.autoAssign = !!patch.autoAssign;
+    if (patch.autoMerge !== void 0) {
+      repo.autoMerge = !!patch.autoMerge;
+      if (repo.autoMerge) void this.syncRepo(repo.id);
+    }
+    if (patch.browserTesting !== void 0) repo.browserTesting = !!patch.browserTesting;
+    if (patch.color && /^#[0-9a-f]{6}$/i.test(patch.color)) repo.color = patch.color;
+    if (Array.isArray(patch.links)) repo.links = patch.links.filter((l) => l !== id && this.state.repos.some((r) => r.id === l));
+    if (typeof patch.mission === "string") repo.mission = patch.mission.trim().slice(0, 4e3);
+    if (typeof patch.summary === "string") repo.summary = patch.summary.trim().slice(0, 140);
+    if (typeof patch.qaBrief === "string") repo.qaBrief = patch.qaBrief.trim().slice(0, 2500);
+    this.save();
+    this.emitRepo(repo);
+    setTimeout(() => this.schedule(), 200);
+    return this.repoView(repo);
+  }
+  // ---------- auto-merge ----------
+  /**
+   * Auto-merge (floors with it on): a swarm PR merges itself once QA has signed off on its latest commit and GitHub's
+   * checks are green. Failing checks and merge conflicts go back to a developer; new commits after QA's sign-off send
+   * it back to QA. Merging deletes the remote branch, and the floor's folder then fast-forwards (syncRepo sees the merge).
+   */
+  async advanceMerges(repo) {
+    const rt = this.repoRt.get(repo.id);
+    if (!rt || !repo.autoMerge || rt.merging) return;
+    rt.merging = true;
+    let merged = false;
+    try {
+      for (const rec of this.state.qa.filter((q) => q.repoId === repo.id && q.status === "passed")) {
+        const pr = rt.pulls.find((p) => p.number === rec.prNumber && p.state === "OPEN");
+        if (!pr || !pr.headRefName.startsWith("swarm/")) continue;
+        if ((rt.fetchedAt ?? 0) < rec.updatedAt) continue;
+        try {
+          if (await this.advanceMerge(repo, rec, pr)) merged = true;
+        } catch (err) {
+          console.warn(`auto-merge of ${repo.fullName}#${pr.number} failed`, err);
+          this.mergeNote(rec, `auto-merge hit a problem: ${oneLine(err)}`);
+        }
+      }
+    } finally {
+      rt.merging = false;
+    }
+    if (merged) {
+      await this.syncRepo(repo.id);
+      setTimeout(() => this.schedule(), 200);
+    }
+  }
+  /** 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") {
+      const d = await this.backend.prDetails(repo.fullName, pr.number);
+      pr = { ...pr, headSha: d.headSha, mergeable: d.mergeable, mergeState: d.mergeState };
+    }
+    rec.passedSha ??= pr.headSha;
+    if (pr.headSha !== rec.passedSha) {
+      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;
+        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"}`);
+    }
+    rec.pendingSince = null;
+    if (pr.mergeable === "UNKNOWN") return this.mergeNote(rec, "GitHub is checking it can merge");
+    if (pr.mergeState === "BEHIND") {
+      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;
+    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);
+        error = "";
+        break;
+      } catch (err) {
+        error = oneLine(err).replace(/^gh .*? failed: /, "");
+        if (!/not allowed/i.test(error)) break;
+      }
+    }
+    if (error && /head (branch|commit)/i.test(error)) return this.mergeNote(rec, "new commits arrived; QA checks them first");
+    if (error) {
+      rec.mergeRetryAt = Date.now() + MERGE_RETRY_MS;
+      if (!rec.alerted) {
+        rec.alerted = true;
+        this.postMessage("office", `\u26A0\uFE0F PR #${pr.number} on ${repo.fullName} passed QA and its checks, but GitHub won't merge it: ${error}. The office retries every ${MERGE_RETRY_MS / 6e4} minutes; merge it yourself, or change the repo's merge rules, if it keeps failing.`);
+      }
+      return this.mergeNote(rec, `merge blocked: ${error}`);
+    }
+    this.toast("success", `\u{1F500} Merged PR #${pr.number} into ${repo.defaultBranch}: ${pr.title}`);
+    return true;
+  }
+  /** Show where auto-merge stands on a PR's card. Doesn't count as a change to the record. */
+  mergeNote(rec, text) {
+    if (rec.mergeNote !== text) {
+      rec.mergeNote = text;
+      this.broadcast({ type: "qa", qa: this.qaView(rec) });
+    }
+    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) {
+      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;
+    }
+    this.setQa(rec, { status: "failed", fixReason: reason, fixInstructions, mergeFixes: rec.mergeFixes + 1, mergeNote: null, pendingSince: null });
+    setTimeout(() => this.schedule(), 200);
+    return false;
+  }
+  /** Fast-forward the floor's main checkout (usually your own project folder) and report how it stands. */
+  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)}`);
+    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;
+      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}`);
+    }
+    return status;
+  }
+  /** The manager's "Sync now". */
+  async syncFolderNow(repoId2) {
+    return { folderSync: await this.syncFolder(this.repo(repoId2)) };
+  }
+  // ---------- the floor's app (preview monitor) ----------
+  /** Run the floor's app from its preview worktree: the default branch, or an open PR. Replaces what it is running now. */
+  async startPreview(id, pr) {
+    const repo = this.repo(id);
+    return this.previews.start(repo, `${repo.fullName.split("/")[1]} app`, pr);
+  }
+  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);
+  }
+  async cloneRepo(id) {
+    const repo = this.state.repos.find((r) => r.id === id);
+    const rt = this.repoRt.get(id);
+    if (!repo || !rt || rt.cloneStatus === "cloning") return;
+    rt.cloneStatus = "cloning";
+    rt.cloneError = void 0;
+    this.emitRepo(repo);
+    try {
+      await this.backend.ensureClone(repo.fullName);
+      rt.cloneStatus = "ready";
+      void this.previews.refreshDefault(repo);
+    } catch (err) {
+      rt.cloneStatus = "error";
+      rt.cloneError = err.message;
+      this.toast("error", `Could not clone ${repo.fullName}: ${rt.cloneError}`);
+    }
+    if (this.repoRt.has(id)) this.emitRepo(repo);
+  }
+  async syncRepo(id) {
+    const repo = this.state.repos.find((r) => r.id === id);
+    const rt = this.repoRt.get(id);
+    if (!repo || !rt || rt.syncing) return;
+    rt.syncing = true;
+    try {
+      const started = Date.now();
+      const [issues, pulls] = await Promise.all([this.backend.listIssues(repo.fullName), this.backend.listPulls(repo.fullName)]);
+      rt.issues = issues;
+      rt.pulls = pulls;
+      rt.lastSync = Date.now();
+      rt.fetchedAt = started;
+      rt.syncError = void 0;
+      this.reconcilePulls(repo, pulls);
+      const newest = pulls.reduce((m, p) => p.mergedAt && (!m || p.mergedAt > m) ? p.mergedAt : m, null);
+      if (newest !== rt.lastMergedAt) {
+        rt.lastMergedAt = newest;
+        void this.syncFolder(repo);
+      }
+      void this.advanceMerges(repo);
+    } catch (err) {
+      rt.syncError = err.message;
+    } finally {
+      rt.syncing = false;
+    }
+    if (this.repoRt.has(id)) this.emitRepo(repo);
+  }
+  /** Keep agents and QA records in step with what happened to PRs on GitHub. */
+  reconcilePulls(repo, pulls) {
+    for (const a of this.state.agents) {
+      if (a.repoId !== repo.id || a.role !== "dev" || a.prNumber == null || BUSY.includes(a.status) || a.status === "idle") continue;
+      const pr = pulls.find((p) => p.number === a.prNumber);
+      if (!pr || pr.state === "OPEN") continue;
+      if (a.task === "qa") {
+        this.clearTask(a);
+        continue;
+      }
+      this.appendLog(a, [{ kind: "done", text: pr.state === "MERGED" ? `\u{1F389} PR #${pr.number} was merged. Ready for the next issue.` : `PR #${pr.number} was closed without merging.` }]);
+      this.clearTask(a);
+    }
+    for (const q of this.state.qa.filter((x) => x.repoId === repo.id)) {
+      const pr = pulls.find((p) => p.number === q.prNumber);
+      if (pr && pr.state !== "OPEN" && q.status !== "testing" && q.status !== "fixing") {
+        this.state.qa = this.state.qa.filter((x) => x !== q);
+        this.broadcast({ type: "qaRemoved", repoId: repo.id, prNumber: q.prNumber });
+      }
+    }
+    for (const pr of pulls) {
+      if (pr.state !== "OPEN" || pr.isDraft || !pr.headRefName.startsWith("swarm/")) continue;
+      if (this.state.qa.some((q) => q.repoId === repo.id && q.prNumber === pr.number)) continue;
+      const dev = this.state.agents.find((a) => a.repoId === repo.id && a.role === "dev" && a.task !== "qa" && (a.prNumber === pr.number || a.branch === pr.headRefName));
+      this.queueQa(repo, pr.number, dev ?? null, pr.closesIssues[0] ?? null);
+    }
+    this.save();
+  }
+  async createIssue(repoId2, title, body, assignTo, specialty) {
+    const repo = this.repo(repoId2);
+    if (!title.trim()) throw new HttpError(400, "An issue needs a title");
+    const slug = specialtySlug(specialty);
+    const number = await this.backend.createIssue(repo.fullName, title.trim(), body, slug ? [specialtyLabel(slug)] : []);
+    await this.syncRepo(repo.id);
+    this.toast("success", `Issue #${number} filed on ${repo.fullName}`);
+    if (assignTo) await this.assign(assignTo, number);
+    else setTimeout(() => this.schedule(), 200);
+    return number;
+  }
+  async mergePull(repoId2, number, method = "squash") {
+    const repo = this.repo(repoId2);
+    await this.backend.mergePull(repo.fullName, number, method);
+    this.toast("success", `Merged PR #${number} into ${repo.defaultBranch}`);
+    await this.syncRepo(repo.id);
+    setTimeout(() => this.schedule(), 200);
+  }
+  async closePull(repoId2, number) {
+    const repo = this.repo(repoId2);
+    await this.backend.closePull(repo.fullName, number);
+    await this.syncRepo(repo.id);
+  }
+  // ---------- agents ----------
+  hireAgent(repoId2, opts) {
+    const repo = this.repo(repoId2);
+    const role = opts.role === "qa" ? "qa" : "dev";
+    const used = new Set(this.state.agents.filter((a) => a.repoId === repo.id && a.role === role).map((a) => a.desk));
+    let desk = 0;
+    while (used.has(desk)) desk++;
+    if (desk >= MAX_DESKS[role]) {
+      throw new HttpError(400, role === "qa" ? `The QA lab on floor ${repo.floor} is full (${MAX_DESKS.qa} stations)` : `Floor ${repo.floor} is full (${MAX_DESKS.dev} desks)`);
+    }
+    const name = opts.name?.trim() || this.freeName(role);
+    const agent = {
+      id: crypto3.randomUUID(),
+      name,
+      repoId: repo.id,
+      role,
+      title: String(opts.title ?? "").trim().slice(0, 60),
+      specialty: specialtySlug(opts.specialty),
+      brief: String(opts.brief ?? "").trim().slice(0, 2500),
+      hiredBy: opts.hiredBy ?? "manager",
+      look: LOOKS.includes(opts.look) ? opts.look : lookFor(name),
+      task: null,
+      desk,
+      color: opts.appearance?.color ?? pick(SHIRTS),
+      hair: opts.appearance?.hair ?? pick(HAIR),
+      skin: opts.appearance?.skin ?? pick(SKIN),
+      model: opts.model ?? "",
+      effort: EFFORTS.includes(opts.effort) ? opts.effort : "",
+      status: "idle",
+      issueNumber: null,
+      issueTitle: null,
+      branch: null,
+      prNumber: null,
+      prUrl: null,
+      startedAt: null,
+      endedAt: null,
+      costUsd: 0,
+      turns: 0,
+      sessionId: 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.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` : ""}` }] : []
+    ]);
+    this.save();
+    this.broadcast({ type: "agent", agent: this.agentView(agent, false) });
+    setTimeout(() => this.schedule(), 200);
+    return this.agentView(agent, true);
+  }
+  /** Every floor has at least one QA tester. */
+  ensureQaTester(repo) {
+    if (this.state.agents.some((a) => a.repoId === repo.id && a.role === "qa")) return;
+    this.hireAgent(repo.id, { role: "qa" });
+  }
+  /** A name from the role's pool that no agent or pending candidate has. */
+  freeName(role) {
+    const taken = /* @__PURE__ */ new Set([...this.state.agents.map((a) => a.name), ...this.state.requests.filter((r) => r.status === "pending").map((r) => r.name)]);
+    const pool = role === "qa" ? QA_NAMES : DEV_NAMES;
+    return pool.find((n) => !taken.has(n)) || `${role === "qa" ? "Tester" : "Agent"} ${this.state.agents.length + 1}`;
+  }
+  updateAgent(id, patch) {
+    const a = this.agent(id);
+    if (patch.name?.trim() && patch.name.trim() !== a.name) {
+      a.name = patch.name.trim().slice(0, 24);
+      a.look = lookFor(a.name);
+    }
+    if (LOOKS.includes(patch.look)) a.look = patch.look;
+    if (patch.color && /^#[0-9a-f]{6}$/i.test(patch.color)) a.color = patch.color;
+    if (patch.hair && /^#[0-9a-f]{6}$/i.test(patch.hair)) a.hair = patch.hair;
+    if (patch.model !== void 0) a.model = String(patch.model).trim();
+    if (patch.effort !== void 0) a.effort = EFFORTS.includes(patch.effort) ? patch.effort : "";
+    if (a.role !== "ceo") {
+      if (patch.title !== void 0) a.title = String(patch.title).trim().slice(0, 60);
+      if (patch.specialty !== void 0) a.specialty = specialtySlug(patch.specialty);
+      if (patch.brief !== void 0) a.brief = String(patch.brief).trim().slice(0, 2500);
+    }
+    this.save();
+    this.emitAgent(a);
+  }
+  fireAgent(id, force = false) {
+    const a = this.agent(id);
+    if (a.role === "ceo") throw new HttpError(409, `${a.name} runs the company and can't be let go.`);
+    if (!force && a.role === "qa" && this.state.agents.filter((x) => x.repoId === a.repoId && x.role === "qa").length <= 1) {
+      throw new HttpError(409, `${a.name} is the only QA tester on this floor, and every floor needs at least one.`);
+    }
+    for (const r of this.state.requests.filter((x) => x.kind === "let-go" && x.agentId === id && x.status === "pending")) {
+      this.decide(r, { status: "approved", note: "They were let go directly.", decidedBy: "manager" });
+    }
+    this.agentRt.get(id)?.session?.stop();
+    void removeScreens(id);
+    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;
+      if (q.devAgentId === null && q.status === "fixing") this.setQa(q, { status: "failed" });
+    }
+    const repo = this.state.repos.find((r) => r.id === a.repoId);
+    if (repo) {
+      const slug = this.agentSlug(a);
+      void this.backend.releaseDesk(repo.fullName, slug, this.port(a)).then(() => this.backend.removeDesk(repo.fullName, slug)).catch(() => void 0);
+    }
+    this.state.agents = this.state.agents.filter((x) => x.id !== id);
+    this.agentRt.delete(id);
+    this.save();
+    this.broadcast({ type: "agentRemoved", agentId: id });
+  }
+  stopAgent(id) {
+    const a = this.agent(id);
+    if (!BUSY.includes(a.status)) return;
+    a.status = "stopped";
+    a.lastError = "Stopped by manager";
+    this.appendLog(a, [{ kind: "manager", text: "\u25A0 Manager stopped this session." }]);
+    this.agentRt.get(id)?.session?.stop();
+    this.emitAgent(a);
+    this.save();
+  }
+  resetAgent(id) {
+    const a = this.agent(id);
+    if (BUSY.includes(a.status)) throw new HttpError(409, `${a.name} is busy; stop them first`);
+    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.status === "fixing") this.setQa(q, { status: "failed" });
+    }
+    this.clearTask(a);
+    this.appendLog(a, [{ kind: "system", text: "\u21BA Cleared desk. Ready for new work." }]);
+    this.save();
+  }
+  issueTaken(repo, n) {
+    if (this.state.agents.some((a) => a.repoId === repo.id && a.role === "dev" && a.task !== "qa" && a.issueNumber === n && a.status !== "idle" && a.status !== "error")) return true;
+    const pulls = this.repoRt.get(repo.id)?.pulls ?? [];
+    return pulls.some((p) => p.state === "OPEN" && (p.closesIssues.includes(n) || p.headRefName.startsWith(`swarm/issue-${n}-`)));
+  }
+  ensureSlot() {
+    if (this.slotsFull()) {
+      throw new HttpError(429, `All ${this.state.settings.sessionLimit} session slots are busy. Raise or clear the session limit in the manager's console, or wait.`);
+    }
+  }
+  async assign(agentId, issueNumber, note) {
+    const a = this.agent(agentId);
+    const repo = this.repo(a.repoId);
+    if (a.role === "qa") throw new HttpError(400, `${a.name} is a QA tester; they test pull requests rather than issues.`);
+    if (a.role === "ceo") throw new HttpError(400, `${a.name} runs the company; give issues to the developers.`);
+    if (BUSY.includes(a.status)) throw new HttpError(409, `${a.name} is already working on #${a.issueNumber}`);
+    this.ensureSlot();
+    const issue2 = this.repoRt.get(repo.id)?.issues.find((i) => i.number === issueNumber);
+    if (!issue2) throw new HttpError(404, `Issue #${issueNumber} is not open on ${repo.fullName}`);
+    const holder = this.state.agents.find((x) => x.id !== a.id && x.repoId === repo.id && x.issueNumber === issueNumber && BUSY.includes(x.status));
+    if (holder) throw new HttpError(409, `${holder.name} is already working on #${issueNumber}`);
+    void this.runTask(a, repo, issue2, note);
+    return this.agentView(a, false);
+  }
+  port(a) {
+    return 5200 + parseInt(a.id.slice(0, 4), 16) % 700;
+  }
+  linkedRepos(repo) {
+    return repo.links.map((id) => this.state.repos.find((r) => r.id === id)).filter((r) => !!r);
+  }
+  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}`;
+    return [
+      `You are ${a.name}, ${a.title ? `the team's ${a.title},` : "a software engineer"} on an autonomous agent team ("cubefarm"). Several teammates work in parallel on other issues of the same repository, each in their own git worktree. Nobody is watching live to answer questions, so make sensible decisions yourself and record assumptions in the PR description. The manager may occasionally send you messages; follow their instructions.`,
+      `Every pull request is reviewed and tested by a QA teammate. ${repo.autoMerge ? "Once they sign off and GitHub's checks pass, the office merges it by itself" : "Once they sign off, the manager merges it"}. If they find problems, or checks fail, or it conflicts with the default branch, you will get the details; fix them on the same branch.`,
+      a.brief ? `
+Your job description:
+${a.brief}` : "",
+      "",
+      `Repository: ${repo.fullName} (default branch: ${repo.defaultBranch})`,
+      repo.summary ? `Project: ${repo.summary}` : "",
+      repo.mission ? `What the team is building (the manager's brief): ${repo.mission}` : "",
+      `Your worktree: ${cwd}`,
+      fixing ? `You are fixing pull request #${fixing.pr}. Its code is checked out on local branch ${branch}; push fixes with: ${push}. Do not open a new pull request.` : `Your branch: ${branch} (already checked out, created from origin/${repo.defaultBranch})`,
+      linked.length ? `Related repositories you may read for context (do not modify them):
+${linked.join("\n")}` : "",
+      "",
+      "Workflow:",
+      "1. Read the issue and explore the relevant code before changing anything.",
+      "2. Implement the change with focused commits and clear messages.",
+      "3. Run the project's existing tests, linters and build (if any) and fix what you broke. Install dependencies first if needed.",
+      repo.browserTesting ? `4. If the project has a web UI, start its dev server in the background on port ${this.port(a)} (reserved for you, so you don't collide with teammates), then check your change with the Playwright browser tools (mcp__playwright__browser_navigate, browser_snapshot, browser_click, browser_take_screenshot). Stop the dev server when you're done.` : "4. Verify the behaviour you changed as directly as you can.",
+      `5. Push: ${push}`,
+      fixing ? "6. Reply with a short summary of what you fixed." : `6. Open a pull request with the GitHub CLI: gh pr create --base ${repo.defaultBranch} --head ${branch} --title "<concise title>" --body "<what changed, how you verified it, assumptions>". The body must contain "Closes #<issue number>".`,
+      fixing ? "" : "7. End your final message with the pull request URL on its own line.",
+      "",
+      "Rules: never push to the default branch, never force-push, never merge pull requests yourself (the office merges them once QA and the checks pass), and never edit files outside your worktree. If you cannot finish, open a draft PR (gh pr create --draft) explaining what is left and why."
+    ].filter((l) => l !== "").join("\n");
+  }
+  beginTask(a, patch, banner, preparing) {
+    const rt = this.agentRt.get(a.id);
+    Object.assign(a, {
+      status: "preparing",
+      startedAt: Date.now(),
+      endedAt: null,
+      costUsd: 0,
+      turns: 0,
+      lastError: null,
+      ...patch
+    });
+    rt.screenshot = null;
+    rt.browserUrl = null;
+    rt.shots = [];
+    void removeScreens(a.id);
+    this.appendLog(a, [
+      { kind: "system", text: "" },
+      { kind: "system", text: `\u2501\u2501\u2501 ${banner} \u2501\u2501\u2501` },
+      { kind: "system", text: preparing }
+    ]);
+    this.emitAgent(a);
+    this.save();
+  }
+  async prepare(a, repo, base, branch) {
+    try {
+      if (this.repoRt.get(repo.id)?.cloneStatus !== "ready") await this.cloneRepo(repo.id);
+      await this.backend.releaseDesk(repo.fullName, this.agentSlug(a), this.port(a));
+      const cwd = await this.backend.prepareDesk(repo.fullName, { defaultBranch: repo.defaultBranch, pr: base.pr }, this.agentSlug(a), branch);
+      return a.status === "preparing" ? cwd : null;
+    } catch (err) {
+      if (a.status !== "preparing") return null;
+      a.status = "error";
+      a.endedAt = Date.now();
+      a.lastError = err.message;
+      this.appendLog(a, [{ kind: "error", text: `\u2717 ${a.lastError}` }]);
+      this.emitAgent(a);
+      this.save();
+      return null;
+    }
+  }
+  async runTask(a, repo, issue2, note) {
+    const branch = `swarm/issue-${issue2.number}-${slugify(a.name)}`;
+    this.beginTask(
+      a,
+      { task: "issue", issueNumber: issue2.number, issueTitle: issue2.title, branch, prNumber: null, prUrl: null, sessionId: null },
+      `Issue #${issue2.number}: ${issue2.title}`,
+      `Preparing worktree on ${branch}\u2026`
+    );
+    const cwd = await this.prepare(a, repo, {}, branch);
+    if (!cwd) return;
+    const prompt = [
+      `Please resolve GitHub issue #${issue2.number}: ${issue2.title}`,
+      `URL: ${issue2.url}`,
+      issue2.labels.length ? `Labels: ${issue2.labels.join(", ")}` : "",
+      "",
+      issue2.body?.trim() || "(The issue has no description.)",
+      note ? `
+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) {
+    const rt = this.agentRt.get(a.id);
+    a.status = "working";
+    this.emitAgent(a);
+    rt.session = this.backend.startSession(
+      {
+        cwd,
+        prompt,
+        systemAppend,
+        model: a.model || this.state.settings.defaultModel,
+        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
+      },
+      {
+        log: (entries) => this.appendLog(a, entries),
+        tool: (name) => {
+          if (rt.currentTool === name) return;
+          rt.currentTool = name;
+          this.emitAgent(a);
+        },
+        sessionId: (id) => {
+          a.sessionId = id;
+        },
+        browserUrl: (url) => {
+          rt.browserUrl = url;
+          this.emitAgent(a);
+        },
+        screenshot: (data, mime) => {
+          const at = Date.now();
+          rt.screenshot = { data, mime, at };
+          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));
+        },
+        limited: (at) => this.pauseForLimit(at),
+        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;
+    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 (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);
+    this.emitAgent(a);
+    this.save();
+    void this.syncRepo(repo.id);
+    setTimeout(() => this.schedule(), 500);
+  }
+  minutes(a) {
+    return a.startedAt && a.endedAt ? Math.max(1, Math.round((a.endedAt - a.startedAt) / 6e4)) : 0;
+  }
+  fail(a, result, what) {
+    a.status = "error";
+    a.lastError = result.errors.join("; ") || "Session failed";
+    this.appendLog(a, [{ kind: "error", text: `\u2717 ${a.lastError}` }]);
+    this.toast("error", `${a.name} hit a problem on ${what}: ${a.lastError.slice(0, 120)}`);
+  }
+  async onIssueFinished(a, repo, result) {
+    const escaped = repo.fullName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const m = result.text.match(new RegExp(`https://github\\.com/${escaped}/pull/(\\d+)`, "i"));
+    if (m) {
+      a.prNumber = Number(m[1]);
+      a.prUrl = m[0];
+    } else if (a.branch) {
+      const pr = await this.backend.prForBranch(repo.fullName, a.branch).catch(() => null);
+      if (pr) {
+        a.prNumber = pr.number;
+        a.prUrl = pr.url;
+      }
+    }
+    if (a.status === "stopped") return;
+    if (!result.ok) {
+      this.issueFailed(repo, a.issueNumber);
+      return this.fail(a, result, `#${a.issueNumber}`);
+    }
+    this.issueFailures.delete(`${repo.id}#${a.issueNumber}`);
+    a.status = "done";
+    this.appendLog(a, [{ kind: "done", text: `\u2714 Finished in ${this.minutes(a)}m \xB7 ${a.turns} turns${a.prNumber ? ` \xB7 PR #${a.prNumber}` : " \xB7 no PR found"}` }]);
+    if (a.prNumber) {
+      this.queueQa(repo, a.prNumber, a, a.issueNumber);
+      this.appendLog(a, [{ kind: "system", text: `\u{1F4E8} Handed PR #${a.prNumber} to QA.` }]);
+      this.toast("success", `${a.name} opened PR #${a.prNumber} for #${a.issueNumber}; it's off to QA`);
+    } else {
+      this.noPullRequest(a, repo);
+    }
+  }
+  /**
+   * An issue session ended without a PR, which would leave the issue "taken" with nobody on it. The same developer,
+   * who has the context and the worktree, is asked once to finish; after that the issue goes back on the board.
+   */
+  noPullRequest(a, repo) {
+    const key = `${repo.id}#${a.issueNumber}`;
+    if (this.nudged.has(key)) return this.releaseIssue(a, repo);
+    this.nudged.add(key);
+    void this.message(
+      a.id,
+      `You finished without opening a pull request for #${a.issueNumber}. Finish the remaining steps now: commit, push your branch and open the PR with "Closes #${a.issueNumber}". If the issue can't be done, open a draft PR that explains why.`
+    ).catch(() => this.releaseIssue(a, repo));
+  }
+  releaseIssue(a, repo) {
+    const n = a.issueNumber;
+    this.clearTask(a);
+    this.postMessage("office", `\u26A0\uFE0F ${a.name} finished #${n} on ${repo.fullName} without opening a pull request, so it's back on the board for anyone.`);
+  }
+  // ---------- QA ----------
+  queueQa(repo, prNumber, dev, issueNumber) {
+    let rec = this.state.qa.find((q) => q.repoId === repo.id && q.prNumber === prNumber);
+    if (rec) {
+      if (rec.status === "testing") return;
+      this.setQa(rec, { status: "queued", devAgentId: dev?.id ?? rec.devAgentId, devSessionId: dev?.sessionId ?? rec.devSessionId });
+    } else {
+      rec = {
+        repoId: repo.id,
+        prNumber,
+        status: "queued",
+        round: 1,
+        devAgentId: dev?.id ?? null,
+        qaAgentId: null,
+        summary: null,
+        checks: [],
+        commentUrl: null,
+        updatedAt: Date.now(),
+        issueNumber,
+        devSessionId: dev && dev.prNumber === prNumber ? dev.sessionId : null,
+        fixInstructions: null,
+        sessionFailures: 0,
+        mergeNote: null,
+        testedSha: null,
+        passedSha: null,
+        fixReason: null,
+        mergeFixes: 0,
+        retests: 0,
+        pendingSince: null,
+        mergeRetryAt: null,
+        alerted: false
+      };
+      this.state.qa.push(rec);
+      this.setQa(rec, {});
+    }
+    setTimeout(() => this.schedule(), 200);
+  }
+  /** Manager's "send to QA" for any open PR (including ones opened by people). */
+  async sendToQa(repoId2, prNumber) {
+    const repo = this.repo(repoId2);
+    const pr = this.repoRt.get(repo.id)?.pulls.find((p) => p.number === prNumber && p.state === "OPEN");
+    if (!pr) throw new HttpError(404, `PR #${prNumber} is not open on ${repo.fullName}`);
+    const rec = this.state.qa.find((q) => q.repoId === repo.id && q.prNumber === prNumber);
+    if (rec?.status === "testing" || rec?.status === "fixing") throw new HttpError(409, `PR #${prNumber} is already ${rec.status}`);
+    if (rec && (rec.status === "needs-human" || rec.status === "passed" || rec.status === "failed")) {
+      rec.round += 1;
+      rec.sessionFailures = 0;
+    }
+    const dev = this.state.agents.find((a) => a.repoId === repo.id && a.role === "dev" && a.task !== "qa" && (a.prNumber === prNumber || a.branch === pr.headRefName));
+    this.queueQa(repo, prNumber, dev ?? null, pr.closesIssues[0] ?? null);
+    this.toast("info", `PR #${prNumber} is queued for QA`);
+  }
+  buildQaSystemAppend(a, repo, cwd, branch, pr) {
+    return [
+      `You are ${a.name}, ${a.title ? `the team's ${a.title},` : "a QA engineer"} on an autonomous agent team ("cubefarm"). Developers open pull requests; you review and independently verify each one before it is merged. Your sign-off is the review: ${repo.autoMerge ? "on this floor a PR you pass merges by itself as soon as GitHub's checks are green, so nobody else reads the code after you. " : ""}Be thorough and skeptical, but fair: fail a PR only for real problems (broken behaviour, failing tests or build, the issue's requirements not met, obvious regressions), not for style preferences.`,
+      ...a.brief ? ["", `Your job description:
+${a.brief}`] : [],
+      ...a.role === "dev" ? ["", "You're a developer covering for the QA lab while its testers are busy. You didn't write this pull request: test it as an independent QA engineer would."] : [],
+      "",
+      `Repository: ${repo.fullName} (default branch: ${repo.defaultBranch})`,
+      ...repo.summary ? [`Project: ${repo.summary}`] : [],
+      ...repo.mission ? [`What the team is building (the manager's brief): ${repo.mission}`] : [],
+      ...repo.qaBrief ? [`What to check on this project (from the CEO):
+${repo.qaBrief}`] : [],
+      `Pull request #${pr.number} "${pr.title}" from branch ${pr.headRefName}: ${pr.url}`,
+      `Your worktree: ${cwd}. It has the pull request's code checked out on local branch ${branch}.`,
+      "",
+      "How to test:",
+      "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).",
+      "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."
+    ].join("\n");
+  }
+  async runQa(a, repo, rec) {
+    const branch = `qa/pr-${rec.prNumber}-${slugify(a.name)}`;
+    this.setQa(rec, { status: "testing", qaAgentId: a.id });
+    this.beginTask(
+      a,
+      { task: "qa", issueNumber: rec.issueNumber, issueTitle: `PR #${rec.prNumber}`, branch, prNumber: rec.prNumber, prUrl: null, sessionId: null },
+      `QA \xB7 PR #${rec.prNumber} \xB7 round ${rec.round}`,
+      `Checking out PR #${rec.prNumber}\u2026`
+    );
+    let pr;
+    let issue2 = null;
+    try {
+      pr = await this.backend.prDetails(repo.fullName, rec.prNumber);
+      const issueNumber = rec.issueNumber ?? pr.closesIssues[0] ?? null;
+      if (issueNumber) issue2 = await this.backend.issueDetails(repo.fullName, issueNumber).catch(() => null);
+      Object.assign(a, { issueTitle: pr.title, prUrl: pr.url });
+      rec.testedSha = pr.headSha;
+      this.emitAgent(a);
+    } catch (err) {
+      a.status = "error";
+      a.endedAt = Date.now();
+      a.lastError = err.message;
+      this.appendLog(a, [{ kind: "error", text: `\u2717 ${a.lastError}` }]);
+      this.setQa(rec, { status: "queued", qaAgentId: null });
+      this.emitAgent(a);
+      return;
+    }
+    if (pr.state !== "OPEN") {
+      this.appendLog(a, [{ kind: "system", text: `PR #${pr.number} is ${pr.state.toLowerCase()}; nothing to test.` }]);
+      this.state.qa = this.state.qa.filter((q) => q !== rec);
+      this.broadcast({ type: "qaRemoved", repoId: repo.id, prNumber: rec.prNumber });
+      this.clearTask(a);
+      return;
+    }
+    const cwd = await this.prepare(a, repo, { pr: rec.prNumber }, branch);
+    if (!cwd) {
+      if (this.state.qa.includes(rec) && rec.status === "testing") this.setQa(rec, { status: "queued", qaAgentId: null });
+      return;
+    }
+    const dev = rec.devAgentId ? this.state.agents.find((x) => x.id === rec.devAgentId) : null;
+    const prompt = [
+      `Please QA pull request #${pr.number}: ${pr.title}`,
+      `URL: ${pr.url}`,
+      `Author: ${dev ? `${dev.name} (developer agent)` : "a teammate"} \xB7 QA round ${rec.round}`,
+      rec.fixReason === "conflict" ? `
+QA passed it before, but since then the branch was updated with ${repo.defaultBranch} to resolve merge conflicts. Re-check everything, especially where this change meets the newly merged work.` : rec.fixReason === "checks" ? "\nQA passed it before, but since then the developer changed the code to fix failing GitHub checks. Re-check everything." : rec.round > 1 && rec.summary ? `
+This is a re-test after fixes. Last round's findings:
+${rec.summary}
+${rec.fixInstructions ?? ""}
+Check those first, then re-check everything else.` : "",
+      "",
+      "PR description:",
+      pr.body.trim() || "(empty)",
+      issue2 ? `
+Linked issue: ${issue2.title}
+${issue2.body.trim() || "(no description)"}` : ""
+    ].filter((l) => l !== "").join("\n");
+    this.startAgentSession(a, repo, cwd, prompt, this.buildQaSystemAppend(a, repo, cwd, branch, pr), void 0, QA_SCHEMA);
+  }
+  async onQaFinished(a, repo, result) {
+    const rec = this.state.qa.find((q) => q.repoId === repo.id && q.prNumber === a.prNumber);
+    const rt = this.agentRt.get(a.id);
+    const report = result.ok ? parseReport(result) : null;
+    if (a.status === "stopped" || !report) {
+      if (a.status !== "stopped") this.fail(a, { ...result, errors: result.errors.length ? result.errors : ["QA finished without a usable report"] }, `QA of PR #${a.prNumber}`);
+      if (rec) {
+        const failures = rec.sessionFailures + (this.limited() ? 0 : 1);
+        this.setQa(rec, {
+          status: a.status === "stopped" || failures >= 2 ? "needs-human" : "queued",
+          qaAgentId: null,
+          sessionFailures: failures,
+          summary: a.status === "stopped" ? "QA was stopped by the manager." : rec.summary
+        });
+      }
+      return;
+    }
+    a.status = "done";
+    const pass = report.verdict === "pass";
+    this.appendLog(a, [{ kind: pass ? "done" : "error", text: `${pass ? "\u2705 QA passed" : "\u274C QA failed"} PR #${a.prNumber} \xB7 ${report.checks.length} checks \xB7 ${rt.shots.length} screenshots` }]);
+    let commentUrl = null;
+    if (rec) {
+      try {
+        this.appendLog(a, [{ kind: "system", text: "\u{1F4CE} Uploading evidence and posting the QA report on the PR\u2026" }]);
+        const body = await this.renderQaComment(a, repo, rec, report, rt.shots);
+        commentUrl = await this.backend.commentPull(repo.fullName, rec.prNumber, body) || null;
+        this.appendLog(a, [{ kind: "system", text: `  \u23BF ${commentUrl ?? "comment posted"}` }]);
+      } catch (err) {
+        this.appendLog(a, [{ kind: "error", text: `  \u23BF Could not post the QA report: ${err.message}` }]);
+      }
+      const qaRounds = rec.round - rec.retests;
+      const nextStatus = pass ? "passed" : qaRounds >= MAX_QA_ROUNDS ? "needs-human" : "failed";
+      this.setQa(rec, {
+        status: nextStatus,
+        summary: report.summary,
+        checks: report.checks,
+        commentUrl: commentUrl ?? rec.commentUrl,
+        fixInstructions: report.fixInstructions ?? report.checks.filter((c) => c.result === "fail").map((c) => `${c.name}: ${c.details}`).join("\n"),
+        sessionFailures: 0,
+        fixReason: pass ? null : "qa",
+        passedSha: pass ? rec.testedSha : null,
+        mergeNote: null,
+        pendingSince: null,
+        mergeRetryAt: null,
+        alerted: false
+      });
+      this.toast(
+        pass ? "success" : "error",
+        pass ? `\u2705 ${a.name} passed PR #${rec.prNumber}${repo.autoMerge ? "; it merges once GitHub's checks are green" : ": ready to merge"}` : nextStatus === "needs-human" ? `\u274C PR #${rec.prNumber} failed QA ${qaRounds} times and needs a human` : `\u274C ${a.name} failed PR #${rec.prNumber}; sending it back to the developer`
+      );
+    }
+  }
+  async renderQaComment(a, repo, rec, report, shots) {
+    const pass = report.verdict === "pass";
+    const images = [];
+    const evidence = shots.slice(-8);
+    const offset = shots.length - evidence.length;
+    const folder = `pr-${rec.prNumber}/round-${rec.round}-${Date.now().toString(36)}`;
+    for (const [i, shot] of evidence.entries()) {
+      const n = offset + i + 1;
+      const ext = MIME_EXT[shot.mime] ?? "png";
+      const file = `${folder}/${String(n).padStart(2, "0")}.${ext}`;
+      try {
+        const url = await this.backend.uploadEvidence(repo.fullName, file, shot.data);
+        const caption = report.screenshots[n - 1] ?? `Screenshot ${n}`;
+        images.push(`**${n}. ${caption}**${shot.url ? ` \xB7 \`${shot.url}\`` : ""}
+
+<img src="${url}" alt="${caption.replace(/"/g, "'")}" width="760">`);
+      } catch (err) {
+        this.appendLog(a, [{ kind: "error", text: `  \u23BF screenshot ${n} upload failed: ${err.message.slice(0, 120)}` }]);
+      }
+    }
+    const dev = rec.devAgentId ? this.state.agents.find((x) => x.id === rec.devAgentId) : null;
+    const lines = [
+      `## \u{1F50D} QA report: ${pass ? "\u2705 Passed" : "\u274C Failed"}`,
+      `**Tester:** ${a.name} (cubefarm QA agent) \xB7 **Round:** ${rec.round}${dev ? ` \xB7 **Author:** ${dev.name}` : ""}`,
+      "",
+      report.summary,
+      "",
+      "| | Check | Details |",
+      "|---|---|---|",
+      ...report.checks.map((c) => `| ${ICON[c.result]} | ${cell(c.name)} | ${cell(c.details)} |`)
+    ];
+    if (report.commands.length) {
+      lines.push("", "<details><summary>\u{1F9EA} Commands run</summary>", "", "| Command | Result |", "|---|---|", ...report.commands.map((c) => `| \`${cell(c.command)}\` | ${cell(c.result)} |`), "", "</details>");
+    }
+    if (!pass && report.fixInstructions) lines.push("", "### \u{1F527} What needs fixing", "", report.fixInstructions);
+    if (images.length) lines.push("", "### \u{1F4F8} Evidence", "", ...images.flatMap((img) => [img, ""]));
+    else lines.push("", "_No browser screenshots were taken in this round._");
+    const merge = repo.autoMerge ? "merges automatically once GitHub's checks pass" : "ready for the manager to merge";
+    lines.push("", `<sub>Posted by cubefarm \xB7 ${pass ? merge : rec.round - rec.retests >= MAX_QA_ROUNDS ? "needs a human decision" : "sent back to the developer for fixes"}</sub>`);
+    return lines.join("\n");
+  }
+  /** Send a failed PR back to the developer who wrote it (or any free developer on the floor). */
+  async runFix(dev, repo, rec) {
+    const original = rec.devAgentId === dev.id;
+    const pull = this.repoRt.get(repo.id)?.pulls.find((p) => p.number === rec.prNumber);
+    const headRef = pull?.headRefName ?? dev.branch ?? `pr-${rec.prNumber}`;
+    const qaAgent = rec.qaAgentId ? this.state.agents.find((x) => x.id === rec.qaAgentId) : null;
+    this.setQa(rec, { status: "fixing", devAgentId: dev.id });
+    this.beginTask(
+      dev,
+      { task: "fix", issueNumber: rec.issueNumber, issueTitle: pull?.title ?? `PR #${rec.prNumber}`, branch: headRef, prNumber: rec.prNumber, prUrl: pull?.url ?? null },
+      rec.fixReason === "conflict" ? `Resolving conflicts on PR #${rec.prNumber}` : rec.fixReason === "checks" ? `Fixing checks on PR #${rec.prNumber}` : `Fixing PR #${rec.prNumber} after QA round ${rec.round}`,
+      `Checking out PR #${rec.prNumber}\u2026`
+    );
+    const cwd = await this.prepare(dev, repo, { pr: rec.prNumber }, headRef);
+    if (!cwd) {
+      if (rec.status === "fixing") this.setQa(rec, { status: "failed" });
+      return;
+    }
+    const failed2 = rec.checks.filter((c) => c.result === "fail");
+    const takeover = original ? "" : " A teammate wrote it, so read the PR and the linked issue first.";
+    const push = `push to the same branch: git push origin HEAD:${headRef}`;
+    const mergeFix = rec.fixReason === "conflict" ? [
+      `QA passed pull request #${rec.prNumber} (${pull?.url ?? ""}), but it now conflicts with ${repo.defaultBranch} because other work was merged first.${takeover}`,
+      "",
+      `Bring it up to date: git fetch origin && git merge origin/${repo.defaultBranch}. Resolve the conflicts so both this change and the newly merged work keep working, run the project's checks, and ${push}`
+    ] : rec.fixReason === "checks" ? [
+      `QA passed pull request #${rec.prNumber} (${pull?.url ?? ""}), but GitHub checks failed on it.${takeover}`,
+      "",
+      `Failed checks:
+${rec.fixInstructions ?? ""}`,
+      "",
+      `Read the logs with gh pr checks ${rec.prNumber} -R ${repo.fullName} (for GitHub Actions: gh run view <run id> -R ${repo.fullName} --log-failed). Fix the cause, run the same checks locally where you can, and ${push}`,
+      `If a failure clearly has nothing to do with this change (a flaky test or a service outage), re-run it instead with gh run rerun <run id> -R ${repo.fullName} --failed, and say so.`
+    ] : null;
+    const qaFix = [
+      original ? `QA tester ${qaAgent?.name ?? "QA"} tested your pull request #${rec.prNumber} and it FAILED (round ${rec.round}).` : `You are taking over pull request #${rec.prNumber} (${pull?.url ?? ""}), written by a teammate, because QA failed it (round ${rec.round}). Read the PR and the linked issue first.`,
+      "",
+      `QA summary: ${rec.summary ?? ""}`,
+      failed2.length ? `Failed checks:
+${failed2.map((c) => `- ${c.name}: ${c.details}`).join("\n")}` : "",
+      rec.fixInstructions ? `
+What needs fixing:
+${rec.fixInstructions}` : "",
+      rec.commentUrl ? `
+Full report with screenshots: ${rec.commentUrl}` : "",
+      "",
+      `Fix these problems, re-run the relevant checks, and push to the same branch: git push origin HEAD:${headRef}`,
+      "Then reply with a short summary of what you changed. Do not open a new pull request; QA will re-test automatically."
+    ];
+    const mergeEnd = "Then reply with a short summary of what you did. Do not open a new pull request; the office merges it once the checks pass, after another QA round if the code changed.";
+    const prompt = (mergeFix ? [...mergeFix, "", mergeEnd] : qaFix).filter((l) => l !== "").join("\n");
+    const resume = original && rec.devSessionId ? rec.devSessionId : void 0;
+    this.startAgentSession(dev, repo, cwd, prompt, this.buildSystemAppend(dev, repo, cwd, headRef, { pr: rec.prNumber, headRef }), resume);
+  }
+  onFixFinished(a, repo, result) {
+    const rec = this.state.qa.find((q) => q.repoId === repo.id && q.prNumber === a.prNumber);
+    if (a.status === "stopped") {
+      if (rec?.status === "fixing") this.setQa(rec, { status: "failed" });
+      return;
+    }
+    if (!result.ok) {
+      this.fail(a, result, `the fix for PR #${a.prNumber}`);
+      const failures = rec ? rec.sessionFailures + (this.limited() ? 0 : 1) : 0;
+      if (rec) this.setQa(rec, { status: failures >= 2 ? "needs-human" : "failed", sessionFailures: failures });
+      return;
+    }
+    a.status = "done";
+    if (rec && (rec.fixReason === "checks" || rec.fixReason === "conflict")) {
+      this.appendLog(a, [{ kind: "done", text: `\u2714 PR #${a.prNumber} fixed in ${this.minutes(a)}m. Back in line to merge.` }]);
+      this.setQa(rec, { status: "passed", devSessionId: a.sessionId ?? rec.devSessionId, mergeNote: "waiting for fresh checks" });
+      this.toast("info", `${a.name} fixed PR #${rec.prNumber}; it merges once it passes again`);
+      return;
+    }
+    this.appendLog(a, [{ kind: "done", text: `\u2714 Fix pushed for PR #${a.prNumber} in ${this.minutes(a)}m. Back to QA.` }]);
+    if (rec) {
+      this.setQa(rec, { status: "queued", round: rec.round + 1, devSessionId: a.sessionId ?? rec.devSessionId });
+      this.toast("info", `${a.name} pushed fixes for PR #${rec.prNumber}; QA round ${rec.round} is queued`);
+    }
+  }
+  async message(id, text) {
+    const a = this.agent(id);
+    if (a.role === "ceo") return this.messageCeo(text);
+    const repo = this.repo(a.repoId);
+    if (!text.trim()) throw new HttpError(400, "Empty message");
+    const rt = this.agentRt.get(id);
+    if (rt.session) {
+      this.appendLog(a, [{ kind: "manager", text: `\u25B6 Manager: ${text}` }]);
+      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.`);
+    if (a.status === "preparing") throw new HttpError(409, `${a.name} is still setting up; try again in a moment`);
+    if (!a.sessionId || !a.branch || a.task === "qa") throw new HttpError(409, `${a.name} has no session to continue. Assign an issue instead.`);
+    this.ensureSlot();
+    this.appendLog(a, [{ kind: "manager", text: `\u25B6 Manager: ${text}` }]);
+    const cwd = this.backend.deskDir(repo.fullName, this.agentSlug(a));
+    a.lastError = null;
+    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);
+  }
+  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 (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.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.setupDone === "boolean") s.setupDone = patch.setupDone;
+    if (patch.tutorialStep !== void 0) s.tutorialStep = Math.max(-1, Math.round(Number(patch.tutorialStep)) || 0);
+    this.save();
+    this.broadcast({ type: "settings", settings: s });
+    this.emitCeo();
+    setTimeout(() => this.schedule(), 200);
+    return s;
+  }
+  /** The setup wizard: who you are, the company, and your CEO. */
+  setup(x) {
+    this.updateSettings({
+      managerName: x.managerName,
+      companyName: x.companyName,
+      ...x.hiring === "auto" || x.hiring === "approve" ? { hiring: x.hiring } : {}
+    });
+    const ceo = this.ceo();
+    this.updateAgent(ceo.id, { name: x.ceoName, color: x.ceoColor });
+    if (LOOKS.includes(x.ceoLook)) this.updateAgent(ceo.id, { look: x.ceoLook });
+    return this.state.settings;
+  }
+  // ---------- scheduling ----------
+  /**
+   * Agents on a floor who can take work now. One whose last session failed sits out a short cooldown, then gets work
+   * like everyone else instead of waiting for the manager to reset them.
+   */
+  available(repo, role) {
+    const now2 = Date.now();
+    return this.state.agents.filter((a) => a.repoId === repo.id && a.role === role && (FREE.includes(a.status) || a.status === "error" && now2 - (a.endedAt ?? 0) >= ERROR_COOLDOWN_MS)).sort((x, y) => x.desk - y.desk);
+  }
+  scheduleOffset = 0;
+  issueFailures = /* @__PURE__ */ new Map();
+  // `${repoId}#${issue}` → failed sessions on it
+  nudged = /* @__PURE__ */ new Set();
+  // `${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
+  /** 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;
+    const open = new Set(issues.map((i) => i.number));
+    const weight = holdUps(issues);
+    return issues.filter(
+      (i) => !i.labels.some((l) => /^(swarm:skip|wontfix|question)$/i.test(l)) && !this.issueTaken(repo, i.number) && blockers(i.body, open).length === 0 && (this.issueFailures.get(`${repo.id}#${i.number}`) ?? 0) < MAX_ISSUE_FAILURES
+    ).map((issue2) => ({ issue: issue2, want: issueSpecialty(issue2.labels), ...weight.get(issue2.number) })).sort((x, y) => y.chain - x.chain || y.waiting - x.waiting || x.issue.number - y.issue.number);
+  }
+  /**
+   * The free developer to put on a job: one it `suits` first, then whoever is least needed elsewhere (fewest ready
+   * issues in their specialty, then the least open work in it), so specialists stay free for their own lane.
+   */
+  pickDev(repo, devs, suits) {
+    if (devs.length <= 1) return devs[0];
+    const ready = this.readyIssues(repo).map((r) => r.want);
+    const open = this.repoRt.get(repo.id).issues.map((i) => issueSpecialty(i.labels));
+    const rank = (a) => {
+      const s = a.specialty.toLowerCase();
+      return [suits(a) ? 0 : 1, ready.filter((w) => w === s).length, open.filter((w) => w === s).length, a.desk];
+    };
+    return devs.map((a) => ({ a, r: rank(a) })).sort((x, y) => x.r[0] - y.r[0] || x.r[1] - y.r[1] || x.r[2] - y.r[2] || x.r[3] - y.r[3])[0].a;
+  }
+  /**
+   * Finish work in flight: test queued PRs (oldest first) and get failed ones fixed. Returns true if work started.
+   * QA testers test; when they're all busy, a free developer who didn't write the PR covers for them, so QA never
+   * holds up the floor. A failed PR goes back to its author when they're free, and otherwise to any free developer.
+   */
+  startPipelineWork(repo) {
+    const devs = this.available(repo, "dev");
+    const testers = this.available(repo, "qa");
+    const waiting = (status) => this.state.qa.filter((q) => q.repoId === repo.id && q.status === status).sort((x, y) => x.updatedAt - y.updatedAt);
+    for (const rec of waiting("queued")) {
+      const tester = testers[0] ?? this.pickDev(
+        repo,
+        devs.filter((a) => a.id !== rec.devAgentId),
+        (a) => /test|qa/i.test(a.specialty)
+      );
+      if (!tester) continue;
+      void this.runQa(tester, repo, rec);
+      return true;
+    }
+    for (const rec of waiting("failed")) {
+      const issue2 = this.repoRt.get(repo.id).issues.find((i) => i.number === rec.issueNumber);
+      const want = issue2 ? issueSpecialty(issue2.labels) : null;
+      const dev = devs.find((a) => a.id === rec.devAgentId) ?? this.pickDev(repo, devs, (a) => a.specialty.toLowerCase() === want);
+      if (!dev) break;
+      void this.runFix(dev, repo, rec);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Give a free developer the next backlog issue (auto-assign floors only). Returns true if work started.
+   * Issues that say "Depends on #N" wait until #N is closed; the rest go in readyIssues() order. A swarm:<specialty>
+   * label is a preference, not a lock: a free specialist gets first pick, and otherwise the issue goes to whichever
+   * free developer is least needed elsewhere, so nobody sits idle while there is work that can start.
+   */
+  startIssueWork(repo) {
+    if (!repo.autoAssign) return false;
+    const free = this.available(repo, "dev");
+    const ready = free.length ? this.readyIssues(repo) : [];
+    if (ready.length === 0) return false;
+    const fits = (a, want) => a.specialty.toLowerCase() === want;
+    const pick2 = ready.find((r) => r.chain === ready[0].chain && free.some((a) => fits(a, r.want))) ?? ready[0];
+    const agent = this.pickDev(repo, free, (a) => fits(a, pick2.want));
+    void this.assign(agent.id, pick2.issue.number).catch((err) => console.warn("auto-assign failed", err));
+    return agent.status === "preparing";
+  }
+  limited() {
+    return Date.now() < this.pausedUntil;
+  }
+  /** Claude turned a session away for the usage limit: start nothing new until it resets, rather than failing agent after agent. */
+  pauseForLimit(resetsAt) {
+    const until = (resetsAt ?? Date.now() + LIMIT_PAUSE_MS) + 3e4;
+    if (until <= this.pausedUntil) return;
+    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.`);
+  }
+  /** A failed session releases its issue for someone else; an issue that keeps failing waits for the manager. */
+  issueFailed(repo, n) {
+    if (n == null || this.limited()) return;
+    const key = `${repo.id}#${n}`;
+    const failures = (this.issueFailures.get(key) ?? 0) + 1;
+    this.issueFailures.set(key, failures);
+    if (failures === MAX_ISSUE_FAILURES) {
+      this.postMessage("office", `\u26A0\uFE0F Issue #${n} on ${repo.fullName} failed ${failures} sessions in a row, so auto-assign skips it now. Assign it to someone by hand once it's sorted.`);
+    }
+  }
+  /**
+   * Hand out work for free session slots. Finishing beats starting: QA and QA fixes on every floor go before any new issue.
+   * Within each phase floors take turns (one job per floor per pass), and the starting floor rotates between calls,
+   * so no repo can hog the slots.
+   */
+  schedule() {
+    if (this.limited()) return;
+    this.maybeHeartbeat();
+    this.startCeoWork();
+    const repos2 = this.state.repos.filter((r) => {
+      const rt = this.repoRt.get(r.id);
+      return rt && rt.lastSync != null && rt.cloneStatus !== "error";
+    });
+    if (repos2.length === 0) return;
+    this.scheduleOffset = (this.scheduleOffset + 1) % repos2.length;
+    const order = [...repos2.slice(this.scheduleOffset), ...repos2.slice(0, this.scheduleOffset)];
+    for (const start of [(r) => this.startPipelineWork(r), (r) => this.startIssueWork(r)]) {
+      let progress = true;
+      while (progress) {
+        progress = false;
+        for (const repo of order) {
+          if (this.slotsFull()) return;
+          if (start(repo)) progress = true;
+        }
+      }
+    }
+  }
+  // ---------- the CEO ----------
+  ceo() {
+    return this.state.agents.find((a) => a.id === CEO_ID);
+  }
+  /** The company always has a CEO. One cut off by a server restart picks its job back up. */
+  ensureCeo(interrupted) {
+    let a = this.state.agents.find((x) => x.id === CEO_ID);
+    if (!a) {
+      a = {
+        id: CEO_ID,
+        name: CEO_NAME,
+        repoId: "",
+        role: "ceo",
+        title: "Chief Executive Officer",
+        specialty: "",
+        brief: "",
+        hiredBy: "manager",
+        look: lookFor(CEO_NAME),
+        task: null,
+        desk: 0,
+        color: "#e63946",
+        hair: "#2b2118",
+        skin: pick(SKIN),
+        model: CEO_MODEL,
+        effort: CEO_EFFORT,
+        status: "idle",
+        issueNumber: null,
+        issueTitle: null,
+        branch: null,
+        prNumber: null,
+        prUrl: null,
+        startedAt: null,
+        endedAt: null,
+        costUsd: 0,
+        turns: 0,
+        sessionId: 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.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);
+    if (i >= 0) {
+      interrupted.splice(i, 1);
+      a.status = "idle";
+      a.lastError = null;
+      this.appendLog(a, [{ kind: "system", text: "\u21BA The office server restarted. Picking the job back up." }]);
+    }
+    if (this.state.ceo.job) {
+      this.state.ceo.queue.unshift(this.state.ceo.job);
+      this.state.ceo.job = null;
+    }
+    this.state.ceo.lastReviewAt ??= Date.now();
+  }
+  ceoFloor(repoId2) {
+    const repo = repoId2 ? this.state.repos.find((r) => r.id === repoId2) : void 0;
+    if (!repo) return null;
+    return { floor: repo.floor, fullName: repo.fullName, clone: this.backend.mainDir(repo.fullName), mission: repo.mission, backlog: this.repoRt.get(repo.id)?.issues.length ?? 0 };
+  }
+  ceoInfo() {
+    const c = this.state.ceo;
+    const view = (j) => ({ kind: j.kind, label: jobLabel(j, this.ceoFloor(j.repoId)) });
+    const min = this.state.settings.ceoHeartbeatMin;
+    return {
+      queue: c.queue.map(view),
+      job: c.job ? view(c.job) : null,
+      lastReviewAt: c.lastReviewAt,
+      nextReviewAt: min > 0 && c.lastReviewAt ? c.lastReviewAt + min * 6e4 : null
+    };
+  }
+  emitCeo() {
+    this.broadcast({ type: "ceo", ceo: this.ceoInfo() });
+  }
+  /** Queue a job for the CEO: one onboarding or plan per floor, one review, and chat messages merge into one reply. */
+  enqueueCeo(job) {
+    const q = this.state.ceo.queue;
+    if (job.kind === "plan" && q.some((j) => j.kind === "onboard" && j.repoId === job.repoId)) return;
+    const same = q.findIndex((j) => j.kind === job.kind && (job.kind === "review" || job.kind === "chat" || j.repoId === job.repoId));
+    if (same >= 0) q[same] = job.kind === "chat" ? { ...q[same], text: `${q[same].text}
+${job.text}` } : job;
+    else q.push(job);
+    this.emitCeo();
+    this.save();
+    setTimeout(() => this.schedule(), 150);
+  }
+  /** Start the CEO's next job when they're free and a session slot is open. Replies to the manager go first. */
+  startCeoWork() {
+    const a = this.state.agents.find((x) => x.id === CEO_ID);
+    const c = this.state.ceo;
+    if (!a || BUSY.includes(a.status) || c.job || c.queue.length === 0) return;
+    if (this.slotsFull()) return;
+    const rank = { chat: 0, onboard: 1, plan: 1, review: 2 };
+    const ready = (j) => {
+      const rt2 = j.repoId ? this.repoRt.get(j.repoId) : void 0;
+      return !rt2 || rt2.cloneStatus === "error" || rt2.cloneStatus === "ready" && rt2.lastSync != null;
+    };
+    const job = [...c.queue].sort((x, y) => rank[x.kind] - rank[y.kind]).find(ready);
+    if (!job) return;
+    c.queue.splice(c.queue.indexOf(job), 1);
+    const rt = job.repoId ? this.repoRt.get(job.repoId) : void 0;
+    if (job.repoId && (!rt || rt.cloneStatus === "error")) {
+      const repo = this.state.repos.find((r) => r.id === job.repoId);
+      if (repo) this.postMessage("office", `\u26A0\uFE0F ${a.name} couldn't study floor ${repo.floor}: the repository clone failed (${rt?.cloneError ?? "unknown error"}).`);
+      this.emitCeo();
+      this.save();
+      return this.startCeoWork();
+    }
+    void this.runCeoJob(a, job);
+  }
+  async runCeoJob(a, job) {
+    const rt = this.agentRt.get(a.id);
+    const floor = this.ceoFloor(job.repoId);
+    const label = jobLabel(job, floor);
+    this.state.ceo.job = job;
+    Object.assign(a, { status: "working", task: null, issueNumber: null, issueTitle: label, startedAt: Date.now(), endedAt: null, costUsd: 0, turns: 0, lastError: null });
+    this.appendLog(a, [
+      { kind: "system", text: "" },
+      { kind: "system", text: `\u2501\u2501\u2501 ${label} \u2501\u2501\u2501` }
+    ]);
+    if (job.kind === "chat") this.appendLog(a, [{ kind: "manager", text: `\u25B6 Manager: ${job.text}` }]);
+    if (job.kind === "review") {
+      this.state.ceo.lastReviewAt = Date.now();
+      this.state.ceo.lastFingerprint = this.fingerprint();
+    }
+    this.ceoIssues = { filed: 0, repos: /* @__PURE__ */ new Set() };
+    this.emitAgent(a);
+    this.emitCeo();
+    this.save();
+    await fs4.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;
+    rt.session = this.backend.startSession(
+      {
+        cwd: CEO_DIR,
+        prompt: ceoJobPrompt(job, floor),
+        systemAppend: ceoSystemPrompt({
+          name: a.name,
+          company: s.companyName,
+          manager: s.managerName,
+          notesFile: path6.join(CEO_DIR, "NOTES.md"),
+          sessionLimit: s.sessionLimit,
+          teamCap: s.teamCap,
+          hiring: s.hiring
+        }),
+        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
+      },
+      {
+        log: (entries) => this.appendLog(a, entries),
+        tool: (name) => {
+          if (rt.currentTool === name) return;
+          rt.currentTool = name;
+          this.emitAgent(a);
+        },
+        sessionId: (id) => {
+          a.sessionId = id;
+        },
+        browserUrl: () => void 0,
+        screenshot: () => void 0,
+        turn: (text) => this.postMessage("ceo", text),
+        limited: (at) => this.pauseForLimit(at),
+        finished: (result) => this.onCeoFinished(a, result)
+      },
+      ""
+    );
+  }
+  onCeoFinished(a, result) {
+    const rt = this.agentRt.get(a.id);
+    if (!rt) return;
+    rt.session = null;
+    rt.currentTool = null;
+    a.endedAt = Date.now();
+    a.costUsd += result.costUsd;
+    a.turns += result.turns;
+    const job = this.state.ceo.job;
+    this.state.ceo.job = null;
+    if (a.status === "stopped") {
+    } else if (!result.ok) {
+      a.status = "error";
+      a.lastError = result.errors.join("; ") || "Session failed";
+      this.appendLog(a, [{ kind: "error", text: `\u2717 ${a.lastError}` }]);
+      const what = job ? jobLabel(job, this.ceoFloor(job.repoId)).toLowerCase() : "working";
+      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` : "";
+      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);
+    this.emitAgent(a);
+    this.emitCeo();
+    this.save();
+    setTimeout(() => this.schedule(), 300);
+  }
+  /** The manager's phone → the CEO. Injected into a running session, otherwise the CEO picks it up next. */
+  async messageCeo(text) {
+    const t = text.trim().slice(0, 4e3);
+    if (!t) throw new HttpError(400, "Empty message");
+    const a = this.ceo();
+    this.postMessage("manager", t);
+    const rt = this.agentRt.get(a.id);
+    if (rt.session) {
+      this.appendLog(a, [{ kind: "manager", text: `\u25B6 Manager: ${t}` }]);
+      rt.session.send(`Message from the manager (they read your reply on their phone, so keep it short):
+${t}`);
+      return;
+    }
+    this.enqueueCeo({ kind: "chat", text: t, at: Date.now() });
+  }
+  requestReview() {
+    if (this.state.repos.length === 0) throw new HttpError(400, "Connect a repo first: the CEO needs a floor to review.");
+    this.enqueueCeo({ kind: "review", at: Date.now() });
+  }
+  onboardFloor(repoId2) {
+    const repo = this.repo(repoId2);
+    this.enqueueCeo({ kind: "onboard", repoId: repo.id, at: Date.now() });
+  }
+  /** The manager hands the CEO a brief for a floor; the CEO turns it into issues and a team. */
+  planFloor(repoId2, mission) {
+    const repo = this.repo(repoId2);
+    if (typeof mission === "string") {
+      repo.mission = mission.trim().slice(0, 4e3);
+      this.emitRepo(repo);
+    }
+    if (!repo.mission) throw new HttpError(400, "Write a brief first: what should this floor build?");
+    this.enqueueCeo({ kind: "plan", repoId: repo.id, at: Date.now() });
+  }
+  /** Everything the heartbeat cares about. When it hasn't changed since the last review, the review is skipped. */
+  fingerprint() {
+    const data = {
+      repos: this.state.repos.map((r) => {
+        const rt = this.repoRt.get(r.id);
+        return [r.id, r.mission, r.summary, rt?.issues.map((i) => i.number), rt?.pulls.filter((p) => p.state === "OPEN").map((p) => p.number)];
+      }),
+      agents: this.state.agents.filter((a) => a.role !== "ceo").map((a) => [a.id, FREE.includes(a.status) ? "free" : a.status]),
+      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");
+  }
+  maybeHeartbeat() {
+    const min = this.state.settings.ceoHeartbeatMin;
+    const c = this.state.ceo;
+    if (!min || this.state.repos.length === 0 || c.job?.kind === "review" || c.queue.some((j) => j.kind === "review")) return;
+    if (Date.now() < (c.lastReviewAt ?? 0) + min * 6e4) return;
+    if (this.fingerprint() === c.lastFingerprint) {
+      c.lastReviewAt = Date.now();
+      this.emitCeo();
+      this.save();
+      return;
+    }
+    this.enqueueCeo({ kind: "review", at: Date.now() });
+  }
+  // ---------- the phone ----------
+  postMessage(from, text, requestId) {
+    const m = { id: this.messageSeq++, from, text: text.trim().slice(0, 6e3), at: Date.now(), ...requestId ? { requestId } : {} };
+    this.state.messages.push(m);
+    if (this.state.messages.length > KEEP_MESSAGES) this.state.messages.splice(0, this.state.messages.length - KEEP_MESSAGES);
+    this.broadcast({ type: "message", message: m });
+    this.save();
+    return m;
+  }
+  markPhoneRead(at) {
+    const t = Math.min(Number(at) || Date.now(), Date.now());
+    if (t <= this.state.phoneReadAt) return;
+    this.state.phoneReadAt = t;
+    this.broadcast({ type: "phoneRead", at: t });
+    this.save();
+  }
+  // ---------- hire and let-go proposals ----------
+  addRequest(req) {
+    this.state.requests.push(req);
+    const decided = this.state.requests.filter((r) => r.status !== "pending");
+    if (decided.length > KEEP_DECIDED_REQUESTS) {
+      const drop = new Set(decided.slice(0, decided.length - KEEP_DECIDED_REQUESTS));
+      this.state.requests = this.state.requests.filter((r) => !drop.has(r));
+    }
+    this.broadcast({ type: "request", request: req });
+    this.save();
+  }
+  decide(req, patch) {
+    Object.assign(req, patch, { decidedAt: Date.now() });
+    this.broadcast({ type: "request", request: req });
+    this.save();
+  }
+  approveRequest(id, overrides = {}, by = "manager") {
+    const req = this.state.requests.find((r) => r.id === id);
+    if (!req) throw new HttpError(404, "That proposal no longer exists");
+    if (req.status !== "pending") throw new HttpError(409, `That proposal was already ${req.status}`);
+    const repo = this.repo(req.repoId);
+    if (req.kind === "hire") {
+      const name = overrides.name?.trim() || req.name;
+      const agent = this.hireAgent(repo.id, {
+        name,
+        role: req.role,
+        model: overrides.model ?? req.model,
+        effort: overrides.effort ?? req.effort,
+        look: name === req.name ? req.look : void 0,
+        title: req.title,
+        specialty: req.specialty,
+        brief: req.brief,
+        hiredBy: "ceo",
+        appearance: { color: req.color, hair: req.hair, skin: req.skin }
+      });
+      req.agentId = agent.id;
+      req.name = agent.name;
+      this.decide(req, { status: "approved", note: "", decidedBy: by });
+      this.postMessage(
+        "office",
+        by === "auto" ? `\u{1F916} Auto-approved: ${agent.name} joined floor ${repo.floor} as ${req.title}.` : `\u2705 You hired ${agent.name} as ${req.title} on floor ${repo.floor}.`,
+        req.id
+      );
+      this.toast("success", `${agent.name} (${req.title}) joined floor ${repo.floor}`);
+      return;
+    }
+    const a = req.agentId ? this.state.agents.find((x) => x.id === req.agentId) : void 0;
+    this.decide(req, { status: "approved", note: a ? "" : "They had already left.", decidedBy: by });
+    if (a) {
+      try {
+        this.fireAgent(a.id);
+      } catch (err) {
+        this.decide(req, { status: "pending", note: "", decidedBy: null });
+        throw err;
+      }
+    }
+    this.postMessage("office", `\u{1F44B} ${req.name} left floor ${repo.floor}${by === "auto" ? " (auto-approved)" : ""}.`, req.id);
+  }
+  rejectRequest(id, note = "") {
+    const req = this.state.requests.find((r) => r.id === id);
+    if (!req) throw new HttpError(404, "That proposal no longer exists");
+    if (req.status !== "pending") throw new HttpError(409, `That proposal was already ${req.status}`);
+    this.decide(req, { status: "rejected", note: note.trim().slice(0, 400), decidedBy: "manager" });
+    const what = req.kind === "hire" ? `${req.name} (${req.title})` : `letting ${req.name} go`;
+    this.postMessage("office", `\u270B You declined ${what}${req.note ? `: "${req.note}"` : "."}`, req.id);
+  }
+  // ---------- the CEO's office tools ----------
+  floorRepo(floor) {
+    const r = this.state.repos.find((x) => x.floor === Number(floor));
+    if (!r) throw new Error(`There is no floor ${floor}. Floors: ${this.state.repos.map((x) => `${x.floor} (${x.fullName})`).join(", ") || "none"}.`);
+    return r;
+  }
+  agentByRef(ref) {
+    const r = String(ref ?? "").trim().toLowerCase();
+    const a = this.state.agents.find((x) => x.id === ref || x.name.toLowerCase() === r);
+    if (!a) throw new Error(`No agent "${ref}". Use the ids from company_status.`);
+    return a;
+  }
+  agentDoing(a) {
+    return !BUSY.includes(a.status) ? null : a.task === "qa" ? `testing PR #${a.prNumber}` : a.task === "fix" ? `fixing PR #${a.prNumber}` : `issue #${a.issueNumber}`;
+  }
+  companyStatus() {
+    const s = this.state.settings;
+    const doing = (a) => this.agentDoing(a);
+    const jobDescription = (brief) => {
+      if (brief.length <= 400) return brief;
+      const mark = `\u2026 (truncated, ${brief.length} chars; see agent_detail)`;
+      return brief.slice(0, 400 - mark.length).trimEnd() + mark;
+    };
+    const floors = [...this.state.repos].sort((x, y) => x.floor - y.floor).map((r) => {
+      const rt = this.repoRt.get(r.id);
+      const open = new Set(rt.issues.map((i) => i.number));
+      return {
+        floor: r.floor,
+        repo: r.fullName,
+        description: r.description,
+        clone: rt.cloneStatus === "ready" ? this.backend.mainDir(r.fullName) : `(not available: clone ${rt.cloneStatus})`,
+        brief: r.mission || null,
+        profile: r.summary || null,
+        qaBrief: r.qaBrief || null,
+        preview: { command: r.preview.command, env: r.preview.env, status: this.previews.view(r).status },
+        autoAssign: r.autoAssign,
+        autoMerge: r.autoMerge,
+        folderSync: rt.folderSync,
+        capacity: {
+          developers: this.state.agents.filter((a) => a.repoId === r.id && a.role === "dev").length,
+          developersFree: this.available(r, "dev").length,
+          issuesReadyToStart: this.readyIssues(r).length,
+          issuesWaitingOnOthers: rt.issues.filter((i) => blockers(i.body, open).length > 0).length,
+          longestDependencyChain: Math.max(0, ...[...holdUps(rt.issues).values()].map((w) => w.chain))
+        },
+        team: this.state.agents.filter((a) => a.repoId === r.id).map((a) => ({
+          id: a.id,
+          name: a.name,
+          role: a.role,
+          title: a.title || (a.role === "qa" ? "QA tester" : "Developer"),
+          specialty: a.specialty || null,
+          status: a.status,
+          doing: doing(a),
+          hiredBy: a.hiredBy,
+          jobDescription: a.brief ? jobDescription(a.brief) : null
+        })),
+        backlog: rt.issues.map((i) => ({
+          number: i.number,
+          title: i.title,
+          specialty: issueSpecialty(i.labels) || null,
+          waitsFor: blockers(i.body, open),
+          inProgress: this.issueTaken(r, i.number)
+        })),
+        pullRequests: rt.pulls.filter((p) => p.state === "OPEN").map((p) => {
+          const q = this.state.qa.find((x) => x.repoId === r.id && x.prNumber === p.number);
+          return { number: p.number, title: p.title, qa: q ? `${q.status}${q.round > 1 ? ` (round ${q.round})` : ""}` : "not tested", merge: q?.mergeNote ?? null, checks: p.checks };
+        }),
+        mergedRecently: rt.pulls.filter((p) => p.state === "MERGED").map((p) => `#${p.number} ${p.title}`)
+      };
+    });
+    const req = (r) => ({
+      id: r.id,
+      kind: r.kind,
+      floor: this.state.repos.find((x) => x.id === r.repoId)?.floor ?? null,
+      role: r.role,
+      name: r.name,
+      title: r.title,
+      specialty: r.specialty || null,
+      reason: r.reason,
+      status: r.status,
+      managerNote: r.note || null
+    });
+    return JSON.stringify(
+      {
+        company: {
+          ceo: this.ceo().name,
+          hiring: s.hiring === "auto" ? `auto-approved while a floor has fewer than ${s.teamCap} people` : "the manager approves every proposal",
+          teamCap: s.teamCap,
+          sessionLimit: s.sessionLimit || "none",
+          sessionsRunning: this.running(),
+          deskLimits: { dev: MAX_DESKS.dev, qa: MAX_DESKS.qa }
+        },
+        floors,
+        pendingProposals: this.state.requests.filter((r) => r.status === "pending").map(req),
+        recentDecisions: this.state.requests.filter((r) => r.status !== "pending").slice(-10).map(req)
+      },
+      null,
+      1
+    );
+  }
+  agentDetail(x) {
+    const a = this.agentByRef(x.agent_id);
+    const repo = this.state.repos.find((r) => r.id === a.repoId);
+    const ceo = a.role === "ceo";
+    return JSON.stringify(
+      {
+        id: a.id,
+        name: a.name,
+        floor: repo?.floor ?? null,
+        role: a.role,
+        title: a.title || (a.role === "qa" ? "QA tester" : a.role === "dev" ? "Developer" : "CEO"),
+        specialty: a.specialty || null,
+        status: a.status,
+        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),
+        effort: a.effort || (ceo ? CEO_EFFORT : this.state.settings.defaultEffort),
+        hiredBy: a.hiredBy,
+        jobDescription: a.brief || null
+      },
+      null,
+      1
+    );
+  }
+  setFloorProfile(x) {
+    const r = this.floorRepo(x.floor);
+    const preview = parsePreviewPatch(x.preview_command, x.preview_env);
+    if (x.summary !== void 0) r.summary = String(x.summary).trim().slice(0, 140);
+    if (x.qa_brief !== void 0) r.qaBrief = String(x.qa_brief).trim().slice(0, 2500);
+    r.preview = { ...r.preview, ...preview };
+    if (preview.command === null) void this.previews.refreshDefault(r);
+    this.emitRepo(r);
+    this.save();
+    return `Saved floor ${r.floor}'s profile.`;
+  }
+  updateJob(x) {
+    const a = this.agentByRef(x.agent_id);
+    if (a.role === "ceo") throw new Error("That's you.");
+    this.updateAgent(a.id, { title: x.title, specialty: x.specialty, brief: x.job_description });
+    const title = a.title || (a.role === "qa" ? "QA tester" : "Developer");
+    this.appendLog(a, [{ kind: "system", text: `\u{1FAAA} ${this.ceo().name} updated ${a.name}'s job: ${title}${a.specialty ? ` \xB7 swarm:${a.specialty}` : ""}` }]);
+    return `Updated ${a.name}: ${title}${a.specialty ? ` (specialty ${a.specialty})` : ""}.`;
+  }
+  proposeHire(x) {
+    const repo = this.floorRepo(x.floor);
+    const role = x.role === "qa" ? "qa" : "dev";
+    const title = String(x.title ?? "").trim().slice(0, 60);
+    if (!title) throw new Error("A hire needs a job title.");
+    const specialty = specialtySlug(x.specialty);
+    const pending2 = this.state.requests.filter((r) => r.status === "pending");
+    if (pending2.length >= MAX_PENDING_REQUESTS) throw new Error(`${pending2.length} proposals are already waiting for the manager. Wait for their decisions first.`);
+    const dup = pending2.find((r) => r.kind === "hire" && r.repoId === repo.id && r.role === role && r.specialty === specialty);
+    if (dup) throw new Error(`${dup.name} (${dup.title}) is already proposed for floor ${repo.floor} with that specialty.`);
+    const seated = this.state.agents.filter((a) => a.repoId === repo.id && a.role === role).length;
+    const waiting = pending2.filter((r) => r.kind === "hire" && r.repoId === repo.id && r.role === role).length;
+    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(),
+      kind: "hire",
+      repoId: repo.id,
+      role,
+      agentId: null,
+      name,
+      title,
+      specialty,
+      brief: String(x.job_description ?? "").trim().slice(0, 2500),
+      reason: String(x.reason ?? "").trim().slice(0, 600),
+      model: String(x.model ?? "").trim(),
+      effort: EFFORTS.includes(x.effort) ? x.effort : "",
+      look: lookFor(name),
+      color: pick(SHIRTS),
+      hair: pick(HAIR),
+      skin: pick(SKIN),
+      status: "pending",
+      note: "",
+      createdAt: Date.now(),
+      decidedAt: null,
+      decidedBy: null
+    };
+    this.addRequest(req);
+    const s = this.state.settings;
+    if (s.hiring === "auto" && this.state.agents.filter((a) => a.repoId === repo.id).length < s.teamCap) {
+      this.approveRequest(req.id, {}, "auto");
+      return `Hired ${req.name} as ${title} on floor ${repo.floor} (auto-approved; agent id ${req.agentId}).`;
+    }
+    this.postMessage("ceo", `\u{1F4C4} New candidate for floor ${repo.floor}: ${name}, ${title}. ${req.reason}`, req.id);
+    return `Proposed ${name} as ${title} on floor ${repo.floor}. The manager will approve or decline (request ${req.id}).`;
+  }
+  proposeLetGo(x) {
+    const a = this.agentByRef(x.agent_id);
+    if (a.role === "ceo") throw new Error("You can't let yourself go.");
+    const repo = this.repo(a.repoId);
+    if (a.role === "qa" && this.state.agents.filter((y) => y.repoId === repo.id && y.role === "qa").length <= 1) {
+      throw new Error(`${a.name} is floor ${repo.floor}'s only QA tester, and every floor keeps one.`);
+    }
+    const pending2 = this.state.requests.filter((r) => r.status === "pending");
+    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(),
+      kind: "let-go",
+      repoId: repo.id,
+      role: a.role,
+      agentId: a.id,
+      name: a.name,
+      title: a.title || (a.role === "qa" ? "QA tester" : "Developer"),
+      specialty: a.specialty,
+      brief: a.brief,
+      reason: String(x.reason ?? "").trim().slice(0, 600),
+      model: a.model,
+      effort: a.effort,
+      look: a.look,
+      color: a.color,
+      hair: a.hair,
+      skin: a.skin,
+      status: "pending",
+      note: "",
+      createdAt: Date.now(),
+      decidedAt: null,
+      decidedBy: null
+    };
+    this.addRequest(req);
+    if (this.state.settings.hiring === "auto" && FREE.includes(a.status)) {
+      this.approveRequest(req.id, {}, "auto");
+      return `Let ${a.name} go (auto-approved).`;
+    }
+    this.postMessage("ceo", `\u{1F44B} I suggest letting ${a.name} (${req.title}, floor ${repo.floor}) go. ${req.reason}`, req.id);
+    return `Proposed letting ${a.name} go. The manager will decide (request ${req.id}).`;
+  }
+  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.`);
+    const title = String(x.title ?? "").trim().slice(0, 120);
+    if (!title) throw new Error("An issue needs a title.");
+    const slug = specialtySlug(x.specialty);
+    const body = `${String(x.body ?? "").trim()}
+
+---
+_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);
+    return `Filed #${n} on floor ${repo.floor}: ${title}${slug ? ` (routed to ${slug})` : ""}.`;
+  }
+};
+
+// server/index.ts
+var swarm = new Swarm(DEMO ? createDemoBackend() : realBackend);
+await swarm.init();
+var app = express();
+app.use(express.json({ limit: "1mb" }));
+var route = (fn) => async (req, res, next) => {
+  try {
+    const out = await fn(req, res);
+    if (!res.headersSent) res.json(out ?? { ok: true });
+  } catch (err) {
+    next(err);
+  }
+};
+var num = (v) => {
+  const n = Number(v);
+  if (!Number.isInteger(n) || n <= 0) throw new HttpError(400, `Invalid number: ${v}`);
+  return n;
+};
+var str = (v) => typeof v === "string" ? v : "";
+var repoId = (req) => decodeURIComponent(String(req.params.repo));
+app.get("/api/state", route(() => swarm.snapshot()));
+app.get("/api/github/repos", route((req) => swarm.listGithubRepos(str(req.query.owner) || void 0)));
+var floorOptions = (req) => ({ mission: str(req.body.mission), autoAssign: req.body.autoAssign === true });
+app.post("/api/repos", route((req) => swarm.connectRepo(str(req.body.fullName).trim(), floorOptions(req))));
+app.get("/api/folders", route((req) => swarm.listProjectFolders(str(req.query.dir) || void 0)));
+app.post("/api/folders/connect", route((req) => swarm.connectFolder(str(req.body.path), floorOptions(req))));
+app.post(
+  "/api/folders/publish",
+  route(
+    (req) => swarm.publishFolder(str(req.body.path), {
+      ...floorOptions(req),
+      name: str(req.body.name) || void 0,
+      visibility: req.body.visibility === "public" ? "public" : "private",
+      description: str(req.body.description)
+    })
+  )
+);
+app.post(
+  "/api/setup",
+  route(
+    (req) => swarm.setup({
+      managerName: str(req.body.managerName),
+      companyName: str(req.body.companyName),
+      hiring: str(req.body.hiring),
+      ceoName: str(req.body.ceoName),
+      ceoLook: str(req.body.ceoLook),
+      ceoColor: str(req.body.ceoColor)
+    })
+  )
+);
+app.post(
+  "/api/repos/new",
+  route(
+    (req) => swarm.createRepo(str(req.body.name).trim(), {
+      ...floorOptions(req),
+      description: str(req.body.description),
+      visibility: req.body.visibility === "public" ? "public" : "private",
+      owner: str(req.body.owner).trim() || void 0
+    })
+  )
+);
+app.patch("/api/repos/:repo", route((req) => swarm.updateRepo(repoId(req), req.body ?? {})));
+app.delete("/api/repos/:repo", route((req) => swarm.disconnectRepo(repoId(req))));
+app.post("/api/repos/:repo/sync", route((req) => swarm.syncRepo(repoId(req))));
+app.post("/api/repos/:repo/sync-folder", route((req) => swarm.syncFolderNow(repoId(req))));
+app.post(
+  "/api/repos/:repo/issues",
+  route(async (req) => ({
+    number: await swarm.createIssue(repoId(req), str(req.body.title), str(req.body.body), str(req.body.assignTo) || void 0, str(req.body.specialty) || void 0)
+  }))
+);
+app.post("/api/repos/:repo/plan", route((req) => swarm.planFloor(repoId(req), typeof req.body?.mission === "string" ? req.body.mission : void 0)));
+app.post("/api/repos/:repo/onboard", route((req) => swarm.onboardFloor(repoId(req))));
+app.post(
+  "/api/repos/:repo/preview",
+  route((req) => {
+    const pr = req.body?.pr;
+    if (pr !== void 0 && pr !== null && (typeof pr !== "number" || !Number.isInteger(pr) || pr <= 0)) throw new HttpError(400, "pr must be a positive integer");
+    return swarm.startPreview(repoId(req), pr ?? null);
+  })
+);
+app.delete("/api/repos/:repo/preview", route((req) => swarm.stopPreview(repoId(req))));
+app.post("/api/repos/:repo/pulls/:n/merge", route((req) => swarm.mergePull(repoId(req), num(req.params.n), req.body?.method ?? "squash")));
+app.post("/api/repos/:repo/pulls/:n/close", route((req) => swarm.closePull(repoId(req), num(req.params.n))));
+app.post("/api/repos/:repo/pulls/:n/qa", route((req) => swarm.sendToQa(repoId(req), num(req.params.n))));
+app.post(
+  "/api/repos/:repo/agents",
+  route(
+    (req) => swarm.hireAgent(repoId(req), {
+      name: str(req.body.name),
+      model: str(req.body.model),
+      effort: str(req.body.effort),
+      role: str(req.body.role),
+      look: str(req.body.look),
+      title: str(req.body.title),
+      specialty: str(req.body.specialty),
+      brief: str(req.body.brief)
+    })
+  )
+);
+app.patch("/api/agents/:id", route((req) => swarm.updateAgent(String(req.params.id), req.body ?? {})));
+app.delete("/api/agents/:id", route((req) => swarm.fireAgent(String(req.params.id))));
+app.post("/api/agents/:id/assign", route((req) => swarm.assign(String(req.params.id), num(req.body.issueNumber), str(req.body.note) || void 0)));
+app.post("/api/agents/:id/stop", route((req) => swarm.stopAgent(String(req.params.id))));
+app.post("/api/agents/:id/reset", route((req) => swarm.resetAgent(String(req.params.id))));
+app.post("/api/agents/:id/message", route((req) => swarm.message(String(req.params.id), str(req.body.text))));
+app.get("/api/agents/:id/screen", (req, res) => {
+  const shot = swarm.screenshot(String(req.params.id));
+  if (!shot) return void res.status(404).end();
+  res.setHeader("Content-Type", shot.mime);
+  res.setHeader("Cache-Control", "no-store");
+  res.end(shot.data);
+});
+app.patch("/api/settings", route((req) => swarm.updateSettings(req.body ?? {})));
+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())));
+app.post(
+  "/api/requests/:id/approve",
+  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)) {
+  app.use(express.static(dist));
+  app.get(/^(?!\/api).*/, (_req, res) => res.sendFile(path7.join(dist, "index.html")));
+}
+app.use((err, _req, res, _next) => {
+  const parserStatus = err?.status;
+  const status = err instanceof HttpError ? err.status : typeof parserStatus === "number" && parserStatus >= 400 && parserStatus < 500 ? parserStatus : 500;
+  const message = err instanceof Error ? err.message : String(err);
+  if (status >= 500) console.error(err);
+  res.status(status).json({ error: message });
+});
+var server = http2.createServer(app);
+var wss = new WebSocketServer({ server, path: "/ws" });
+wss.on("connection", (ws) => swarm.addClient(ws));
+server.listen(PORT, "127.0.0.1", () => {
+  console.log(`
+  \u{1F3E2} cubefarm on http://localhost:${PORT}${DEMO ? "  (DEMO MODE: fake GitHub + fake agents)" : ""}`);
+  console.log(`     state: ${STATE_FILE}`);
+  console.log(`     workspaces: ${WORKSPACE_ROOT}
+`);
+});
+var closing = false;
+var shutdown = (signal) => {
+  if (closing) return;
+  closing = true;
+  console.log(`
+  ${signal}: stopping floor previews\u2026`);
+  const force = setTimeout(() => process.exit(0), 15e3);
+  void swarm.shutdown().catch((err) => console.error(err)).finally(() => {
+    clearTimeout(force);
+    process.exit(0);
+  });
+};
+process.once("SIGINT", () => shutdown("SIGINT"));
+process.once("SIGTERM", () => shutdown("SIGTERM"));
+//# sourceMappingURL=index.js.map