@setupsworks/office 0.0.0-stage → 0.7.5

package/dist-server/main.mjs

@@ -0,0 +1,4068 @@
+// server/main.ts
+import { existsSync as existsSync13 } from "node:fs";
+import { dirname as dirname3, join as join13, resolve as resolve4 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/data/types.ts
+var SERVICE_KEYS = ["anthropic", "openai", "github", "google", "groq", "mistral", "openrouter", "xai", "nebius", "copilot", "cursor", "devin", "droid"];
+var HOST_TERMINAL = "shell:@host";
+
+// src/data/names.ts
+var LEAD_NAME = "Michael";
+var WORKER_NAMES = ["Dwight", "Jim", "Pam", "Angela", "Kevin", "Oscar", "Stanley", "Phyllis", "Andy", "Creed", "Meredith"];
+var OFFICE_NAME_MAX = 19;
+
+// src/data/stack.ts
+var STACK_CATEGORIES = [
+  { id: "auth", label: "Auth", hint: "Sign-in and users" },
+  { id: "payments", label: "Payments", hint: "Billing and subscriptions" },
+  { id: "database", label: "Database", hint: "Data and branches" },
+  { id: "analytics", label: "Analytics", hint: "Product analytics" },
+  { id: "security", label: "Security", hint: "Bots, rate limits, prompt injection" }
+];
+var fw = (id, name, docs, skills = [], verify = false) => ({
+  id,
+  name,
+  category: "framework",
+  docs,
+  api: [],
+  keys: [],
+  skills,
+  note: `${name} app`,
+  verify
+});
+var REACT = { source: "vercel-labs/agent-skills", skills: ["vercel-react-best-practices", "vercel-composition-patterns"] };
+var STACK_CATALOG = [
+  // ---------------------------------------------------------------- frameworks
+  fw("nextjs", "Next.js", ["nextjs.org"], [{ source: "vercel/next.js", skills: ["next-dev-loop"] }, REACT]),
+  fw("react-vite", "React (Vite)", ["react.dev", "vite.dev"], [REACT]),
+  fw("express", "Express", ["expressjs.com"]),
+  fw("hono", "Hono", ["hono.dev"]),
+  fw("nestjs", "NestJS", ["docs.nestjs.com"]),
+  fw("react-router", "React Router", ["reactrouter.com"], [REACT]),
+  fw("astro", "Astro", ["docs.astro.build"]),
+  fw("sveltekit", "SvelteKit", ["svelte.dev"]),
+  fw("nuxt", "Nuxt", ["nuxt.com"]),
+  // ---------------------------------------------------------------- auth
+  {
+    id: "clerk",
+    name: "Clerk",
+    category: "auth",
+    docs: ["clerk.com"],
+    api: ["api.clerk.com", "*.clerk.accounts.dev"],
+    keys: ["NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY", "CLERK_SECRET_KEY"],
+    skills: [{ source: "clerk/skills", skills: ["clerk", "clerk-setup", "clerk-nextjs-patterns", "clerk-react-patterns", "clerk-custom-ui", "clerk-backend-api", "clerk-webhooks", "clerk-orgs"] }],
+    note: "Auth uses Clerk"
+  },
+  {
+    id: "better-auth",
+    name: "Better Auth",
+    category: "auth",
+    docs: ["better-auth.com"],
+    api: [],
+    keys: ["BETTER_AUTH_SECRET", "BETTER_AUTH_URL"],
+    skills: [],
+    note: "Auth uses Better Auth (self-hosted)",
+    verify: true
+  },
+  {
+    id: "auth0",
+    name: "Auth0",
+    category: "auth",
+    docs: ["auth0.com"],
+    api: ["*.auth0.com"],
+    keys: ["AUTH0_DOMAIN", "AUTH0_CLIENT_ID", "AUTH0_CLIENT_SECRET", "AUTH0_SECRET"],
+    skills: [],
+    note: "Auth uses Auth0",
+    verify: true
+  },
+  {
+    id: "supabase-auth",
+    name: "Supabase Auth",
+    category: "auth",
+    docs: ["supabase.com"],
+    api: ["*.supabase.co"],
+    keys: ["NEXT_PUBLIC_SUPABASE_URL", "NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY"],
+    skills: [{ source: "supabase/agent-skills", skills: ["supabase"] }],
+    note: "Auth uses Supabase Auth",
+    verify: true
+  },
+  // ---------------------------------------------------------------- payments
+  {
+    id: "clerk-billing",
+    name: "Clerk Billing",
+    category: "payments",
+    docs: ["clerk.com"],
+    api: ["api.clerk.com"],
+    keys: ["CLERK_SECRET_KEY"],
+    skills: [{ source: "clerk/skills", skills: ["clerk-billing", "clerk-setup"] }],
+    note: "Subscriptions use Clerk Billing"
+  },
+  {
+    id: "stripe",
+    name: "Stripe",
+    category: "payments",
+    docs: ["docs.stripe.com"],
+    api: ["api.stripe.com"],
+    keys: ["STRIPE_SECRET_KEY", "STRIPE_WEBHOOK_SECRET", "NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY"],
+    skills: [{ source: "stripe/ai", skills: ["stripe-best-practices", "stripe-docs"] }],
+    mcp: "https://mcp.stripe.com",
+    note: "Payments use Stripe (test mode)"
+  },
+  {
+    id: "polar",
+    name: "Polar",
+    category: "payments",
+    docs: ["docs.polar.sh"],
+    api: ["api.polar.sh", "sandbox-api.polar.sh"],
+    keys: ["POLAR_ACCESS_TOKEN", "POLAR_WEBHOOK_SECRET"],
+    skills: [],
+    note: "Payments use Polar (sandbox)",
+    verify: true
+  },
+  // ---------------------------------------------------------------- database
+  {
+    id: "instacloud",
+    name: "InstaCloud",
+    category: "database",
+    docs: ["instacloud.com", "agents.instacloud.com"],
+    api: ["api.instacloud.com"],
+    keys: ["DATABASE_URL"],
+    skills: [{ source: "InsForge/instacloud-skills", skills: ["insta"] }],
+    mcp: "https://mcp.instacloud.com/mcp",
+    note: "Database and branch environments use InstaCloud (the insta CLI)"
+  },
+  {
+    id: "neon",
+    name: "Neon",
+    category: "database",
+    docs: ["neon.com"],
+    api: ["console.neon.tech", "*.neon.tech"],
+    keys: ["DATABASE_URL"],
+    skills: [],
+    note: "Database is Neon Postgres",
+    verify: true
+  },
+  {
+    id: "supabase",
+    name: "Supabase",
+    category: "database",
+    docs: ["supabase.com"],
+    api: ["*.supabase.co"],
+    keys: ["NEXT_PUBLIC_SUPABASE_URL", "NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY", "SUPABASE_SECRET_KEY", "DATABASE_URL"],
+    skills: [{ source: "supabase/agent-skills", skills: ["supabase", "supabase-postgres-best-practices"] }],
+    // Scoped to one project and read-only: without project_ref the MCP reaches every project in the account.
+    mcp: "https://mcp.supabase.com/mcp",
+    mcpParam: { name: "project_ref", hint: "Tip: add ?project_ref=<id> to limit it to one project (Project Settings \u2192 General). Without it, the agent can reach every project in your account." },
+    note: "Database is Supabase Postgres",
+    verify: true
+  },
+  {
+    id: "prisma-postgres",
+    name: "Prisma Postgres",
+    category: "database",
+    docs: ["prisma.io"],
+    api: ["db.prisma.io"],
+    keys: ["DATABASE_URL"],
+    skills: [],
+    note: "Database is Prisma Postgres with Prisma ORM",
+    verify: true
+  },
+  // ---------------------------------------------------------------- analytics
+  {
+    id: "posthog",
+    name: "PostHog",
+    category: "analytics",
+    docs: ["posthog.com"],
+    api: ["us.i.posthog.com", "eu.i.posthog.com", "us-assets.i.posthog.com"],
+    keys: ["NEXT_PUBLIC_POSTHOG_KEY", "NEXT_PUBLIC_POSTHOG_HOST"],
+    skills: [{ source: "PostHog/skills", skills: ["instrument-integration", "instrument-product-analytics", "instrument-llm-analytics"] }],
+    mcp: "https://mcp.posthog.com",
+    note: "Analytics use PostHog"
+  },
+  {
+    id: "plausible",
+    name: "Plausible",
+    category: "analytics",
+    docs: ["plausible.io"],
+    api: ["plausible.io"],
+    keys: [],
+    skills: [],
+    note: "Analytics use Plausible",
+    verify: true
+  },
+  {
+    id: "vercel-analytics",
+    name: "Vercel Analytics",
+    category: "analytics",
+    docs: ["vercel.com"],
+    api: [],
+    keys: [],
+    skills: [],
+    note: "Analytics use Vercel Web Analytics",
+    verify: true
+  },
+  // ---------------------------------------------------------------- security
+  {
+    id: "arcjet",
+    name: "Arcjet",
+    category: "security",
+    docs: ["docs.arcjet.com"],
+    api: ["decide.arcjet.com"],
+    keys: ["ARCJET_KEY"],
+    skills: [{ source: "arcjet/skills", skills: ["arcjet"] }],
+    note: "Bot protection, rate limiting and prompt-injection checks use Arcjet"
+  },
+  {
+    id: "upstash-ratelimit",
+    name: "Upstash Ratelimit",
+    category: "security",
+    docs: ["upstash.com"],
+    api: ["*.upstash.io"],
+    keys: ["UPSTASH_REDIS_REST_URL", "UPSTASH_REDIS_REST_TOKEN"],
+    skills: [],
+    note: "Rate limiting uses Upstash Ratelimit",
+    verify: true
+  }
+];
+var stackTool = (id) => STACK_CATALOG.find((t2) => t2.id === id);
+function chosenTools(stack) {
+  if (!stack) return [];
+  const ids = [...stack.frameworks.map((f) => f.id), ...Object.values(stack.tools).map((c) => c?.id)];
+  return [...new Set(ids)].flatMap((id) => id ? [stackTool(id)].filter((t2) => !!t2) : []);
+}
+var choiceName = (c) => c.id === "other" ? c.name || "Other" : stackTool(c.id)?.name ?? c.id;
+function stackRoleMd(stack) {
+  if (!stack || !stack.frameworks.length && !Object.values(stack.tools).some(Boolean)) return "";
+  const lines = ["## Stack"];
+  for (const f of stack.frameworks) lines.push(`- ${choiceName(f)}${f.where ? ` in \`${f.where}\`` : ""}${f.id === "other" && f.docsUrl ? ` (docs: ${f.docsUrl})` : ""}`);
+  for (const cat of STACK_CATEGORIES) {
+    const c = stack.tools[cat.id];
+    if (!c) continue;
+    const t2 = stackTool(c.id);
+    const docs = c.id === "other" ? c.docsUrl : t2?.docs[0];
+    lines.push(`- ${t2 ? t2.note : `${cat.label}: ${choiceName(c)}`}${docs ? ` (docs: ${docs})` : ""}`);
+  }
+  lines.push(
+    "",
+    "Use the installed agent skills for these tools before writing integration code, and follow their current docs rather than memory.",
+    "Secrets come from environment variables; never hard-code or commit them."
+  );
+  return lines.join("\n");
+}
+function stackSkills(stack) {
+  const bySource = /* @__PURE__ */ new Map();
+  for (const t2 of chosenTools(stack)) for (const spec of t2.skills) for (const name of spec.skills) bySource.set(spec.source, (bySource.get(spec.source) ?? /* @__PURE__ */ new Set()).add(name));
+  return [...bySource].map(([source, names]) => ({ source, skills: [...names].sort() })).sort((a, b) => a.source.localeCompare(b.source));
+}
+
+// server/access.ts
+var DOMAIN = /^(\*\.)?([a-z0-9-]+\.)+[a-z]{2,}(:\d+)?$/;
+function cleanDomain(raw) {
+  let v = raw.trim().toLowerCase();
+  try {
+    if (/^[a-z]+:\/\//.test(v)) v = new URL(v).host;
+  } catch {
+    return null;
+  }
+  v = v.replace(/\/.*$/, "");
+  return DOMAIN.test(v) ? v : null;
+}
+var seq = 0;
+function requestAccess(hub, agentId, rawDomain, reason) {
+  const agent = hub.cfg(agentId);
+  if (!agent) throw new Error("Unknown agent.");
+  if (agent.mode !== "sandbox") return "You run in Local mode, outside a sandbox: HQ doesn't restrict your network. If a request fails, it isn't a sandbox block.";
+  const domain = cleanDomain(rawDomain);
+  if (!domain) throw new Error(`"${rawDomain}" isn't a domain. Pass just the host, like docs.example.com.`);
+  if (agent.sandbox.allow.includes(domain))
+    return `${domain} is already allowed for your sandbox. If it still fails, the problem is something else (a typo, the site is down, or a different domain it redirects to).`;
+  const open = hub.snap.accessRequests?.find((r) => r.agentId === agentId && r.domain === domain && r.status === "pending");
+  if (open) return `You already asked for ${domain}; the user hasn't answered yet. Continue with other work; HQ will tell you.`;
+  const req = { id: `ar${Date.now().toString(36)}${++seq}`, agentId, domain, reason: reason.trim().slice(0, 300) || "No reason given", at: (/* @__PURE__ */ new Date()).toISOString(), status: "pending" };
+  hub.holdForAccess(agentId);
+  const all = [req, ...hub.snap.accessRequests ?? []];
+  hub.snap.accessRequests = [...all.filter((r) => r.status === "pending"), ...all.filter((r) => r.status !== "pending").slice(0, 50)];
+  hub.emit({ type: "access.updated", request: { ...req } });
+  hub.setStatus(agentId, { state: "needs-input", note: `Asking: access to ${domain}` });
+  hub.activity("agent.needs-input", agentId, `${agent.name} needs you: access to ${domain}`);
+  return `Asked the user to allow ${domain}. Continue with other work if you can; HQ will message you as soon as they answer. Don't work around the block meanwhile.`;
+}
+var queue = Promise.resolve();
+function resolveAccess(hub, sbx, planner, requestId, decision) {
+  const next = queue.then(() => answer(hub, sbx, planner, requestId, decision));
+  queue = next.catch(() => {
+  });
+  return next;
+}
+async function answer(hub, sbx, planner, requestId, decision) {
+  const req = hub.snap.accessRequests?.find((r) => r.id === requestId);
+  if (!req || req.status !== "pending") return;
+  const who = hub.name(req.agentId);
+  const settle = (r, status) => {
+    r.status = status;
+    hub.emit({ type: "access.updated", request: { ...r } });
+    hub.accessAnswered(r.agentId);
+  };
+  if (decision === "deny") {
+    settle(req, "denied");
+    hub.activity("config", req.agentId, `You denied ${who} access to ${req.domain}`);
+    planner.notify(req.agentId, `The user denied access to ${req.domain}. Continue without it. If you can't, say why in your reply${hub.cfg(req.agentId)?.isLead ? "" : " and call set_my_status blocked with the reason"}.`);
+    return;
+  }
+  const ids = decision === "everyone" ? hub.snap.config.team.filter((a) => a.mode === "sandbox").map((a) => a.id) : [req.agentId];
+  const added = [];
+  for (const id of ids) {
+    const a = hub.cfg(id);
+    if (a && !a.sandbox.allow.includes(req.domain)) {
+      a.sandbox.allow = [...a.sandbox.allow, req.domain];
+      added.push(id);
+    }
+  }
+  hub.configChanged();
+  let failure = null;
+  const results = await Promise.allSettled(ids.map((id) => sbx.syncRules(id)));
+  const thrown = results.find((r) => r.status === "rejected");
+  const bad = ids.find((id) => sbx.state.agents[id]?.syncError?.includes(req.domain));
+  if (thrown) failure = thrown.reason instanceof Error ? thrown.reason.message : String(thrown.reason);
+  else if (bad) failure = `${hub.name(bad)}: ${sbx.state.agents[bad]?.syncError}`;
+  if (failure) {
+    for (const id of added) {
+      const a = hub.cfg(id);
+      if (a) a.sandbox.allow = a.sandbox.allow.filter((d) => d !== req.domain);
+    }
+    hub.configChanged();
+    await Promise.all(added.map((id) => sbx.syncRules(id).catch(() => {
+    })));
+    hub.activity("config", req.agentId, `Couldn't allow ${req.domain} (${failure.slice(0, 160)}). The request is still open: try again or deny it.`);
+    return;
+  }
+  settle(req, "allowed");
+  hub.activity("config", req.agentId, `You allowed ${req.domain} for ${decision === "everyone" ? "every agent" : who}`);
+  planner.notify(req.agentId, `The user allowed ${req.domain} for your sandbox. Try the request again.`);
+  if (decision === "everyone") {
+    for (const other of hub.snap.accessRequests ?? [])
+      if (other.status === "pending" && other.domain === req.domain && other.id !== req.id) {
+        settle(other, "allowed");
+        planner.notify(other.agentId, `The user allowed ${req.domain} for your sandbox. Try the request again.`);
+      }
+  }
+}
+
+// server/skills.ts
+import { cpSync, existsSync as existsSync2, lstatSync as lstatSync3, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync3, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+
+// server/lib/agentFs.ts
+import { lstatSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+var lstat = (p) => {
+  try {
+    return lstatSync(p);
+  } catch {
+    return null;
+  }
+};
+function agentPath(root, rel) {
+  const abs = resolve(root, rel);
+  const inside = relative(resolve(root), abs);
+  if (!inside || inside.startsWith("..") || resolve(root, inside) !== abs) throw new Error(`${rel} is outside the agent's folder`);
+  let cur = resolve(root);
+  for (const part of inside.split(sep).slice(0, -1)) {
+    cur = join(cur, part);
+    if (lstat(cur)?.isSymbolicLink()) throw new Error(`${relative(root, cur)} in ${root} is a symlink; HQ won't write through it. Remove it and start again.`);
+  }
+  return abs;
+}
+function agentMkdir(root, rel) {
+  const abs = agentPath(root, join(rel, "x"));
+  mkdirSync(dirname(abs), { recursive: true });
+  agentPath(root, join(rel, "x"));
+}
+function agentWrite(root, rel, data, opts) {
+  const abs = agentPath(root, rel);
+  mkdirSync(dirname(abs), { recursive: true });
+  agentPath(root, rel);
+  if (lstat(abs)?.isSymbolicLink()) rmSync(abs);
+  writeFileSync(abs, data, opts);
+}
+function agentRead(root, rel) {
+  const abs = agentPath(root, rel);
+  const st = lstat(abs);
+  if (!st || st.isSymbolicLink() || !st.isFile()) return null;
+  return readFileSync(abs, "utf8");
+}
+function agentRemove(root, rel) {
+  rmSync(agentPath(root, rel), { recursive: true, force: true });
+}
+
+// server/skills.ts
+import { createHash } from "node:crypto";
+import { join as join4, resolve as resolve2, sep as sep2 } from "node:path";
+
+// server/agentFiles.ts
+import { lstatSync as lstatSync2 } from "node:fs";
+
+// server/lib/exec.ts
+import { execFile } from "node:child_process";
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve5) => {
+    const child = execFile(
+      cmd,
+      args,
+      { cwd: opts.cwd, timeout: opts.timeoutMs ?? 2e4, maxBuffer: 8 * 1024 * 1024, env: process.env },
+      (err, stdout, stderr) => {
+        const code = err && typeof err.code === "number" ? Number(err.code) : err ? null : 0;
+        resolve5({ ok: !err, code: err ? code ?? 1 : 0, stdout: String(stdout), stderr: String(stderr || (err && !stderr ? err.message : "")) });
+      }
+    );
+    if (opts.input !== void 0) child.stdin?.end(opts.input);
+  });
+}
+async function has(cmd) {
+  const r = process.platform === "win32" ? await run("where", [cmd], { timeoutMs: 5e3 }) : await run("sh", ["-c", `command -v ${cmd}`], { timeoutMs: 5e3 });
+  return r.ok && r.stdout.trim().length > 0;
+}
+function shq(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+
+// server/agentFiles.ts
+import { join as join2 } from "node:path";
+var MCP_CONFIG = ".claude/hq-mcp.json";
+var HOOK_SCRIPT = ".jsmhq-hook.mjs";
+var ROLE_FILE = ".jsmhq-role.md";
+var HQ_FILES = [ROLE_FILE, ".claude/settings.local.json", MCP_CONFIG, HOOK_SCRIPT];
+var isHqRole = (text) => text.includes("## Team MCP (server `hq`)") && text.includes("You are managed by Setups Works Office.");
+async function adoptRoleFile(dir2) {
+  const text = agentRead(dir2, "ROLE.md");
+  if (text === null) return null;
+  if (!isHqRole(text)) return text.slice(0, 2e4);
+  const tracked = await run("git", ["ls-files", "--error-unmatch", "ROLE.md"], { cwd: dir2 });
+  if (!tracked.ok) {
+    agentRemove(dir2, "ROLE.md");
+    removeFromExclude(dir2, ["ROLE.md"]);
+  }
+  return null;
+}
+var MARK = "# jsmhq-hook";
+var MARK_ARG = "--jsmhq-hook";
+var isOurs = (command) => command.includes(MARK) || command.includes(MARK_ARG);
+function hookScriptFor(agent, dir2) {
+  if (agent.mode !== "local" || process.platform !== "win32" && process.env.HQ_NODE_HOOKS !== "1") return null;
+  return join2(dir2, HOOK_SCRIPT).replace(/\\/g, "/");
+}
+var HOOK_SCRIPT_SOURCE = `// Written by Setups Works Office (git-excluded). Sends this agent's hook events to HQ.
+// Usage: node .jsmhq-hook.mjs <url> <token> [--print-reply] | --print-role
+import { readFileSync } from "node:fs";
+
+const args = process.argv.slice(2).filter((a) => a !== "${MARK_ARG}");
+if (args[0] === "--print-role") {
+  try {
+    process.stdout.write(readFileSync(new URL("./${ROLE_FILE}", import.meta.url), "utf8"));
+  } catch {}
+  process.exit(0);
+}
+const [url, token, print] = args;
+let body = "";
+let sent = false;
+const send = async () => {
+  if (sent) return;
+  sent = true;
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { Authorization: "Bearer " + token, "Content-Type": "application/json" },
+      body: body || "{}",
+      signal: AbortSignal.timeout(4000),
+    });
+    // Stop: HQ's reply ({"decision":"block",...}) hands over queued messages.
+    if (print === "--print-reply" && res.ok) process.stdout.write(await res.text());
+  } catch {}
+  process.exit(0);
+};
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (d) => (body += d));
+process.stdin.on("end", send);
+setTimeout(send, 2000).unref();
+`;
+function writeHookScript(dir2) {
+  agentWrite(dir2, HOOK_SCRIPT, HOOK_SCRIPT_SOURCE);
+}
+var HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Notification", "Stop", "SessionEnd"];
+function hqUrl(agent, port) {
+  return agent.mode === "sandbox" ? `http://host.docker.internal:${port}` : `http://127.0.0.1:${port}`;
+}
+function roleMd(agent, cfg, extras = {}) {
+  const team = cfg.team.map((a) => `- ${a.name} \u2014 ${a.role}${a.isLead ? " (lead)" : ""}${a.id === agent.id ? " \u2190 you" : ""}`).join("\n");
+  const rules = agent.isLead ? [
+    "You plan the work and assign it to the team. You never write app code.",
+    "Keep tasks small: one task = one branch = one PR. Give each task the files it may edit and a clear done-when.",
+    "Assign only to agents that are running and free (check list_workers).",
+    cfg.workflow.merge.by === "lead" ? "You merge PRs once they pass review (`gh pr merge <number> --squash --delete-branch`), one at a time, in an order that avoids conflicts. HQ tells you when each one passes." : "The user merges PRs; never merge one yourself. Decide the order they should land in, and tell the user if one blocks another.",
+    "If the user changes who merges, HQ tells you. Follow the latest message."
+  ] : [
+    "Work only on the task you were given. One task = one branch = one PR.",
+    "When HQ tells you to start a task, call get_my_task first, then `git pull origin main` and create a branch.",
+    "Edit only the files the task lists. Need another file? Ask the lead with send_message.",
+    "Title PRs `[TASK-ID] Short title` and open them with `gh pr create`, then call set_my_status in-review with the PR number.",
+    "set_my_status tells the lead automatically. Don't also send_message the same news.",
+    "If you are blocked or need a decision, call set_my_status blocked with the reason."
+  ];
+  rules.push(
+    "When you need the user to do something outside your sandbox (create an account, database or API key, change a setting in a dashboard, put a value in your env file), call ask_user with a short title and clear steps, then keep working on what you can. Never put secret values in it; name the variable instead. Variables reach you through HQ: ask the user to add NAME to your App variables in HQ (Settings \u2192 Sandbox \u2192 App variables) and restart you; there is no env file inside your sandbox to edit."
+  );
+  if (agent.mode === "sandbox")
+    rules.push(
+      "Your sandbox blocks most websites and APIs. If a request you need is blocked (a docs page or an API: usually a 403 saying 'Approval required for <host>'), call request_access with the domain and why, then continue with other work until HQ tells you it was answered. Never work around the block."
+    );
+  const tools = agent.isLead ? "list_workers, get_status, list_tasks, create_board, create_task, update_task, assign_task, send_message, ask_user, request_access" : "get_my_task, set_my_status, list_workers, get_status, list_tasks, send_message, ask_user, request_access";
+  return [
+    `# ${agent.name} \u2014 ${agent.role}`,
+    "",
+    agent.roleMd.trim(),
+    "",
+    "## Team",
+    team,
+    "",
+    "## Rules",
+    ...rules.map((r) => `- ${r}`),
+    "",
+    ...stackRoleMd(cfg.stack) ? [stackRoleMd(cfg.stack), ""] : [],
+    ...extras.hasEnvFile ? [
+      "## App variables",
+      "Your session already has this project's app variables (from HQ's env file) as environment variables. There is no .env file for them. See the names with `printenv | cut -d= -f1`; never print or commit the values. Code reads them from the environment as usual. Don't create a .env file with them unless the user asks.",
+      ""
+    ] : [],
+    ...extras.ownRole?.trim() ? ["## From ROLE.md in this folder", extras.ownRole.trim(), ""] : [],
+    "## Team MCP (server `hq`)",
+    `Your tools: ${tools}.`,
+    "Messages that start with `[HQ]` come from Setups Works Office: assignments from the lead, or messages from teammates. Act on them.",
+    "Teammates work in their own sandboxes and cannot see your files or terminal. Talk to them only with send_message.",
+    "",
+    `Project: ${cfg.project.name} (${cfg.project.repo}). You are managed by Setups Works Office.`,
+    ""
+  ].join("\n");
+}
+function hookCommand(url, token, agentId, event, script = null) {
+  if (script) return `node "${script}" ${url}/hook/${agentId}/${event} ${token}${event === "Stop" ? " --print-reply" : ""} ${MARK_ARG}`;
+  const out = event === "Stop" ? "2>/dev/null" : ">/dev/null 2>&1";
+  return `curl -sf -m 4 -X POST -H 'Authorization: Bearer ${token}' -H 'Content-Type: application/json' --data-binary @- '${url}/hook/${agentId}/${event}' ${out} || true ${MARK}`;
+}
+function writeSettings(dir2, agent, port, token) {
+  const script = hookScriptFor(agent, dir2);
+  const file = ".claude/settings.local.json";
+  let settings = {};
+  const existing = agentRead(dir2, file);
+  if (existing) {
+    try {
+      settings = JSON.parse(existing);
+    } catch {
+      settings = {};
+    }
+  }
+  const hooks = { ...settings.hooks ?? {} };
+  const url = hqUrl(agent, port);
+  for (const event of HOOK_EVENTS) {
+    const kept = (hooks[event] ?? []).map((e) => ({ ...e, hooks: e.hooks.filter((h) => !isOurs(h.command)) })).filter((e) => e.hooks.length);
+    const ours = [{ type: "command", command: hookCommand(url, token, agent.id, event, script), timeout: 5 }];
+    if (event === "SessionStart")
+      ours.unshift({ type: "command", command: script ? `node "${script}" --print-role ${MARK_ARG}` : `cat "$CLAUDE_PROJECT_DIR/${ROLE_FILE}" 2>/dev/null || true ${MARK}` });
+    hooks[event] = [...kept, event === "PreToolUse" || event === "PostToolUse" ? { matcher: "*", hooks: ours } : { hooks: ours }];
+  }
+  const allow = /* @__PURE__ */ new Set([...settings.permissions?.allow ?? [], "mcp__hq"]);
+  agentWrite(dir2, file, JSON.stringify({ ...settings, hooks, permissions: { ...settings.permissions ?? {}, allow: [...allow] } }, null, 2) + "\n");
+}
+function writeMcpConfig(dir2, agent, port, token) {
+  const config = {
+    mcpServers: {
+      hq: { type: "http", url: `${hqUrl(agent, port)}/mcp`, headers: { Authorization: `Bearer ${token}`, "X-HQ-Agent": agent.id } }
+    }
+  };
+  agentWrite(dir2, MCP_CONFIG, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+}
+function writeClaudeFiles(dir2, agent, cfg, token, extras = {}) {
+  agentWrite(dir2, ROLE_FILE, roleMd(agent, cfg, extras));
+  writeSettings(dir2, agent, cfg.project.hqPort, token);
+  writeMcpConfig(dir2, agent, cfg.project.hqPort, token);
+  if (hookScriptFor(agent, dir2)) writeHookScript(dir2);
+  excludeFromGit(dir2, HQ_FILES);
+}
+function removeFromExclude(dir2, paths) {
+  const file = ".git/info/exclude";
+  const current = agentRead(dir2, file);
+  if (current === null) return;
+  const next = current.split("\n").filter((l) => !paths.includes(l)).join("\n");
+  if (next !== current) agentWrite(dir2, file, next);
+}
+function excludeFromGit(dir2, paths) {
+  try {
+    if (!lstatSync2(join2(dir2, ".git")).isDirectory()) return;
+  } catch {
+    return;
+  }
+  const file = ".git/info/exclude";
+  const current = agentRead(dir2, file) ?? "";
+  const missing = paths.filter((p) => !current.split("\n").includes(p));
+  if (missing.length) agentWrite(dir2, file, current + (current.endsWith("\n") || !current ? "" : "\n") + "# Setups Works Office\n" + missing.join("\n") + "\n");
+}
+
+// server/lib/log.ts
+var dim = (s) => `\x1B[2m${s}\x1B[0m`;
+var log = {
+  info: (...a) => console.log(dim("[hq]"), ...a),
+  warn: (...a) => console.warn("\x1B[33m[hq]\x1B[0m", ...a),
+  error: (...a) => console.error("\x1B[31m[hq]\x1B[0m", ...a)
+};
+
+// server/paths.ts
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir } from "node:os";
+import { join as join3 } from "node:path";
+var slugify = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "") || "project";
+function projectHome(projectSlug) {
+  const dir2 = join3(homedir(), ".jsmhq", projectSlug);
+  mkdirSync2(dir2, { recursive: true });
+  return dir2;
+}
+function managedWorkspace(projectSlug, agentId) {
+  return join3(projectHome(projectSlug), agentId);
+}
+var sessionName = (projectSlug, agentId) => `hq-${projectSlug}-${agentId}`;
+function agentToken(projectSlug) {
+  const file = join3(projectHome(projectSlug), "agent-token");
+  if (existsSync(file)) return readFileSync2(file, "utf8").trim();
+  const tok = randomBytes(24).toString("hex");
+  writeFileSync2(file, tok, { mode: 384 });
+  return tok;
+}
+function browserToken(projectSlug, dev) {
+  if (!dev) return randomBytes(24).toString("hex");
+  const file = join3(projectHome(projectSlug), "dev-browser-token");
+  if (existsSync(file)) return readFileSync2(file, "utf8").trim();
+  const tok = randomBytes(24).toString("hex");
+  writeFileSync2(file, tok, { mode: 384 });
+  return tok;
+}
+
+// server/skills.ts
+var AGENT_DIRS = [".claude/skills", ".agents/skills"];
+var cacheDir = (slug2) => join4(projectHome(slug2), "skills-cache");
+var key = (specs) => JSON.stringify(specs);
+var installing = null;
+function ensureSkillCache(slug2, specs) {
+  const run_ = async () => {
+    const dir2 = cacheDir(slug2);
+    const stamp = join4(dir2, "installed.json");
+    if (existsSync2(stamp) && readFileSync3(stamp, "utf8") === key(specs)) return;
+    rmSync2(dir2, { recursive: true, force: true });
+    mkdirSync3(dir2, { recursive: true });
+    if (!specs.length) return writeFileSync3(stamp, key(specs));
+    await run("git", ["init", "-q"], { cwd: dir2 });
+    const failed = [];
+    for (const spec of specs) {
+      const args = ["-y", "skills", "add", spec.source, "--skill", ...spec.skills, "-a", "claude-code", "codex", "-y", "--copy"];
+      const [cmd, cmdArgs] = process.platform === "win32" ? ["cmd.exe", ["/d", "/s", "/c", "npx", ...args]] : ["npx", args];
+      const r = await run(cmd, cmdArgs, {
+        cwd: dir2,
+        timeoutMs: 18e4
+      });
+      if (!r.ok) failed.push(`${spec.source}: ${(r.stderr || r.stdout).trim().split("\n").pop()}`);
+    }
+    if (failed.length) throw new Error(`Some skills didn't install. ${failed.join("; ")}`);
+    writeFileSync3(stamp, key(specs));
+  };
+  const next = (installing ?? Promise.resolve()).then(run_);
+  const settled = next.then(
+    () => {
+    },
+    () => {
+    }
+  );
+  installing = settled;
+  void settled.then(() => {
+    if (installing === settled) installing = null;
+  });
+  return next;
+}
+var SAFE = /^\.(claude|agents)\/skills\/[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var ownedFile = (slug2, workspace) => join4(projectHome(slug2), "skills-owned", `${createHash("sha1").update(resolve2(workspace)).digest("hex").slice(0, 16)}.json`);
+function readOwned(slug2, workspace) {
+  try {
+    const list = JSON.parse(readFileSync3(ownedFile(slug2, workspace), "utf8"));
+    return Array.isArray(list) ? list.filter((p) => typeof p === "string" && SAFE.test(p)) : [];
+  } catch {
+    return [];
+  }
+}
+var hasHqSkills = (slug2, workspace) => readOwned(slug2, workspace).length > 0;
+async function syncSkillsInto(slug2, workspace) {
+  const before = readOwned(slug2, workspace);
+  const tracked = async (rel) => (await run("git", ["ls-files", "--error-unmatch", rel], { cwd: workspace })).ok;
+  const inside = (rel) => SAFE.test(rel) && resolve2(workspace, rel).startsWith(resolve2(workspace) + sep2);
+  const now3 = [];
+  const there = (rel) => {
+    try {
+      lstatSync3(agentPath(workspace, rel));
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  for (const sub of AGENT_DIRS) {
+    const from = join4(cacheDir(slug2), sub);
+    if (!existsSync2(from)) continue;
+    agentMkdir(workspace, sub);
+    for (const name of readdirSync(from)) {
+      const rel = `${sub}/${name}`;
+      if (!inside(rel)) continue;
+      if (await tracked(rel)) continue;
+      if (there(rel) && !before.includes(rel)) continue;
+      agentRemove(workspace, rel);
+      cpSync(join4(from, name), agentPath(workspace, rel), { recursive: true });
+      now3.push(rel);
+    }
+  }
+  for (const rel of before) {
+    if (now3.includes(rel) || !inside(rel) || await tracked(rel)) continue;
+    try {
+      agentRemove(workspace, rel);
+    } catch {
+    }
+  }
+  mkdirSync3(join4(projectHome(slug2), "skills-owned"), { recursive: true });
+  writeFileSync3(ownedFile(slug2, workspace), JSON.stringify(now3));
+  excludeFromGit(workspace, now3);
+  return now3;
+}
+async function prepareSkills(slug2, workspace, specs) {
+  try {
+    await ensureSkillCache(slug2, specs);
+    const copied = await syncSkillsInto(slug2, workspace);
+    return { count: copied.filter((p) => p.startsWith(".claude/")).length, error: null };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log.warn(`skills: ${msg}`);
+    return { count: 0, error: msg };
+  }
+}
+
+// src/theme/tokens.ts
+var colors = {
+  ink: "#241a2e",
+  cream: "#fff6e9",
+  cream2: "#f0dfc2",
+  cream3: "#e2cba6",
+  muted: "#7d6b73",
+  navy: "#1d2b53",
+  navy2: "#16213f",
+  blue: "#29adff",
+  red: "#ff004d",
+  orange: "#ffa300",
+  green: "#00e436",
+  lav: "#83769c",
+  yellow: "#ffec27",
+  pink: "#ff77a8",
+  grass: "#4a8f3d",
+  white: "#fff1e8"
+};
+var stateStyle = {
+  working: { label: "Working", color: colors.blue, dim: "#1d6fb8" },
+  "needs-input": { label: "Needs input", color: colors.red, dim: "#7e0f33" },
+  "in-review": { label: "In review", color: colors.orange, dim: "#a86a00" },
+  "review-passed": { label: "Review passed", color: colors.green, dim: "#00873a" },
+  idle: { label: "Idle", color: colors.lav, dim: "#5a5170" }
+};
+var reviewStyle = {
+  pending: { label: "Queued", color: colors.lav, dim: "#5a5170" },
+  reviewing: { label: "Reviewing", color: colors.orange, dim: "#a86a00" },
+  "changes-requested": { label: "Changes", color: colors.red, dim: "#7e0f33" },
+  passed: { label: "Passed", color: colors.green, dim: "#00873a" }
+};
+var agentPalette = [
+  "#ff77a8",
+  // pink
+  "#29adff",
+  // blue
+  "#ffd23a",
+  // yellow
+  "#00e436",
+  // green
+  "#ff8a3d",
+  // orange
+  "#a98bff",
+  // violet
+  "#3ee0d0",
+  // teal
+  "#ff5c5c",
+  // coral
+  "#c2c3c7",
+  // silver
+  "#b0e04a",
+  // lime
+  "#f0a6ff",
+  // lilac
+  "#6fa8ff"
+  // periwinkle
+];
+
+// server/planExport.ts
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join5 } from "node:path";
+var PLAN_EXPORT_PATH = "docs/plan.md";
+var BOX = { todo: "[ ]", "in-progress": "[ ]", "in-review": "[ ]", blocked: "[ ]", done: "[x]" };
+var STATUS = { todo: "", "in-progress": "in progress", "in-review": "in review", blocked: "blocked", done: "" };
+function planMarkdown(config, plan) {
+  const name = (id) => id ? config.team.find((a) => a.id === id)?.name ?? id : null;
+  const lines = [`# ${config.project.name} plan`, "", "_Written by Setups Works Office from .jsmhq/plan.json. Edits here are overwritten; change the plan in HQ._", ""];
+  for (const b of [...plan.boards].sort((x, y) => x.order - y.order)) {
+    lines.push(`## ${b.title} (${b.status})`, "");
+    const tasks = plan.tasks.filter((t2) => t2.boardId === b.id);
+    if (!tasks.length) lines.push("_No tasks._");
+    for (const t2 of tasks) {
+      const meta = [name(t2.ownerId), STATUS[t2.status], t2.prNumber ? `PR #${t2.prNumber}` : "", t2.needs.length ? `needs ${t2.needs.join(", ")}` : ""].filter(Boolean);
+      lines.push(`- ${BOX[t2.status]} **${t2.id}** ${t2.title}${meta.length ? ` \u2014 ${meta.join(" \xB7 ")}` : ""}`);
+      if (t2.description) lines.push(`  - ${t2.description.replace(/\s*\n\s*/g, " ")}`);
+      if (t2.doneWhen) lines.push(`  - Done when: ${t2.doneWhen.replace(/\s*\n\s*/g, " ")}`);
+      if (t2.note) lines.push(`  - Note: ${t2.note}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function writePlanExport(root, config, plan) {
+  const file = join5(root, PLAN_EXPORT_PATH);
+  mkdirSync4(join5(file, ".."), { recursive: true });
+  writeFileSync4(file, planMarkdown(config, plan));
+}
+
+// server/store.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync5, readFileSync as readFileSync4, renameSync, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join6 } from "node:path";
+var dir = (root) => join6(root, ".jsmhq");
+function readJson(file) {
+  if (!existsSync3(file)) return null;
+  return JSON.parse(readFileSync4(file, "utf8"));
+}
+function writeJson(file, value) {
+  mkdirSync5(join6(file, ".."), { recursive: true });
+  const tmp = `${file}.tmp`;
+  writeFileSync5(tmp, JSON.stringify(value, null, 2) + "\n");
+  renameSync(tmp, file);
+}
+var defaultSandbox = () => ({
+  resources: { cpus: null, memoryGb: null },
+  // sbx's own defaults
+  allow: [],
+  deny: []
+});
+function newAgent(id, name, role, color, isLead) {
+  return {
+    id,
+    name,
+    role,
+    isLead,
+    cli: "claude",
+    model: "",
+    // the CLI's default; users can pick with /model or "Start with model"
+    mode: "sandbox",
+    color,
+    skills: [],
+    roleMd: isLead ? `You are ${name}, the lead. You plan and assign work. You never write app code.` : `You are ${name}, a ${role.toLowerCase()} on the team. You build the tasks assigned to you.`,
+    sandbox: defaultSandbox(),
+    workspacePath: null,
+    mcp: []
+  };
+}
+function defaultConfig(repo, port) {
+  return {
+    project: { id: slugify(repo.name), name: repo.name, repo: repo.github ?? repo.name, path: repo.root, hqPort: port },
+    team: [newAgent(slugify(LEAD_NAME), LEAD_NAME, "Lead", "#ff77a8", true), newAgent(slugify(WORKER_NAMES[0]), WORKER_NAMES[0], "Developer", "#29adff", false)],
+    workflow: {
+      review: { enabled: true, tool: repo.hasCodeRabbit ? "coderabbit" : "human", command: "" },
+      merge: { by: "human" },
+      deploy: { enabled: repo.hasInsta, tool: "instacloud", command: "", perAgentEnvironments: repo.hasInsta }
+    }
+  };
+}
+function loadConfig(repo, port) {
+  const file = join6(dir(repo.root), "config.json");
+  const found = readJson(file);
+  if (found) {
+    for (const a of found.team) {
+      a.workspacePath ??= null;
+      a.mcp ??= [];
+      a.cli ??= "claude";
+      a.sandbox.resources ??= { cpus: null, memoryGb: null };
+      const old = a.sandbox;
+      delete old.policy;
+      delete old.proxy;
+      delete old.secrets;
+    }
+    found.project.id = slugify(found.project.id ?? found.project.name);
+    found.project.path = repo.root;
+    return { config: found, isNew: false };
+  }
+  return { config: defaultConfig(repo, port), isNew: true };
+}
+function saveConfig(root, cfg) {
+  const { path: _path, ...project } = cfg.project;
+  writeJson(join6(dir(root), "config.json"), { ...cfg, project: { ...project, path: "" } });
+}
+function loadPlan(root) {
+  return readJson(join6(dir(root), "plan.json")) ?? { boards: [{ id: "B1", title: "Backlog", status: "active", order: 0 }], tasks: [] };
+}
+function savePlan(root, plan) {
+  writeJson(join6(dir(root), "plan.json"), plan);
+}
+
+// server/hub.ts
+var now = () => (/* @__PURE__ */ new Date()).toISOString();
+var Hub = class _Hub {
+  constructor(repo, slug2, config, plan, setup) {
+    this.repo = repo;
+    this.slug = slug2;
+    this.snap = {
+      setup,
+      sbx: { basePolicy: "unknown", proxy: null, globalKeys: [], agents: {}, checkedAt: now() },
+      config,
+      agents: config.team.map((a) => _Hub.freshStatus(a.id)),
+      boards: plan.boards,
+      tasks: plan.tasks,
+      pullRequests: [],
+      environments: [],
+      messages: [],
+      activity: []
+    };
+  }
+  repo;
+  slug;
+  snap;
+  listeners = /* @__PURE__ */ new Set();
+  seq = 0;
+  static freshStatus(agentId) {
+    return {
+      agentId,
+      state: "idle",
+      currentTaskId: null,
+      stateSince: now(),
+      note: "Not started",
+      session: { state: "stopped", detail: null, workspace: null, sandbox: null }
+    };
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  emit(e) {
+    for (const fn of this.listeners) fn(e);
+  }
+  // ------------------------------------------------------------ lookups
+  cfg(id) {
+    return this.snap.config.team.find((a) => a.id === id);
+  }
+  status(id) {
+    return this.snap.agents.find((a) => a.agentId === id);
+  }
+  name(id) {
+    if (id === "you") return "You";
+    if (id === "hq") return "HQ";
+    return id && this.cfg(id)?.name || "Someone";
+  }
+  // ------------------------------------------------------------ mutations
+  /** While an access request is open, the agent stays "needs you"; what hooks report meanwhile is kept for after. */
+  held = /* @__PURE__ */ new Map();
+  /** Remember what the agent was doing before it asked, to return to it after the answer. */
+  holdForAccess(agentId) {
+    const s = this.status(agentId);
+    if (s && !this.held.has(agentId) && s.state !== "needs-input") this.held.set(agentId, { state: s.state, note: s.note });
+  }
+  pendingAccess(agentId) {
+    return this.snap.accessRequests?.find((r) => r.agentId === agentId && r.status === "pending");
+  }
+  /** An access request was answered: drop back to what the agent is really doing (unless another is open). */
+  accessAnswered(agentId) {
+    if (this.pendingAccess(agentId)) return;
+    const held = this.held.get(agentId);
+    this.held.delete(agentId);
+    const s = this.status(agentId);
+    if (s?.state === "needs-input" && s.note?.startsWith("Asking: access to"))
+      this.setStatus(agentId, held ?? { state: "working", note: "Access answered" });
+  }
+  setStatus(id, patch) {
+    const s = this.status(id);
+    if (!s) return;
+    const open = this.pendingAccess(id);
+    if (open && patch.state !== void 0 && patch.state !== "needs-input") {
+      this.held.set(id, { state: patch.state, note: patch.note !== void 0 ? patch.note : this.held.get(id)?.note ?? null });
+      patch = { ...patch, state: "needs-input", note: `Asking: access to ${open.domain}` };
+    }
+    if (patch.state !== void 0 && patch.state !== s.state) s.stateSince = now();
+    Object.assign(s, patch);
+    this.emit({ type: "agent.updated", agent: structuredClone(s) });
+  }
+  setSession(id, patch) {
+    const s = this.status(id);
+    if (!s) return;
+    s.session = { ...s.session, ...patch };
+    this.emit({ type: "agent.updated", agent: structuredClone(s) });
+  }
+  setSetup(setup) {
+    this.snap.setup = setup;
+    this.emit({ type: "setup.updated", setup });
+  }
+  activity(type, agentId, text) {
+    this.seq += 1;
+    const event = { id: `a${this.seq}`, at: now(), type, agentId, text };
+    this.snap.activity = [event, ...this.snap.activity].slice(0, 50);
+    this.emit({ type: "activity", event });
+  }
+  configChanged() {
+    saveConfig(this.repo.root, this.snap.config);
+    this.emit({ type: "config.updated", config: structuredClone(this.snap.config) });
+  }
+  planChanged() {
+    const plan = { boards: this.snap.boards, tasks: this.snap.tasks };
+    savePlan(this.repo.root, plan);
+    if (this.snap.config.project.exportPlan) writePlanExport(this.repo.root, this.snap.config, plan);
+  }
+  terminal(agentId, data) {
+    this.emit({ type: "terminal.output", agentId, data });
+  }
+};
+
+// server/github.ts
+var BASE_FIELDS = "number title url headRefName createdAt mergedAt state mergeable isDraft reviewDecision";
+var REVIEW_FIELDS = `
+  reviews(last: 10) { nodes { author { login } state submittedAt } }
+  reviewThreads(first: 30) { nodes { isResolved isOutdated comments(first: 1) { nodes { author { login } } } } }
+  commits(last: 1) { nodes { commit { statusCheckRollup { contexts(first: 25) { nodes {
+    __typename
+    ... on CheckRun { name status conclusion }
+    ... on StatusContext { context state description }
+  } } } } } }`;
+var OPEN_LIMIT = 20;
+var QUERY = `query($owner: String!, $name: String!) {
+  rateLimit { cost remaining resetAt }
+  repository(owner: $owner, name: $name) {
+    open: pullRequests(states: OPEN, first: ${OPEN_LIMIT}, orderBy: { field: UPDATED_AT, direction: DESC }) { nodes { ${BASE_FIELDS} ${REVIEW_FIELDS} } }
+    merged: pullRequests(states: MERGED, first: 10, orderBy: { field: UPDATED_AT, direction: DESC }) { nodes { ${BASE_FIELDS} } }
+    closed: pullRequests(states: CLOSED, first: 10, orderBy: { field: UPDATED_AT, direction: DESC }) { nodes { number } }
+  }
+}`;
+var RateLimited = class extends Error {
+  constructor(resetAt) {
+    super("GitHub API rate limit reached");
+    this.resetAt = resetAt;
+  }
+  resetAt;
+};
+async function graphqlResetAt() {
+  const r = await run("gh", ["api", "rate_limit"], { timeoutMs: 15e3 });
+  try {
+    const reset = JSON.parse(r.stdout).resources?.graphql?.reset;
+    if (reset) return new Date(reset * 1e3);
+  } catch {
+  }
+  return new Date(Date.now() + 15 * 6e4);
+}
+async function rateLimited(message) {
+  if (/secondary rate limit/i.test(message)) return new RateLimited(new Date(Date.now() + 2 * 6e4));
+  return new RateLimited(await graphqlResetAt());
+}
+var EMPTY_REVIEW = { reviews: { nodes: [] }, reviewThreads: { nodes: [] }, commits: { nodes: [] } };
+async function fetchPrs(repo) {
+  const [owner, name] = repo.split("/");
+  const r = await run("gh", ["api", "graphql", "-f", `query=${QUERY}`, "-F", `owner=${owner}`, "-F", `name=${name}`], { timeoutMs: 3e4 });
+  if (!r.ok) {
+    const msg = r.stderr.trim().split("\n")[0] || "gh api failed";
+    if (/rate limit/i.test(r.stderr + r.stdout)) throw await rateLimited(r.stderr + r.stdout);
+    throw new Error(msg);
+  }
+  const data = JSON.parse(r.stdout);
+  const limited = data.errors?.find((e) => e.type === "RATE_LIMITED" || /rate limit/i.test(e.message));
+  if (limited) throw await rateLimited(limited.message);
+  if (!data.data?.repository) throw new Error(data.errors?.[0]?.message ?? "Repository not found");
+  return {
+    open: data.data.repository.open.nodes,
+    merged: data.data.repository.merged.nodes.map((pr) => ({ ...pr, ...EMPTY_REVIEW })),
+    closed: (data.data.repository.closed?.nodes ?? []).map((n) => n.number),
+    rate: data.data.rateLimit ?? null
+  };
+}
+var BOTS = {
+  coderabbit: { logins: ["coderabbitai", "coderabbitai[bot]"], check: /coderabbit/i, label: "CodeRabbit" },
+  greptile: { logins: ["greptile-apps", "greptile-apps[bot]"], check: /greptile/i, label: "Greptile" },
+  copilot: { logins: ["copilot-pull-request-reviewer", "copilot-pull-request-reviewer[bot]", "Copilot"], check: /copilot/i, label: "Copilot" }
+};
+var contexts = (pr) => pr.commits.nodes[0]?.commit.statusCheckRollup?.contexts.nodes ?? [];
+var openThreads = (pr, logins) => pr.reviewThreads.nodes.filter((t2) => !t2.isResolved && !t2.isOutdated && (!logins || logins.includes(t2.comments.nodes[0]?.author?.login ?? ""))).length;
+function reviewOf(pr, tool) {
+  if (tool === "custom") return { review: "pending", openComments: openThreads(pr), note: "Custom review checks aren't run by HQ yet" };
+  if (tool === "human") {
+    const decided = pr.reviewDecision ?? [...pr.reviews.nodes].reverse().find((r) => r.state === "APPROVED" || r.state === "CHANGES_REQUESTED")?.state ?? null;
+    const open2 = openThreads(pr);
+    if (decided === "APPROVED") return { review: "passed", openComments: open2, note: null };
+    if (decided === "CHANGES_REQUESTED") return { review: "changes-requested", openComments: open2, note: null };
+    return { review: "pending", openComments: open2, note: "Waiting for a reviewer" };
+  }
+  const bot = BOTS[tool];
+  const open = openThreads(pr, bot.logins);
+  const ctx = contexts(pr).find((c) => bot.check.test(c.__typename === "CheckRun" ? c.name : c.context));
+  const pending = ctx && (ctx.__typename === "CheckRun" ? ctx.status !== "COMPLETED" : ctx.state === "PENDING" || ctx.state === "EXPECTED");
+  if (pending) return { review: "reviewing", openComments: open, note: null };
+  if (open > 0) return { review: "changes-requested", openComments: open, note: null };
+  const desc = ctx?.__typename === "StatusContext" ? ctx.description ?? "" : "";
+  if (/rate.?limit|skip|paused|disabled/i.test(desc)) return { review: "pending", openComments: 0, note: `${bot.label}: ${desc.toLowerCase()}` };
+  const ok2 = ctx && (ctx.__typename === "CheckRun" ? ctx.conclusion === "SUCCESS" || ctx.conclusion === "NEUTRAL" : ctx.state === "SUCCESS");
+  if (ok2) return { review: "passed", openComments: 0, note: null };
+  if (ctx) return { review: "changes-requested", openComments: 0, note: `${bot.label} check failed` };
+  const botReviewed = pr.reviews.nodes.some((r) => bot.logins.includes(r.author?.login ?? ""));
+  return botReviewed ? { review: "passed", openComments: 0, note: null } : { review: "pending", openComments: 0, note: `Waiting for ${bot.label}` };
+}
+var TASK_ID = /([A-Z][A-Z0-9]*-T\d+)/i;
+function taskIdOf(pr) {
+  const inTitle = pr.title.match(/\[([A-Z][A-Z0-9]*-T\d+)\]/i);
+  if (inTitle) return inTitle[1].toUpperCase();
+  const inBranch = pr.headRefName.match(TASK_ID);
+  return inBranch ? inBranch[1].toUpperCase() : null;
+}
+function branchAgent(branch) {
+  const m = branch.match(/^([a-z0-9][a-z0-9-]*)\//i);
+  return m ? m[1].toLowerCase() : null;
+}
+function toPullRequest(pr, tool, reviewEnabled, taskId, authorId) {
+  const merged = pr.state === "MERGED";
+  const r = reviewEnabled ? reviewOf(pr, tool) : { review: "passed", openComments: 0, note: null };
+  return {
+    number: pr.number,
+    title: pr.title,
+    taskId,
+    authorId,
+    review: merged && r.review !== "changes-requested" ? "passed" : r.review,
+    openComments: r.openComments,
+    mergeable: pr.mergeable === "MERGEABLE",
+    merged,
+    openedAt: pr.createdAt,
+    url: pr.url,
+    branch: pr.headRefName,
+    closed: pr.state === "CLOSED",
+    conflict: pr.mergeable === "CONFLICTING",
+    reviewNote: pr.isDraft ? "Draft" : r.note
+  };
+}
+
+// server/githubSync.ts
+var MERGE_CMD = (n) => `gh pr merge ${n} --squash --delete-branch`;
+function passedNotice(pr, author, by) {
+  const head = `PR #${pr.number} (${pr.title}) by ${author} passed review.`;
+  return by === "lead" ? `${head} You merge PRs on this project: run \`${MERGE_CMD(pr.number)}\` now. If GitHub refuses (conflicts or failing checks), ask the author to fix it instead. Then assign the next task if anything is waiting.` : `${head} It's ready for the user to merge. Don't merge it yourself.`;
+}
+function mergeByNotice(by, waiting) {
+  if (by === "human") return "The user changed the workflow: the user merges PRs now. Don't merge PRs yourself.";
+  const list = waiting.length ? ` These passed review and are waiting: ${waiting.map((n) => `#${n}`).join(", ")}. Merge each with \`${MERGE_CMD("<number>")}\`.` : "";
+  return `The user changed the workflow: you now merge PRs once they pass review.${list}`;
+}
+var MIN_POLL_MS = 2e4;
+var MAX_POLL_MS = 5 * 6e4;
+var HQ_BUDGET = 1200;
+var LOW_REMAINING = 800;
+var label = { coderabbit: "CodeRabbit", greptile: "Greptile", copilot: "Copilot", human: "The reviewer", custom: "The review check" };
+var GitHubSync = class {
+  constructor(hub, planner, repo) {
+    this.hub = hub;
+    this.planner = planner;
+    this.repo = repo;
+  }
+  hub;
+  planner;
+  repo;
+  prev = /* @__PURE__ */ new Map();
+  first = true;
+  timer = null;
+  nudgeTimer = null;
+  busy = false;
+  lastError = null;
+  lastFetch = 0;
+  interval = MIN_POLL_MS;
+  pausedUntil = 0;
+  start() {
+    if (!this.repo) {
+      log.warn("No GitHub remote: PRs and reviews are off.");
+      return;
+    }
+    void this.tick();
+    let reviewCfg = JSON.stringify(this.hub.snap.config.workflow.review);
+    this.hub.subscribe((e) => {
+      if (e.type === "config.updated" && JSON.stringify(e.config.workflow.review) !== reviewCfg) {
+        reviewCfg = JSON.stringify(e.config.workflow.review);
+        this.first = true;
+        this.nudge(500);
+      }
+      if (e.type === "activity" && e.event.type === "agent.answered") this.nudge();
+      if (e.type === "task.updated" && e.task.status === "in-review") this.nudge(1500);
+    });
+  }
+  stop() {
+    if (this.timer) clearTimeout(this.timer);
+    if (this.nudgeTimer) clearTimeout(this.nudgeTimer);
+  }
+  /** One poll, then schedule the next at the current interval. */
+  async tick() {
+    await this.refresh();
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => void this.tick(), Math.max(this.interval, this.pausedUntil - Date.now()));
+  }
+  /** Refresh soon (debounced): an agent just opened a PR or finished a turn. Still respects the minimum gap and any pause. */
+  nudge(delayMs = 3e3) {
+    if (!this.repo) return;
+    if (this.nudgeTimer) clearTimeout(this.nudgeTimer);
+    const wait = Math.max(delayMs, this.lastFetch + MIN_POLL_MS - Date.now(), this.pausedUntil - Date.now());
+    this.nudgeTimer = setTimeout(() => void this.refresh(), wait);
+  }
+  /** Poll often enough to stay within HQ's share of the budget; slow down when it runs low. */
+  pace(rate) {
+    if (!rate) return;
+    const forBudget = Math.ceil(Math.max(1, rate.cost) * 36e5 / HQ_BUDGET);
+    const low = rate.remaining < LOW_REMAINING ? 12e4 : 0;
+    this.interval = Math.min(MAX_POLL_MS, Math.max(MIN_POLL_MS, forBudget, low));
+  }
+  async refresh() {
+    if (!this.repo || this.busy || Date.now() < this.pausedUntil) return;
+    if (Date.now() - this.lastFetch < MIN_POLL_MS - 1e3) return;
+    if (!this.hub.snap.setup.checks.find((c) => c.id === "gh" && c.status === "ok")) return;
+    this.busy = true;
+    this.lastFetch = Date.now();
+    try {
+      const { open, merged, closed, rate } = await fetchPrs(this.repo);
+      if (this.lastError) log.info("GitHub reachable again");
+      this.lastError = null;
+      this.pace(rate);
+      const wf = this.hub.snap.config.workflow;
+      const team = new Set(this.hub.snap.config.team.map((a) => a.id));
+      const next = [...open, ...merged].map((gh) => {
+        const taskId = taskIdOf(gh);
+        const task = taskId ? this.planner.task(taskId) : void 0;
+        const fromBranch = branchAgent(gh.headRefName);
+        const authorId = task?.ownerId ?? (fromBranch && team.has(fromBranch) ? fromBranch : "");
+        return toPullRequest(gh, wf.review.tool, wf.review.enabled, task?.id ?? taskId ?? "", authorId);
+      });
+      const seen = new Set(next.map((p) => p.number));
+      const complete = open.length < OPEN_LIMIT;
+      const recentlyClosed = new Set(closed);
+      for (const old of this.prev.values())
+        if (!seen.has(old.number) && !old.merged && !old.closed) next.push(complete || recentlyClosed.has(old.number) ? { ...old, closed: true } : old);
+      for (const pr of next) {
+        const old = this.prev.get(pr.number);
+        if (JSON.stringify(old) !== JSON.stringify(pr)) this.hub.emit({ type: "pr.updated", pr: { ...pr } });
+        if (!this.first) this.react(old, pr);
+        this.syncTask(pr);
+      }
+      this.hub.snap.pullRequests = next;
+      this.prev = new Map(next.map((p) => [p.number, p]));
+      this.first = false;
+    } catch (err) {
+      if (err instanceof RateLimited) {
+        this.pausedUntil = err.resetAt.getTime() + 5e3;
+        const at = err.resetAt.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+        const msg2 = `GitHub API rate limit reached (shared with your agents' gh commands). PR sync paused until ${at}.`;
+        if (msg2 !== this.lastError) {
+          log.warn(msg2);
+          this.hub.activity("config", null, msg2);
+        }
+        this.lastError = msg2;
+        return;
+      }
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg !== this.lastError) log.warn(`GitHub: ${msg}`);
+      this.lastError = msg;
+    } finally {
+      this.busy = false;
+    }
+  }
+  /** Keep the task board in line with its PR. */
+  syncTask(pr) {
+    const task = pr.taskId ? this.planner.task(pr.taskId) : void 0;
+    if (!task || pr.closed) return;
+    if (pr.merged && task.status !== "done") this.planner.updateTask(task.id, { status: "done", prNumber: pr.number });
+    else if (!pr.merged && (task.status === "todo" || task.status === "in-progress")) this.planner.updateTask(task.id, { status: "in-review", prNumber: pr.number });
+    else if (!pr.merged && task.prNumber !== pr.number) this.planner.updateTask(task.id, { prNumber: pr.number });
+  }
+  react(old, pr) {
+    const hub = this.hub;
+    const who = pr.authorId || null;
+    const tool = label[hub.snap.config.workflow.review.tool];
+    const lead = hub.snap.config.team.find((a) => a.isLead);
+    const ref = `#${pr.number} ${pr.title}`;
+    if (!old && !pr.merged && !pr.closed) hub.activity("pr.opened", who, `${hub.name(who)} opened PR ${ref}`);
+    if (pr.closed && !old?.closed) return hub.activity("config", who, `PR #${pr.number} was closed without merging`);
+    if (pr.merged && !old?.merged) {
+      hub.activity("pr.merged", null, `PR ${ref} was merged`);
+      if (lead) this.planner.notify(lead.id, `PR #${pr.number} (${pr.title}) was merged${pr.taskId ? `; ${pr.taskId} is done` : ""}. Assign the next task if anything is waiting.`);
+      return;
+    }
+    if (pr.merged) return;
+    if (pr.review === "reviewing" && old?.review !== "reviewing") hub.activity("review.started", null, `${tool} is reviewing #${pr.number}`);
+    const newComments = pr.review === "changes-requested" && (old?.review !== "changes-requested" || pr.openComments > (old?.openComments ?? 0));
+    if (newComments) {
+      const n = pr.openComments;
+      hub.activity("review.changes", who, `${tool} left ${n || "new"} comment${n === 1 ? "" : "s"} on #${pr.number}`);
+      if (who)
+        this.planner.notify(
+          who,
+          `${tool} reviewed your PR #${pr.number} (${pr.title}) and left ${n || "new"} open comment${n === 1 ? "" : "s"}. Read them with \`gh pr view ${pr.number} --comments\` (or the GitHub API), fix them on the same branch, push, and resolve each thread you fixed.`
+        );
+    }
+    if (pr.review === "passed" && old?.review !== "passed") {
+      hub.activity("review.passed", who, `${tool} approved #${pr.number}`);
+      if (lead) this.planner.notify(lead.id, passedNotice(pr, hub.name(who), hub.snap.config.workflow.merge.by));
+    }
+    if (pr.conflict && !old?.conflict && who)
+      this.planner.notify(who, `Your PR #${pr.number} has merge conflicts with main. Pull main, rebase or merge it into your branch, fix the conflicts, and push.`);
+  }
+};
+
+// server/commands.ts
+function cleanStack(raw) {
+  const input = raw ?? {};
+  const choice = (c, category) => {
+    const v = c ?? {};
+    const id = str(v.id, 40);
+    const known = id === "other" || stackTool(id)?.category === category;
+    if (!known) return null;
+    const out = { id };
+    if (typeof v.where === "string" && v.where.trim()) out.where = str(v.where, 120).trim();
+    if (id === "other") {
+      if (typeof v.name === "string" && v.name.trim()) out.name = str(v.name, 60).trim();
+      if (typeof v.docsUrl === "string" && v.docsUrl.trim()) out.docsUrl = str(v.docsUrl, 300).trim();
+    }
+    return out;
+  };
+  const frameworks = (Array.isArray(input.frameworks) ? input.frameworks : []).slice(0, 10).map((f) => choice(f, "framework")).filter((f) => !!f);
+  const tools = {};
+  for (const c of STACK_CATEGORIES) {
+    const picked = choice(input.tools?.[c.id], c.id);
+    if (picked) tools[c.id] = picked;
+  }
+  return frameworks.length || Object.keys(tools).length ? { frameworks, tools } : null;
+}
+var slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "") || "agent";
+var str = (v, max = 2e3) => typeof v === "string" ? v.slice(0, max) : "";
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+function makeCommands(hub, sessions, planner, inbox, sbx, mcp) {
+  const attempt = async (agentId, what, fn) => {
+    try {
+      await fn();
+      hub.activity("config", agentId, what);
+    } catch (err) {
+      hub.activity("config", agentId, `Couldn't ${what.charAt(0).toLowerCase() + what.slice(1)}: ${err instanceof Error ? err.message : err}`);
+    }
+  };
+  const team = () => hub.snap.config.team;
+  const commands = {
+    sendTerminalInput: (id, data) => sessions.input(str(id, 80), str(data, 1e5)),
+    openShell: (id) => sessions.openShell(str(id, 80)),
+    closeShell: (id) => sessions.closeShell(str(id, 80)),
+    openHostShell: (dir2, fresh) => sessions.openHostShell(str(dir2, 4096), fresh === true),
+    closeHostShell: () => sessions.closeHostShell(),
+    forwardPort: (agentId, port) => sbx.forwardPort(str(agentId, 80), num(port)),
+    unforwardPort: (agentId, port) => sbx.unforwardPort(str(agentId, 80), num(port)),
+    resizeTerminal: (id, cols, rows) => sessions.resize(str(id, 80), num(cols), num(rows)),
+    startAgent: (id) => sessions.start(str(id, 80)),
+    stopAgent: (id) => sessions.stop(str(id, 80)),
+    openWorkspace: (id) => sessions.openWorkspace(str(id, 80)),
+    recreateSandbox: (id) => sessions.recreate(str(id, 80)),
+    recheckSetup: async () => {
+      await sessions.recheckSetup();
+      await sbx.refresh();
+    },
+    runSetupFix: (id) => sessions.runFix(str(id, 40)),
+    // You → agent: same delivery path as the lead's assign_task / send_message.
+    assignTask: (taskId, agentId) => planner.assign(str(taskId, 40), str(agentId, 80), "you"),
+    sendMessage: (toId, text) => planner.message("you", str(toId, 80), str(text, 2e3)),
+    addAgent: (raw) => {
+      const input = raw ?? {};
+      const name = str(input.name, 40).trim() || "Agent";
+      let id = slug(name);
+      for (let i = 2; team().some((a) => a.id === id); i++) id = `${slug(name)}-${i}`;
+      const used = new Set(team().map((a) => a.color));
+      const color = agentPalette.find((c) => !used.has(c)) ?? agentPalette[team().length % agentPalette.length];
+      const agent = newAgent(id, name, str(input.role, 40).trim() || "Developer", color, false);
+      agent.cli = input.cli === "codex" ? "codex" : "claude";
+      agent.model = str(input.model, 60).trim();
+      agent.mode = input.mode === "local" ? "local" : "sandbox";
+      const lead = team().find((a) => a.isLead);
+      if (lead) agent.sandbox = structuredClone(lead.sandbox);
+      team().push(agent);
+      const status = Hub.freshStatus(id);
+      hub.snap.agents.push(status);
+      hub.configChanged();
+      hub.emit({ type: "agent.updated", agent: structuredClone(status) });
+      hub.activity("config", null, `Added ${agent.name} (${agent.role}). Press Start to launch their session.`);
+      if (agent.cli === "codex") void sessions.recheckSetup();
+    },
+    updateAgent: (id, patch) => {
+      const agent = hub.cfg(str(id));
+      if (!agent) return;
+      const p = patch ?? {};
+      const before = `${agent.cli}/${agent.mode}`;
+      for (const k of ["name", "role", "model", "color", "roleMd"]) if (typeof p[k] === "string") agent[k] = str(p[k], 8e3);
+      if (p.mode === "sandbox" || p.mode === "local") agent.mode = p.mode;
+      if ((p.cli === "claude" || p.cli === "codex") && p.cli !== agent.cli) {
+        agent.cli = p.cli;
+        if (typeof p.model !== "string") agent.model = "";
+      }
+      if (Array.isArray(p.skills)) agent.skills = p.skills.map((s) => str(s, 60)).filter(Boolean);
+      if (p.workspacePath !== void 0) agent.workspacePath = p.workspacePath ? str(p.workspacePath, 500).trim() || null : null;
+      hub.configChanged();
+      if (`${agent.cli}/${agent.mode}` !== before) void sessions.recheckSetup();
+    },
+    inspectWorkspace: async (id) => {
+      const info = await sessions.inspectWorkspace(str(id, 80));
+      if (info) hub.emit({ type: "workspace.info", info });
+    },
+    removeAgent: async (id, opts) => {
+      const agent = hub.cfg(str(id));
+      if (!agent || agent.isLead) return;
+      const o = opts ?? {};
+      const removed = await sessions.removeResources(agent.id, { deleteSandbox: o.deleteSandbox !== false, deleteFolder: o.deleteFolder === true });
+      hub.snap.config.team = team().filter((a) => a.id !== agent.id);
+      hub.snap.agents = hub.snap.agents.filter((a) => a.agentId !== agent.id);
+      inbox.forget(agent.id);
+      mcp.forget(agent.id);
+      for (const t2 of hub.snap.tasks)
+        if (t2.ownerId === agent.id && t2.status !== "done") {
+          t2.ownerId = null;
+          if (t2.status === "in-progress") t2.status = "todo";
+          hub.emit({ type: "task.updated", task: { ...t2 } });
+        }
+      hub.planChanged();
+      hub.emit({ type: "agent.removed", agentId: agent.id });
+      hub.configChanged();
+      const what = removed.length ? ` Deleted: ${removed.join(" and ")}.` : "";
+      const kept = removed.includes("folder") ? "" : " Their folder is kept.";
+      hub.activity("config", null, `Removed ${agent.name}.${what}${kept}`);
+    },
+    updateSandbox: (id, patch) => {
+      const agent = hub.cfg(str(id));
+      if (!agent) return;
+      const p = patch ?? {};
+      const clean = (list) => [...new Set(list.map((d) => str(d, 200).trim().toLowerCase()).filter(Boolean))];
+      const rulesChanged = Array.isArray(p.allow) || Array.isArray(p.deny);
+      if (Array.isArray(p.allow)) agent.sandbox.allow = clean(p.allow);
+      if (Array.isArray(p.deny)) agent.sandbox.deny = clean(p.deny);
+      if (p.resources) {
+        const m = hub.snap.setup.machine;
+        const cpus2 = p.resources.cpus === null ? null : Math.round(Math.min(m.cpus, Math.max(1, num(p.resources.cpus))));
+        const maxMem = Math.max(0.5, Math.floor(m.memoryGb * 0.75 * 2) / 2);
+        const memoryGb = p.resources.memoryGb === null ? null : Math.min(maxMem, Math.max(0.5, Math.round(num(p.resources.memoryGb) * 2) / 2));
+        agent.sandbox.resources = { cpus: cpus2, memoryGb };
+      }
+      hub.configChanged();
+      if (rulesChanged) void sbx.syncRules(agent.id);
+    },
+    setSecret: (id, service, value) => {
+      const agentId = id === null ? null : str(id, 80);
+      const svc = str(service, 40);
+      if (!SERVICE_KEYS.includes(svc) || typeof value !== "string" || !value.trim()) return;
+      if (agentId && !hub.cfg(agentId)) return;
+      return attempt(agentId, `Stored the ${svc} key ${agentId ? `for ${hub.name(agentId)}'s sandbox` : "for every sandbox"}`, () => sbx.setKey(agentId, svc, value));
+    },
+    removeSecret: (id, service) => {
+      const agentId = id === null ? null : str(id, 80);
+      const svc = str(service, 40);
+      if (!SERVICE_KEYS.includes(svc)) return;
+      return attempt(agentId, `Removed the ${svc} key ${agentId ? `from ${hub.name(agentId)}'s sandbox` : "from every sandbox"}`, () => sbx.removeKey(agentId, svc));
+    },
+    setProxy: (url) => {
+      const u = typeof url === "string" && url.trim() ? str(url, 300).trim() : null;
+      if (u && !/^https?:\/\/[^\s]+$/i.test(u)) return hub.activity("config", null, "Proxy must be an http(s):// URL");
+      return attempt(null, u ? `Set the sandbox proxy to ${u}` : "Removed the sandbox proxy", () => sbx.setProxy(u));
+    },
+    openEnvFile: async (id) => {
+      const agent = hub.cfg(str(id, 80));
+      if (!agent) return;
+      const file = sbx.ensureEnvFile(agent.id);
+      const [cmd, args] = process.platform === "darwin" ? ["open", ["-t", file]] : process.platform === "win32" ? ["notepad", [file]] : ["xdg-open", [file]];
+      await run(cmd, args, { timeoutMs: 5e3 });
+      await sbx.refresh();
+    },
+    refreshSbx: () => sbx.refresh(),
+    resolveActionItem: (id, decision, note) => {
+      const d = decision === "done" || decision === "dismissed" ? decision : null;
+      if (d) planner.actions?.resolve(str(id, 40), d, typeof note === "string" ? str(note, 1e3) : void 0);
+    },
+    refreshMcp: () => mcp.refresh(),
+    addMcp: (raw) => {
+      const v = raw ?? {};
+      return mcp.add({
+        name: str(v.name, 40),
+        url: str(v.url, 500) || void 0,
+        command: str(v.command, 300) || void 0,
+        args: Array.isArray(v.args) ? v.args.slice(0, 20).map((a) => str(a, 200)) : void 0,
+        apiKey: str(v.apiKey, 4e3) || void 0
+      });
+    },
+    authMcp: (name) => mcp.authorize(str(name, 40)),
+    removeMcp: (name) => mcp.remove(str(name, 40)),
+    setAgentMcp: (agentId, names) => mcp.setAgent(str(agentId, 80), Array.isArray(names) ? names.slice(0, 50).map((n) => str(n, 40)) : []),
+    answerApproval: (agentId, approvalId, decision) => {
+      const d = decision === "allow" || decision === "dismiss" ? decision : null;
+      if (d) return sbx.answerApproval(str(agentId, 80), str(approvalId, 120), d);
+    },
+    /** Saves the project's stack (sanitised against the catalog). The agents get it in ROLE.md on their next start. */
+    updateStack: (raw) => {
+      const cfg = hub.snap.config;
+      const stack = cleanStack(raw);
+      if (!stack) {
+        delete cfg.stack;
+        return hub.configChanged();
+      }
+      cfg.stack = stack;
+      hub.configChanged();
+      const specs = stackSkills(cfg.stack);
+      if (specs.length) void ensureSkillCache(hub.slug, specs).catch((e) => hub.activity("config", null, `Couldn't fetch agent skills: ${String(e instanceof Error ? e.message : e).slice(0, 160)}`));
+    },
+    resolveAccess: (id, decision) => {
+      const d = decision === "agent" || decision === "everyone" || decision === "deny" ? decision : null;
+      if (d) return resolveAccess(hub, sbx, planner, str(id, 40), d);
+    },
+    completeWelcome: async (raw) => {
+      if (!hub.snap.welcome) return;
+      const input = raw ?? {};
+      const cli = (c) => c === "codex" ? "codex" : "claude";
+      const used = /* @__PURE__ */ new Set();
+      const make = (name, role, agentCli, isLead) => {
+        const clean = str(name, 40).trim() || (isLead ? "Lead" : "Agent");
+        let id = slug(clean);
+        for (let i = 2; used.has(id); i++) id = `${slug(clean)}-${i}`;
+        used.add(id);
+        const agent = newAgent(id, clean, isLead ? "Lead" : str(role, 40).trim() || "Developer", agentPalette[used.size - 1] ?? agentPalette[0], isLead);
+        agent.cli = agentCli;
+        return agent;
+      };
+      const lead = make(input.lead?.name ?? LEAD_NAME, "Lead", cli(input.lead?.cli), true);
+      const workers = (Array.isArray(input.workers) ? input.workers : []).slice(0, 11).map((w) => make(w?.name ?? "", w?.role ?? "", cli(w?.cli), false));
+      if (!workers.length) return hub.activity("config", null, "Add at least one worker to the team.");
+      const cfg = hub.snap.config;
+      if (typeof input.projectName === "string" && input.projectName.trim()) cfg.project.name = str(input.projectName, 80).trim();
+      cfg.team = [lead, ...workers];
+      const tools = ["coderabbit", "greptile", "copilot", "human", "custom"];
+      if (tools.includes(input.reviewTool)) cfg.workflow.review.tool = input.reviewTool;
+      if (typeof input.reviewEnabled === "boolean") cfg.workflow.review.enabled = input.reviewEnabled;
+      const stack = cleanStack(input.stack);
+      if (stack) {
+        cfg.stack = stack;
+        const specs = stackSkills(stack);
+        if (specs.length) void ensureSkillCache(hub.slug, specs).catch(() => {
+        });
+      }
+      hub.snap.agents = cfg.team.map((a) => Hub.freshStatus(a.id));
+      hub.snap.welcome = false;
+      hub.configChanged();
+      hub.planChanged();
+      await sessions.recheckSetup();
+      await sbx.refresh();
+      hub.emit({ type: "snapshot", snapshot: structuredClone(hub.snap) });
+      hub.activity("config", null, `Welcome! Team created: ${cfg.team.map((a) => a.name).join(", ")}. Press Start team when you're ready.`);
+    },
+    updateWorkflow: (patch) => {
+      const p = patch ?? {};
+      const wf = hub.snap.config.workflow;
+      const mergeBy = wf.merge.by;
+      Object.assign(wf.review, p.review ?? {});
+      if (p.merge?.by === "human" || p.merge?.by === "lead") wf.merge.by = p.merge.by;
+      Object.assign(wf.deploy, p.deploy ?? {});
+      hub.configChanged();
+      const lead = hub.snap.config.team.find((a) => a.isLead);
+      if (lead && wf.merge.by !== mergeBy) {
+        const waiting = hub.snap.pullRequests.filter((pr) => pr.review === "passed" && !pr.merged && !pr.closed).map((pr) => pr.number);
+        planner.notify(lead.id, mergeByNotice(wf.merge.by, waiting));
+      }
+    },
+    updateProject: (patch) => {
+      const p = patch ?? {};
+      const project = hub.snap.config.project;
+      if (typeof p.name === "string" && p.name.trim()) project.name = str(p.name, 80);
+      if (typeof p.repo === "string" && p.repo.trim()) project.repo = str(p.repo, 200);
+      if (typeof p.officeName === "string") {
+        const name = p.officeName.trim().slice(0, OFFICE_NAME_MAX);
+        if (name) project.officeName = name;
+        else delete project.officeName;
+      }
+      const exportOn = typeof p.exportPlan === "boolean" && p.exportPlan && !project.exportPlan;
+      if (typeof p.exportPlan === "boolean") project.exportPlan = p.exportPlan;
+      hub.configChanged();
+      if (exportOn) {
+        hub.planChanged();
+        hub.activity("config", null, "Plan export on: HQ writes docs/plan.md whenever the plan changes.");
+      }
+    },
+    createBoard: (title) => planner.createBoard(str(title, 80)),
+    updateBoard: (id, patch) => {
+      const p = patch ?? {};
+      const status = p.status === "active" || p.status === "planned" || p.status === "done" ? p.status : void 0;
+      planner.updateBoard(str(id, 20), { title: typeof p.title === "string" ? p.title : void 0, status });
+    }
+  };
+  return commands;
+}
+
+// server/http.ts
+import { createReadStream, existsSync as existsSync4, statSync } from "node:fs";
+import { createServer } from "node:http";
+import { extname, join as join7, normalize } from "node:path";
+import { timingSafeEqual } from "node:crypto";
+import { WebSocketServer } from "ws";
+
+// server/hooks.ts
+var clip = (s, n = 80) => s.length > n ? s.slice(0, n - 1) + "\u2026" : s;
+var turnOpen = /* @__PURE__ */ new Map();
+function handleHook(hub, inbox, agentId, event, body) {
+  const st = hub.status(agentId);
+  const name = hub.name(agentId);
+  if (!st) return { ok: false };
+  inbox.noteHook(agentId, event);
+  switch (event) {
+    case "SessionStart":
+      turnOpen.set(agentId, false);
+      hub.setStatus(agentId, { state: "idle", note: "Ready" });
+      break;
+    case "UserPromptSubmit":
+      turnOpen.set(agentId, true);
+      hub.setStatus(agentId, { state: "working", note: body.prompt ? clip(body.prompt.replace(/\s+/g, " ")) : null });
+      if (st.state !== "working") hub.activity("task.started", agentId, `${name} is working`);
+      break;
+    case "PreToolUse":
+      if (turnOpen.get(agentId) === false) break;
+      if (st.state !== "working" || st.note?.startsWith("Asking")) hub.setStatus(agentId, { state: "working", note: body.tool_name ? `Using ${body.tool_name}` : null });
+      break;
+    case "PostToolUse":
+      if (turnOpen.get(agentId) === false) break;
+      if (st.state === "needs-input") hub.setStatus(agentId, { state: "working", note: "Continuing after your answer" });
+      break;
+    case "PermissionRequest": {
+      const what = body.tool_name ? `Approve ${body.tool_name}?` : "Approval needed in the terminal";
+      hub.setStatus(agentId, { state: "needs-input", note: `Asking: ${what}` });
+      hub.activity("agent.needs-input", agentId, `${name} needs you: ${what}`);
+      break;
+    }
+    case "Notification": {
+      const msg = body.message ?? "Needs your attention";
+      if (/waiting for your input/i.test(msg) || body.notification_type === "idle_prompt") {
+        hub.setStatus(agentId, { state: "idle", note: "Waiting for you" });
+        break;
+      }
+      hub.setStatus(agentId, { state: "needs-input", note: `Asking: ${clip(msg)}` });
+      hub.activity("agent.needs-input", agentId, `${name} needs you: ${clip(msg, 60)}`);
+      break;
+    }
+    case "Stop": {
+      const queued = inbox.takeForStop(agentId);
+      if (queued) {
+        turnOpen.set(agentId, true);
+        hub.setStatus(agentId, { state: "working", note: "Reading new messages" });
+        return { ok: true, response: { decision: "block", reason: queued } };
+      }
+      turnOpen.set(agentId, false);
+      hub.setStatus(agentId, { state: "idle", note: "Finished \u2014 ready for the next instruction" });
+      hub.activity("agent.answered", agentId, `${name} finished a turn`);
+      break;
+    }
+    case "SessionEnd":
+      turnOpen.set(agentId, false);
+      hub.setStatus(agentId, { state: "idle", note: "Session ended" });
+      break;
+    default:
+      return { ok: false };
+  }
+  return { ok: true };
+}
+
+// server/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { z } from "zod";
+var ok = (value) => ({ content: [{ type: "text", text: typeof value === "string" ? value : JSON.stringify(value, null, 2) }] });
+var fail = (msg) => ({ content: [{ type: "text", text: msg }], isError: true });
+function guard(fn) {
+  return async (args) => {
+    try {
+      return fn(args);
+    } catch (err) {
+      return fail(err instanceof Error ? err.message : String(err));
+    }
+  };
+}
+function buildServer(hub, planner, me) {
+  const server = new McpServer({ name: "hq", version: "0.1.0" });
+  const isLead = !!hub.cfg(me)?.isLead;
+  const leadOnly = () => {
+    if (!isLead) throw new Error("Only the lead can do this. Ask the lead with send_message.");
+  };
+  const taskView = (id) => {
+    const t2 = planner.task(id);
+    return t2 && { ...t2, owner: t2.ownerId ? hub.name(t2.ownerId) : null };
+  };
+  server.registerTool(
+    "list_workers",
+    { description: "The team: each agent's id, name, role, whether they are running, and what they are doing now." },
+    guard(
+      () => ok(
+        hub.snap.config.team.map((a) => {
+          const st = hub.status(a.id);
+          return {
+            id: a.id,
+            name: a.name,
+            role: a.role,
+            lead: a.isLead,
+            you: a.id === me,
+            running: st?.session.state === "running",
+            state: st?.state,
+            task: st?.currentTaskId ?? null,
+            free: st?.session.state === "running" && !a.isLead && !planner.currentTask(a.id)
+          };
+        })
+      )
+    )
+  );
+  server.registerTool(
+    "get_status",
+    { description: "Live status of every agent (state, note, current task) plus the active boards with task counts." },
+    guard(
+      () => ok({
+        agents: hub.snap.agents.map((s) => ({ id: s.agentId, name: hub.name(s.agentId), state: s.state, note: s.note, task: s.currentTaskId, session: s.session.state })),
+        boards: hub.snap.boards.map((b) => {
+          const ts = hub.snap.tasks.filter((t2) => t2.boardId === b.id);
+          const n = (st) => ts.filter((t2) => t2.status === st).length;
+          return { id: b.id, title: b.title, status: b.status, todo: n("todo"), inProgress: n("in-progress"), inReview: n("in-review"), blocked: n("blocked"), done: n("done") };
+        })
+      })
+    )
+  );
+  server.registerTool(
+    "list_tasks",
+    {
+      description: "Tasks, optionally filtered by board, status or owner.",
+      inputSchema: {
+        boardId: z.string().optional().describe("Board id, e.g. P3"),
+        status: z.enum(["todo", "in-progress", "in-review", "done", "blocked"]).optional(),
+        owner: z.string().optional().describe("Agent id or name")
+      }
+    },
+    guard(({ boardId, status, owner }) => {
+      const ownerId = owner ? planner.agentId(owner) : void 0;
+      const list = hub.snap.tasks.filter((t2) => (!boardId || t2.boardId === boardId) && (!status || t2.status === status) && (!owner || t2.ownerId === ownerId));
+      return ok(list.map((t2) => ({ id: t2.id, board: t2.boardId, title: t2.title, status: t2.status, owner: t2.ownerId ? hub.name(t2.ownerId) : null, needs: t2.needs })));
+    })
+  );
+  server.registerTool(
+    "create_board",
+    { description: "Lead only. Create a board (a phase or an area of work).", inputSchema: { title: z.string(), active: z.boolean().optional().describe("Agents only pick tasks from active boards") } },
+    guard(({ title, active }) => {
+      leadOnly();
+      return ok(planner.createBoard(title, active ? "active" : "planned"));
+    })
+  );
+  server.registerTool(
+    "create_task",
+    {
+      description: "Lead only. Add a task. Keep tasks small: one task = one branch = one PR.",
+      inputSchema: {
+        title: z.string(),
+        boardId: z.string().optional().describe("Defaults to the first active board"),
+        description: z.string().optional().describe("What to build and why"),
+        files: z.array(z.string()).optional().describe("The only files/folders this task may edit"),
+        doneWhen: z.string().optional().describe("Acceptance criteria"),
+        needs: z.array(z.string()).optional().describe("Task ids that must be done first")
+      }
+    },
+    guard((args) => {
+      leadOnly();
+      return ok(planner.createTask(args, me));
+    })
+  );
+  server.registerTool(
+    "update_task",
+    {
+      description: "Lead only. Edit a task's details or status.",
+      inputSchema: {
+        taskId: z.string(),
+        title: z.string().optional(),
+        description: z.string().optional(),
+        files: z.array(z.string()).optional(),
+        doneWhen: z.string().optional(),
+        needs: z.array(z.string()).optional(),
+        status: z.enum(["todo", "in-progress", "in-review", "done", "blocked"]).optional()
+      }
+    },
+    guard(({ taskId, ...patch }) => {
+      leadOnly();
+      return ok(planner.updateTask(taskId, patch));
+    })
+  );
+  server.registerTool(
+    "assign_task",
+    {
+      description: "Lead only. Give a task to an agent. HQ tells them to pull main and start it (right away if idle, otherwise when their current turn ends).",
+      inputSchema: { taskId: z.string(), agent: z.string().describe("Agent id or name") }
+    },
+    guard(({ taskId, agent }) => {
+      leadOnly();
+      const t2 = planner.assign(taskId, agent, me);
+      return ok(`Assigned ${t2.id} to ${hub.name(t2.ownerId)}. They have been told to start.`);
+    })
+  );
+  server.registerTool(
+    "get_my_task",
+    { description: "Your current task: title, description, the files you may edit, done-when, and what it needs. Marks it in progress." },
+    guard(() => {
+      const t2 = planner.currentTask(me);
+      if (!t2) return ok("You have no task right now. Wait for the lead, or ask with send_message.");
+      if (t2.status === "todo") planner.setStatus(me, "in-progress");
+      const blockedBy = t2.needs.filter((n) => planner.task(n)?.status !== "done");
+      return ok({ ...taskView(t2.id), waitingOn: blockedBy, rules: "Work only on this task, on its own branch. Edit only the listed files. Title the PR `[" + t2.id + "] " + t2.title + "`. When the PR is open, call set_my_status with in-review and the PR number." });
+    })
+  );
+  server.registerTool(
+    "set_my_status",
+    {
+      description: "Update your current task: in-progress, blocked (say why), in-review (PR opened), or done. The lead is told automatically.",
+      inputSchema: {
+        status: z.enum(["in-progress", "blocked", "in-review", "done"]),
+        note: z.string().optional().describe("Why you are blocked, or a short summary"),
+        prNumber: z.number().int().optional()
+      }
+    },
+    guard(({ status, note, prNumber }) => {
+      const t2 = planner.setStatus(me, status, note, prNumber);
+      return ok(`${t2.id} is now ${t2.status}.`);
+    })
+  );
+  server.registerTool(
+    "ask_user",
+    {
+      description: "Ask the user to do something you can't do from your sandbox: create an account, database or API key, change a setting in a dashboard (Vercel, Supabase\u2026), or put a value in your env file. It goes to their Action items list. Give a short title and clear steps. Never include secret values; name the variable instead. HQ messages you when they've done it. For a variable you need, write: add NAME to <your name>'s App variables in HQ (Settings \u2192 Sandbox \u2192 App variables), then restart <your name>. For a site you need, use request_access instead.",
+      inputSchema: {
+        title: z.string().describe("What to do, in a few words"),
+        details: z.string().describe("The exact steps: where to go, what to create, which variable name, where to put it, and whether you need a restart. No secret values."),
+        waiting: z.boolean().optional().describe("True if you can't continue without it")
+      }
+    },
+    guard(({ title, details, waiting }) => {
+      if (!planner.actions) throw new Error("Action items aren't available.");
+      if (!details.trim()) throw new Error("Add the steps in details, so the user knows exactly what to do.");
+      const item = planner.actions.add(me, title, details, !!waiting);
+      return ok(`Added to the user's Action items (${item.id}). ${waiting ? "Wait for HQ's message, or work on something else meanwhile." : "Keep working; HQ will message you when it's done."}`);
+    })
+  );
+  server.registerTool(
+    "request_access",
+    {
+      description: "Your sandbox blocks most websites and APIs. When a request you need is blocked (docs or an API), ask the user to allow that domain. Pass the host (e.g. docs.example.com) and why you need it. The user answers in HQ; you'll get a message.",
+      inputSchema: { domain: z.string(), reason: z.string() }
+    },
+    guard(({ domain, reason }) => ok(requestAccess(hub, me, domain, reason)))
+  );
+  server.registerTool(
+    "send_message",
+    {
+      description: 'Send a message to another agent (id, name, or "lead"). HQ delivers it: right away if they are idle, otherwise when their current turn ends.',
+      inputSchema: { to: z.string(), text: z.string() }
+    },
+    guard(({ to, text }) => {
+      const toId = planner.agentId(to);
+      if (toId === me) throw new Error("That's you.");
+      planner.message(me, to, text);
+      return ok(`Sent to ${hub.name(toId)}.`);
+    })
+  );
+  return server;
+}
+async function handleMcp(hub, planner, agentId, req, res, body) {
+  const server = buildServer(hub, planner, agentId);
+  const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0, enableJsonResponse: true });
+  res.on("close", () => {
+    void transport.close();
+    void server.close();
+  });
+  await server.connect(transport);
+  await transport.handleRequest(req, res, body);
+}
+
+// server/http.ts
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript",
+  ".css": "text/css",
+  ".svg": "image/svg+xml",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".png": "image/png",
+  ".json": "application/json"
+};
+function safeEqual(a, b) {
+  const x = Buffer.from(a);
+  const y = Buffer.from(b);
+  return x.length === y.length && timingSafeEqual(x, y);
+}
+function readBody(req, limit = 256 * 1024) {
+  return new Promise((resolve5, reject) => {
+    let size = 0;
+    const chunks = [];
+    req.on("data", (c) => {
+      size += c.length;
+      if (size > limit) reject(new Error("too large"));
+      else chunks.push(c);
+    });
+    req.on("end", () => resolve5(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+function startHttp(o) {
+  const send = (res, code, body, type = "text/plain") => {
+    res.writeHead(code, { "Content-Type": type });
+    res.end(body);
+  };
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (req.method === "POST" && url.pathname.startsWith("/hook/")) {
+      const auth = req.headers.authorization ?? "";
+      if (!safeEqual(auth, `Bearer ${o.agentToken}`)) return send(res, 401, "unauthorized");
+      const [, , agentId, event] = url.pathname.split("/");
+      try {
+        const body = await readBody(req);
+        const r = handleHook(o.hub, o.inbox, decodeURIComponent(agentId ?? ""), event ?? "", body ? JSON.parse(body) : {});
+        if (!r.ok) return send(res, 404, "");
+        if (r.response) return send(res, 200, JSON.stringify(r.response), "application/json");
+        res.writeHead(204);
+        return void res.end();
+      } catch {
+        return send(res, 400, "bad request");
+      }
+    }
+    if (url.pathname === "/mcp") {
+      const auth = req.headers.authorization ?? "";
+      const agentId = String(req.headers["x-hq-agent"] ?? "");
+      if (!safeEqual(auth, `Bearer ${o.agentToken}`) || !o.hub.cfg(agentId)) return send(res, 401, "unauthorized");
+      if (req.method === "GET" || req.method === "DELETE") return send(res, 405, "stateless server");
+      try {
+        const raw = await readBody(req, 1024 * 1024);
+        return await handleMcp(o.hub, o.planner, agentId, req, res, raw ? JSON.parse(raw) : void 0);
+      } catch {
+        return res.headersSent ? void res.end() : send(res, 400, "bad request");
+      }
+    }
+    if (url.pathname === "/api/health") return send(res, 200, JSON.stringify({ ok: true }), "application/json");
+    if (req.method === "GET" && o.distDir) {
+      const rel = normalize(url.pathname === "/" ? "/index.html" : url.pathname).replace(/^(\.\.[/\\])+/, "");
+      let file = join7(o.distDir, rel);
+      if (!file.startsWith(o.distDir) || !existsSync4(file) || statSync(file).isDirectory()) file = join7(o.distDir, "index.html");
+      res.writeHead(200, { "Content-Type": MIME[extname(file)] ?? "application/octet-stream" });
+      return void createReadStream(file).pipe(res);
+    }
+    send(res, 404, "not found");
+  });
+  const wss = new WebSocketServer({ noServer: true, maxPayload: 1024 * 1024 });
+  server.on("upgrade", (req, socket, head) => {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    const origin = req.headers.origin ?? "";
+    const token = url.searchParams.get("token") ?? "";
+    if (url.pathname !== "/ws" || !safeEqual(token, o.browserToken) || origin && !o.allowedOrigins.includes(origin)) {
+      socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+      return socket.destroy();
+    }
+    wss.handleUpgrade(req, socket, head, (ws) => onClient(ws));
+  });
+  function onClient(ws) {
+    const sendEvent = (e) => ws.readyState === ws.OPEN && ws.send(JSON.stringify(e));
+    sendEvent({ type: "snapshot", snapshot: o.hub.snap });
+    const unsub = o.hub.subscribe(sendEvent);
+    ws.on("message", async (raw) => {
+      try {
+        const msg = JSON.parse(String(raw));
+        const fn = msg.cmd ? o.commands[msg.cmd] : void 0;
+        if (!fn) return log.warn("unknown command", msg.cmd);
+        await fn(...Array.isArray(msg.args) ? msg.args : []);
+      } catch (err) {
+        log.warn("command failed:", err instanceof Error ? err.message : err);
+      }
+    });
+    ws.on("close", () => unsub());
+  }
+  return new Promise((resolve5, reject) => {
+    server.once("error", reject);
+    server.listen(o.port, "127.0.0.1", () => resolve5(server));
+  });
+}
+
+// server/inbox.ts
+var QUIET_MS = 1e3;
+var SUBMIT_CHECK_MS = 3e3;
+var Inbox = class {
+  constructor(hub, keys) {
+    this.hub = hub;
+    this.keys = keys;
+    this.timer = setInterval(() => {
+      for (const id of this.queues.keys()) void this.tryType(id);
+    }, 2e3);
+  }
+  hub;
+  keys;
+  queues = /* @__PURE__ */ new Map();
+  sessionUp = /* @__PURE__ */ new Set();
+  // SessionStart seen: Claude Code's prompt exists
+  lastHook = /* @__PURE__ */ new Map();
+  lastSubmit = /* @__PURE__ */ new Map();
+  typing = /* @__PURE__ */ new Set();
+  timer;
+  stop() {
+    clearInterval(this.timer);
+  }
+  push(agentId, item) {
+    const q2 = this.queues.get(agentId) ?? [];
+    q2.push(item);
+    this.queues.set(agentId, q2);
+    void this.tryType(agentId);
+  }
+  /** When the agent's last hook arrived (0 if never). */
+  lastHookAt(agentId) {
+    return this.lastHook.get(agentId) ?? 0;
+  }
+  pending(agentId) {
+    return this.queues.get(agentId)?.length ?? 0;
+  }
+  /** Every hook event goes through here (before the state change it causes). */
+  noteHook(agentId, event) {
+    this.lastHook.set(agentId, Date.now());
+    if (event === "SessionStart") this.sessionUp.add(agentId);
+    if (event === "SessionEnd") this.sessionUp.delete(agentId);
+    if (event === "UserPromptSubmit") this.lastSubmit.set(agentId, Date.now());
+    if (event === "Stop" || event === "SessionStart" || event === "Notification") setTimeout(() => void this.tryType(agentId), QUIET_MS + 100);
+  }
+  /** An already-running session was reattached: its prompt exists even though HQ missed SessionStart. */
+  sessionReattached(agentId) {
+    this.sessionUp.add(agentId);
+  }
+  /** The session stopped or restarted: Claude Code's prompt is gone until the next SessionStart. */
+  sessionDown(agentId) {
+    this.sessionUp.delete(agentId);
+  }
+  forget(agentId) {
+    this.queues.delete(agentId);
+    this.sessionUp.delete(agentId);
+  }
+  /** Called from the Stop hook: everything queued, as the reason Claude continues with. */
+  takeForStop(agentId) {
+    const q2 = this.queues.get(agentId);
+    if (!q2?.length) return null;
+    this.queues.set(agentId, []);
+    return this.format(q2);
+  }
+  canType(agentId) {
+    const st = this.hub.status(agentId);
+    return !!st && this.sessionUp.has(agentId) && st.session.state === "running" && st.state === "idle" && !this.typing.has(agentId) && Date.now() - (this.lastHook.get(agentId) ?? 0) >= QUIET_MS;
+  }
+  whyNot(agentId) {
+    const st = this.hub.status(agentId);
+    return JSON.stringify({ up: this.sessionUp.has(agentId), session: st?.session.state, state: st?.state, note: st?.note, typing: this.typing.has(agentId), quietMs: Date.now() - (this.lastHook.get(agentId) ?? 0) });
+  }
+  /** Types queued items into an idle agent. Safe to call any time. */
+  async tryType(agentId) {
+    const q2 = this.queues.get(agentId);
+    if (!q2?.length) return;
+    if (!this.canType(agentId)) {
+      if (process.env.HQ_DEBUG) log.info(`inbox ${agentId}: holding ${q2.length} \u2014 ${this.whyNot(agentId)}`);
+      return;
+    }
+    const items = q2.splice(0);
+    this.typing.add(agentId);
+    const typedAt = Date.now();
+    try {
+      if (!await this.keys.type(agentId, this.format(items))) {
+        log.warn(`could not type into ${agentId}; keeping ${items.length} message(s) queued`);
+        this.queues.set(agentId, [...items, ...this.queues.get(agentId) ?? []]);
+        return;
+      }
+      await new Promise((r) => setTimeout(r, SUBMIT_CHECK_MS));
+      if ((this.lastSubmit.get(agentId) ?? 0) < typedAt && this.hub.status(agentId)?.state === "idle") {
+        log.warn(`${agentId}: no prompt submit after typing; pressing Enter again`);
+        await this.keys.enter(agentId);
+      }
+    } finally {
+      this.typing.delete(agentId);
+    }
+  }
+  format(items) {
+    const lines = items.map(
+      (i) => i.kind === "message" ? `[HQ] Message from ${this.hub.name(i.fromId)}: ${i.text}` : `[HQ] ${i.text}`
+    );
+    const fromAgent = items.some((i) => i.kind === "message" && i.fromId !== "you");
+    return (lines.join("  \xB7  ") + (fromAgent ? "  (Reply with the hq send_message tool only if a reply is needed.)" : "")).replace(/\s*\n\s*/g, " ");
+  }
+};
+
+// server/planner.ts
+var now2 = () => (/* @__PURE__ */ new Date()).toISOString();
+var Planner = class {
+  constructor(hub, inbox) {
+    this.hub = hub;
+    this.inbox = inbox;
+  }
+  hub;
+  inbox;
+  seq = 0;
+  /** Set by main: the user's action items (Team MCP `ask_user`). */
+  actions = null;
+  get snap() {
+    return this.hub.snap;
+  }
+  task(id) {
+    return this.snap.tasks.find((t2) => t2.id.toLowerCase() === id.trim().toLowerCase());
+  }
+  /** An agent by id or (case-insensitive) name; "lead" means the lead. */
+  agentId(ref) {
+    const r = ref.trim().toLowerCase();
+    const team = this.snap.config.team;
+    if (r === "lead") return team.find((a) => a.isLead)?.id ?? null;
+    return team.find((a) => a.id === r || a.name.toLowerCase() === r)?.id ?? null;
+  }
+  defaultBoard() {
+    const active = this.snap.boards.filter((b) => b.status === "active").sort((a, b) => a.order - b.order);
+    if (active[0]) return active[0];
+    return this.createBoard("Backlog", "active");
+  }
+  // ------------------------------------------------------------ boards
+  createBoard(title, status = "planned") {
+    const clean = title.trim().slice(0, 80) || "Board";
+    const base = clean.split(/\s+/).map((w) => w[0]).join("").toUpperCase().replace(/[^A-Z0-9]/g, "").slice(0, 3) || "B";
+    let id = base;
+    for (let i = 2; this.snap.boards.some((b) => b.id === id); i++) id = `${base}${i}`;
+    const board = { id, title: clean, status, order: this.snap.boards.length };
+    this.snap.boards.push(board);
+    this.hub.emit({ type: "board.updated", board: { ...board } });
+    this.hub.planChanged();
+    return board;
+  }
+  updateBoard(id, patch) {
+    const board = this.snap.boards.find((b) => b.id === id);
+    if (!board) throw new Error(`No board ${id}`);
+    if (patch.title?.trim()) board.title = patch.title.trim().slice(0, 80);
+    if (patch.status) board.status = patch.status;
+    this.hub.emit({ type: "board.updated", board: { ...board } });
+    this.hub.planChanged();
+    return board;
+  }
+  // ------------------------------------------------------------ tasks
+  createTask(input, byId) {
+    const board = input.boardId ? this.snap.boards.find((b) => b.id === input.boardId) : this.defaultBoard();
+    if (!board) throw new Error(`No board ${input.boardId}. Boards: ${this.snap.boards.map((b) => b.id).join(", ")}`);
+    let n = this.snap.tasks.filter((t2) => t2.boardId === board.id).length + 1;
+    let id = `${board.id}-T${String(n).padStart(2, "0")}`;
+    while (this.task(id)) id = `${board.id}-T${String(++n).padStart(2, "0")}`;
+    const task = {
+      id,
+      boardId: board.id,
+      title: input.title.trim().slice(0, 120),
+      ownerId: null,
+      status: "todo",
+      needs: input.needs ?? [],
+      prNumber: null,
+      description: input.description ?? "",
+      files: input.files ?? [],
+      doneWhen: input.doneWhen ?? "",
+      note: null
+    };
+    this.snap.tasks.push(task);
+    this.hub.emit({ type: "task.updated", task: { ...task } });
+    this.hub.activity("task.created", byId === "you" ? null : byId, `${this.hub.name(byId)} added ${task.id} ${task.title}`);
+    this.hub.planChanged();
+    return task;
+  }
+  updateTask(id, patch) {
+    const task = this.task(id);
+    if (!task) throw new Error(`No task ${id}`);
+    Object.assign(task, Object.fromEntries(Object.entries(patch).filter(([, v]) => v !== void 0)));
+    if (task.status === "done") {
+      for (const a of this.snap.agents) if (a.currentTaskId === task.id) this.hub.setStatus(a.agentId, { currentTaskId: null });
+    }
+    this.hub.emit({ type: "task.updated", task: { ...task } });
+    this.hub.planChanged();
+    return task;
+  }
+  /** Gives a task to an agent and tells them to start. */
+  assign(taskId, agentRef, byId) {
+    const task = this.task(taskId);
+    const agentId = this.agentId(agentRef);
+    if (!task) throw new Error(`No task ${taskId}`);
+    if (!agentId) throw new Error(`No agent "${agentRef}". Team: ${this.snap.config.team.map((a) => a.id).join(", ")}`);
+    const agent = this.hub.cfg(agentId);
+    task.ownerId = agentId;
+    if (task.status === "done") task.status = "todo";
+    this.hub.emit({ type: "task.updated", task: { ...task } });
+    this.hub.setStatus(agentId, { currentTaskId: task.id });
+    this.hub.planChanged();
+    this.hub.activity("task.assigned", byId === "you" ? null : byId, `${this.hub.name(byId)} assigned ${task.id} ${task.title} to ${agent.name}`);
+    const by = byId === "you" ? "The user (your human)" : this.hub.name(byId);
+    const text = `${by} assigned you ${task.id} (${task.title}). Pull main, start ${task.id}. Call the hq get_my_task tool for the details.`;
+    this.record(byId, agentId, `Start ${task.id}: ${task.title}`);
+    this.inbox.push(agentId, { fromId: byId, kind: "assign", text });
+    return task;
+  }
+  setStatus(agentId, status, note, prNumber) {
+    const task = this.currentTask(agentId);
+    if (!task) throw new Error("You have no task. Ask the lead for one.");
+    task.status = status;
+    task.note = note?.slice(0, 300) || null;
+    if (prNumber) task.prNumber = prNumber;
+    if (status === "done") this.hub.setStatus(agentId, { currentTaskId: null });
+    else this.hub.setStatus(agentId, { currentTaskId: task.id });
+    this.hub.emit({ type: "task.updated", task: { ...task } });
+    this.hub.planChanged();
+    const name = this.hub.name(agentId);
+    const words = { "in-progress": "started", blocked: "is blocked on", "in-review": "sent for review", done: "finished" }[status];
+    this.hub.activity(status === "blocked" ? "agent.needs-input" : "task.started", agentId, `${name} ${words} ${task.id}${note ? `: ${note}` : ""}`);
+    const lead = this.snap.config.team.find((a) => a.isLead);
+    if (lead && lead.id !== agentId && (status === "blocked" || status === "in-review" || status === "done"))
+      this.message(agentId, lead.id, `${task.id} ${words}${note ? `: ${note}` : ""}${prNumber ? ` (PR #${prNumber})` : ""}`);
+    return task;
+  }
+  currentTask(agentId) {
+    const st = this.hub.status(agentId);
+    const byCurrent = st?.currentTaskId ? this.task(st.currentTaskId) : void 0;
+    if (byCurrent && byCurrent.ownerId === agentId) return byCurrent;
+    const mine = this.snap.tasks.filter((t2) => t2.ownerId === agentId && t2.status !== "done");
+    return mine.find((t2) => t2.status === "in-progress") ?? mine.find((t2) => t2.status === "todo") ?? mine[0];
+  }
+  // ------------------------------------------------------------ messages
+  /** Records a message, shows it in the office, and delivers it. */
+  message(fromId, toRef, text) {
+    const toId = this.agentId(toRef);
+    if (!toId) throw new Error(`No agent "${toRef}". Team: ${this.snap.config.team.map((a) => a.id).join(", ")}`);
+    const clean = text.trim().slice(0, 2e3);
+    if (!clean) throw new Error("Empty message");
+    this.record(fromId, toId, clean);
+    this.hub.activity("message", fromId === "you" ? null : fromId, `${this.hub.name(fromId)} \u2192 ${this.hub.name(toId)}: ${clean.slice(0, 80)}`);
+    this.inbox.push(toId, { fromId, kind: "message", text: clean });
+    return toId;
+  }
+  /** A notice from HQ itself (review results, merges) to one agent. */
+  notify(agentId, text) {
+    if (!this.hub.cfg(agentId)) return;
+    this.record("hq", agentId, text);
+    this.inbox.push(agentId, { fromId: "hq", kind: "notice", text });
+  }
+  record(fromId, toId, text) {
+    this.seq += 1;
+    const msg = { id: `m${Date.now().toString(36)}${this.seq}`, at: now2(), fromId, toId, text };
+    this.snap.messages = [msg, ...this.snap.messages].slice(0, 100);
+    this.hub.emit({ type: "message", message: msg });
+  }
+};
+
+// server/actionItems.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, renameSync as renameSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join8 } from "node:path";
+
+// server/lib/json.ts
+function parseCliJson(text) {
+  const starts = [text.indexOf("{"), text.indexOf("[")].filter((i) => i !== -1);
+  if (!starts.length) return null;
+  const start = Math.min(...starts);
+  const end = text.lastIndexOf(text[start] === "{" ? "}" : "]");
+  if (end <= start) return null;
+  try {
+    return JSON.parse(text.slice(start, end + 1));
+  } catch {
+    return null;
+  }
+}
+function sandboxList(text) {
+  const data = parseCliJson(text);
+  if (data === null) return null;
+  return Array.isArray(data) ? data : data.sandboxes ?? [];
+}
+
+// server/actionItems.ts
+var KEEP_CLOSED = 100;
+var ActionItems = class {
+  constructor(hub, planner) {
+    this.hub = hub;
+    this.planner = planner;
+    this.file = join8(projectHome(hub.slug), "action-items.json");
+    const saved = existsSync5(this.file) ? parseCliJson(readFileSync5(this.file, "utf8")) : null;
+    hub.snap.actionItems = Array.isArray(saved) ? saved : [];
+  }
+  hub;
+  planner;
+  file;
+  seq = 0;
+  get items() {
+    return this.hub.snap.actionItems ??= [];
+  }
+  save() {
+    const open = this.items.filter((i) => i.status === "open");
+    const closed = this.items.filter((i) => i.status !== "open").slice(0, KEEP_CLOSED);
+    this.hub.snap.actionItems = [...open, ...closed].sort((a, b) => b.at.localeCompare(a.at));
+    const tmp = `${this.file}.${process.pid}.tmp`;
+    writeFileSync6(tmp, JSON.stringify(this.hub.snap.actionItems, null, 2));
+    renameSync2(tmp, this.file);
+  }
+  add(fromId, title, details, waiting) {
+    const clean = title.trim().replace(/\s+/g, " ").slice(0, 160);
+    if (!clean) throw new Error("Give the action item a short title.");
+    const item = {
+      id: `ai${Date.now().toString(36)}${++this.seq}`,
+      fromId,
+      taskId: this.planner.currentTask(fromId)?.id ?? null,
+      title: clean,
+      details: details.trim().slice(0, 4e3),
+      waiting,
+      status: "open",
+      note: null,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      closedAt: null
+    };
+    this.items.unshift(item);
+    this.save();
+    this.hub.emit({ type: "action.updated", item: { ...item } });
+    this.hub.activity("agent.needs-input", fromId, `${this.hub.name(fromId)} added an action item${waiting ? " (waiting)" : ""}: ${clean}`);
+    return item;
+  }
+  resolve(id, decision, note) {
+    const item = this.items.find((i) => i.id === id);
+    if (!item || item.status !== "open") return;
+    item.status = decision;
+    item.note = note?.trim().slice(0, 1e3) || null;
+    item.closedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.save();
+    this.hub.emit({ type: "action.updated", item: { ...item } });
+    const n = item.note ? ` Note from the user: ${item.note}` : "";
+    if (decision === "done") this.planner.notify(item.fromId, `The user did your action item "${item.title}".${n} Continue with it.`);
+    else this.planner.notify(item.fromId, `The user dismissed your action item "${item.title}".${n} Continue without it, or find another way.`);
+  }
+};
+
+// server/sbx.ts
+import { chmodSync, existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join9 } from "node:path";
+
+// server/setup.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "node:fs";
+import { arch, cpus, platform, release, totalmem } from "node:os";
+
+// server/backends/pty.ts
+import { spawn as spawnPty } from "@lydell/node-pty";
+import xtermHeadless from "@xterm/headless";
+var { Terminal } = xtermHeadless;
+var TERM_ENV = { ...process.env, TERM: "xterm-256color", COLORTERM: "truecolor" };
+var procs = /* @__PURE__ */ new Map();
+async function resolveCommand(file, args) {
+  if (process.platform !== "win32" || /[\\/]/.test(file)) return { file, args };
+  const r = await run("where", [file], { timeoutMs: 5e3 });
+  const found = r.stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  const exe = found.find((p) => /\.exe$/i.test(p));
+  if (exe) return { file: exe, args };
+  const script = found.find((p) => /\.(cmd|bat)$/i.test(p));
+  if (script) return { file: "cmd.exe", args: ["/d", "/s", "/c", script, ...args] };
+  throw new Error(`${file} was not found on PATH.`);
+}
+var ptyBackend = {
+  kind: "pty",
+  persistent: false,
+  async exists(name) {
+    return procs.has(name);
+  },
+  async create(name, cwd, spec, size) {
+    if (procs.has(name)) return;
+    const { file, args } = await resolveCommand(spec.file, spec.args);
+    const pty = spawnPty(file, args, { name: "xterm-256color", cols: size.cols, rows: size.rows, cwd, env: TERM_ENV });
+    const screen = new Terminal({ cols: size.cols, rows: size.rows, scrollback: 300, allowProposedApi: true });
+    const proc = { pty, screen, exit: { dead: false, exitStatus: null }, views: /* @__PURE__ */ new Set(), ends: /* @__PURE__ */ new Set() };
+    pty.onData((d) => {
+      screen.write(d);
+      for (const view of proc.views) view(d);
+    });
+    pty.onExit(({ exitCode }) => {
+      proc.exit = { dead: true, exitStatus: exitCode };
+    });
+    procs.set(name, proc);
+  },
+  async kill(name) {
+    const proc = procs.get(name);
+    if (!proc) return;
+    procs.delete(name);
+    if (!proc.exit.dead) proc.pty.kill();
+    proc.screen.dispose();
+    for (const end of proc.ends) end();
+  },
+  attach(name, size, onData, onEnd) {
+    const proc = procs.get(name);
+    if (!proc) {
+      queueMicrotask(onEnd);
+      return { write() {
+      }, resize() {
+      }, close() {
+      } };
+    }
+    proc.views.add(onData);
+    proc.ends.add(onEnd);
+    const resize = (cols, rows) => {
+      if (proc.exit.dead) return;
+      proc.pty.resize(cols, rows);
+      proc.screen.resize(cols, rows);
+    };
+    resize(size.cols, size.rows);
+    return {
+      write: (d) => !proc.exit.dead && proc.pty.write(d),
+      resize,
+      close: () => {
+        proc.views.delete(onData);
+        proc.ends.delete(onEnd);
+      }
+    };
+  },
+  async type(name, text) {
+    const proc = procs.get(name);
+    if (!proc || proc.exit.dead) return false;
+    proc.pty.write(text);
+    return true;
+  },
+  async enter(name) {
+    const proc = procs.get(name);
+    if (!proc || proc.exit.dead) return false;
+    proc.pty.write("\r");
+    return true;
+  },
+  async exitInfo(name) {
+    return procs.get(name)?.exit ?? null;
+  },
+  async screenText(name, lines) {
+    const proc = procs.get(name);
+    if (!proc) return "";
+    await new Promise((r) => proc.screen.write("", r));
+    const buf = proc.screen.buffer.active;
+    const out = [];
+    for (let i = 0; i < buf.length; i++) out.push(buf.getLine(i)?.translateToString(true).trimEnd() ?? "");
+    return out.filter(Boolean).slice(-lines).join("\n");
+  },
+  shutdown() {
+    for (const proc of procs.values()) if (!proc.exit.dead) proc.pty.kill();
+    procs.clear();
+  }
+};
+
+// server/backends/tmux.ts
+import { spawn as spawnPty2 } from "@lydell/node-pty";
+
+// server/backends/tmuxCli.ts
+async function hasSession(name) {
+  return (await run("tmux", ["has-session", "-t", `=${name}`], { timeoutMs: 5e3 })).ok;
+}
+async function newSession(name, cwd, command, env = {}) {
+  const args = ["new-session", "-d", "-s", name, "-x", "200", "-y", "50", "-c", cwd];
+  for (const [k, v] of Object.entries(env)) args.push("-e", `${k}=${v}`);
+  args.push(command);
+  const r = await run("tmux", args, { timeoutMs: 1e4 });
+  if (!r.ok) throw new Error(`tmux: ${r.stderr.trim()}`);
+  await run("tmux", ["set-option", "-t", name, "remain-on-exit", "on"], { timeoutMs: 5e3 });
+  await run("tmux", ["set-option", "-t", name, "mouse", "on"], { timeoutMs: 5e3 });
+  await run("tmux", ["set-option", "-t", name, "status", "off"], { timeoutMs: 5e3 });
+  await run("tmux", ["set-option", "-t", name, "focus-events", "on"], { timeoutMs: 5e3 });
+}
+async function killSession(name) {
+  await run("tmux", ["kill-session", "-t", `=${name}`], { timeoutMs: 5e3 });
+}
+async function paneInfo(name) {
+  const r = await run("tmux", ["display-message", "-p", "-t", `=${name}:`, "#{pane_dead} #{pane_dead_status}"], { timeoutMs: 5e3 });
+  if (!r.ok) return null;
+  const [dead, status] = r.stdout.trim().split(" ");
+  return { dead: dead === "1", exitStatus: status ? Number(status) : null };
+}
+async function tailText(name, n = 6) {
+  const r = await run("tmux", ["capture-pane", "-p", "-t", `=${name}:`], { timeoutMs: 5e3 });
+  return r.stdout.split("\n").map((l) => l.trimEnd()).filter(Boolean).slice(-n).join("\n");
+}
+
+// server/backends/tmux.ts
+var TERM_ENV2 = { ...process.env, TERM: "xterm-256color", COLORTERM: "truecolor" };
+var q = (s) => /^[A-Za-z0-9_\-.,:/=@%+]+$/.test(s) ? s : shq(s);
+var loadEnvFile = (quotedPath) => (
+  // CRLF files: drop the \r. Lines whose key isn't a valid name are skipped (export would stop the shell).
+  // Scratch names are unlikely to clash with app variables and are unset afterwards; the CR is
+  // computed per line, so nothing in the file can change it.
+  `while IFS= read -r __jsmhq_l || [ -n "$__jsmhq_l" ]; do __jsmhq_l=\${__jsmhq_l%"$(printf '\\r')"}; __jsmhq_k=\${__jsmhq_l%%=*}; case "$__jsmhq_l" in *=*) case "$__jsmhq_k" in ""|[!A-Za-z_]*|*[!A-Za-z0-9_]*) ;; *) export "$__jsmhq_l";; esac;; esac; done < ${quotedPath}; unset __jsmhq_l __jsmhq_k`
+);
+function shellCommand(spec) {
+  const load = spec.envFile ? `${loadEnvFile(shq(spec.envFile))} && ` : "";
+  return load + [spec.file, ...spec.args].map(q).join(" ");
+}
+var tmuxBackend = {
+  kind: "tmux",
+  persistent: true,
+  exists: (name) => hasSession(name),
+  async create(name, cwd, spec) {
+    await newSession(name, cwd, shellCommand(spec));
+  },
+  kill: (name) => killSession(name),
+  attach(name, size, onData, onEnd) {
+    const pty = spawnPty2("tmux", ["attach-session", "-t", `=${name}`], { name: "xterm-256color", cols: size.cols, rows: size.rows, env: TERM_ENV2 });
+    pty.onData(onData);
+    pty.onExit(onEnd);
+    return { write: (d) => pty.write(d), resize: (c, r) => pty.resize(c, r), close: () => pty.kill() };
+  },
+  async type(name, text) {
+    if (!await hasSession(name)) return false;
+    return (await run("tmux", ["send-keys", "-t", `=${name}:`, "-l", text], { timeoutMs: 5e3 })).ok;
+  },
+  async enter(name) {
+    return (await run("tmux", ["send-keys", "-t", `=${name}:`, "Enter"], { timeoutMs: 5e3 })).ok;
+  },
+  exitInfo: (name) => paneInfo(name),
+  screenText: (name, lines) => tailText(name, lines),
+  shutdown() {
+  }
+};
+
+// server/backends/index.ts
+function usesTmux() {
+  const forced = process.env.HQ_SESSION_BACKEND;
+  if (forced === "pty" || forced === "tmux") return forced === "tmux";
+  return process.platform !== "win32";
+}
+function sessionBackend() {
+  return usesTmux() ? tmuxBackend : ptyBackend;
+}
+
+// server/setup.ts
+var SBX_DOCS = "https://docs.docker.com/ai/sandboxes/install/";
+var os = platform();
+var fix = (command, runnable, docs) => ({ command, runnable, docs });
+async function checkOs() {
+  const base = { id: "os", label: "Machine supports sandboxes", neededFor: "sandbox", fix: fix("", false, SBX_DOCS) };
+  if (os === "darwin") {
+    const v = (await run("sw_vers", ["-productVersion"])).stdout.trim();
+    const major = Number(v.split(".")[0]);
+    if (arch() !== "arm64") return { ...base, status: "unsupported", detail: `macOS ${v} on Intel. Sandboxes need Apple silicon \u2014 use Local mode.` };
+    if (major < 14) return { ...base, status: "unsupported", detail: `macOS ${v}. Sandboxes need macOS 14 (Sonoma) or later.` };
+    return { ...base, status: "ok", detail: `macOS ${v} \xB7 Apple silicon`, fix: null };
+  }
+  if (os === "win32") {
+    const build = Number(release().split(".")[2] ?? 0);
+    return build >= 22e3 ? { ...base, status: "ok", detail: "Windows 11 (needs Windows Hypervisor Platform enabled)", fix: null } : { ...base, status: "unsupported", detail: "Windows 10. Sandboxes need Windows 11 \u2014 use Local mode." };
+  }
+  const osRelease = existsSync6("/etc/os-release") ? readFileSync6("/etc/os-release", "utf8") : "";
+  const id = osRelease.match(/^ID=(.*)$/m)?.[1]?.replace(/"/g, "");
+  const ver = Number(osRelease.match(/^VERSION_ID="?([\d.]+)/m)?.[1] ?? 0);
+  if (id === "ubuntu" && ver >= 24.04) return { ...base, status: "ok", detail: `Ubuntu ${ver} (needs KVM)`, fix: null };
+  return { ...base, status: "warning", detail: `${id ?? "Linux"} ${ver || ""} \u2014 Docker documents Ubuntu 24.04+ with KVM.` };
+}
+async function checkSbx(brew) {
+  const base = { id: "sbx", label: "Docker Sandboxes (sbx)", neededFor: "sandbox" };
+  const v = await run("sbx", ["version"], { timeoutMs: 8e3 });
+  if (v.ok) return { ...base, status: "ok", detail: v.stdout.trim().split(/\s+/)[2] ?? v.stdout.trim(), fix: null };
+  const cmd = os === "darwin" ? "brew trust docker/tap && brew install docker/tap/sbx" : os === "win32" ? "winget install -h Docker.sbx" : "curl -fsSL https://get.docker.com | sudo SBX=1 sh";
+  const runnable = os === "darwin" ? brew : os === "win32";
+  return { ...base, status: "missing", detail: "Not installed.", fix: fix(cmd, runnable, SBX_DOCS) };
+}
+var POLICY_NOT_INITIALIZED = /not been initialized|sbx policy init/i;
+async function policyVerdict(host) {
+  const r = await run("sbx", ["policy", "check", "network", host], { timeoutMs: 1e4 });
+  const out = `${r.stdout}
+${r.stderr}`.replace(/\x1b(\[[0-9;?]*[ -\/]*[@-~]|\][^\x07\x1b]*(\x07|\x1b\\)|[@-_])/g, "");
+  const m = out.match(/\b(Allowed|Denied):/);
+  return { verdict: m ? m[1] === "Allowed" ? "allowed" : "denied" : null, out };
+}
+async function checkSbxPolicy(loginOk) {
+  const base = { id: "sbx-policy", label: "Sandbox network policy", neededFor: "sandbox" };
+  if (!loginOk) return { ...base, status: "missing", detail: "Waiting for Docker sign-in.", fix: null };
+  const { verdict, out } = await policyVerdict("registry.npmjs.org");
+  if (POLICY_NOT_INITIALIZED.test(out))
+    return {
+      ...base,
+      status: "missing",
+      detail: "Not set yet. Choose what sandboxes can reach once: balanced (recommended: AI services, package registries, GitHub), allow-all, or deny-all. Change it later with sbx policy reset.",
+      fix: fix("sbx policy init balanced", true, SBX_DOCS)
+    };
+  if (!verdict) return { ...base, status: "warning", detail: out.trim().split("\n")[0] || "sbx did not respond.", fix: fix("sbx diagnose", true, SBX_DOCS) };
+  const open = (await policyVerdict("hq-probe.invalid")).verdict === "allowed";
+  const name = open ? "Allow all" : verdict === "allowed" ? "Balanced" : "Deny all";
+  return { ...base, status: "ok", detail: `${name}. HQ adds only the rule that lets sandboxes reach it.`, fix: null };
+}
+async function checkSbxLogin(sbxOk) {
+  const base = { id: "sbx-login", label: "Signed in to Docker", neededFor: "sandbox" };
+  if (!sbxOk) return { ...base, status: "missing", detail: "Waiting for sbx.", fix: null };
+  const r = await run("sbx", ["ls", "--json"], { timeoutMs: 1e4 });
+  const list = r.ok ? sandboxList(r.stdout) : null;
+  if (r.ok) {
+    const n = list?.length;
+    return { ...base, status: "ok", detail: n === void 0 ? "Signed in" : `Signed in \xB7 ${n} sandbox${n === 1 ? "" : "es"} on this machine`, fix: null };
+  }
+  const msg = (r.stderr || r.stdout).trim();
+  const loggedOut = /log ?in|sign ?in|unauthori[sz]ed|not authenticated/i.test(msg);
+  return {
+    ...base,
+    status: loggedOut ? "missing" : "warning",
+    detail: loggedOut ? "Not signed in. Sign-in opens your browser." : msg.split("\n")[0] || "sbx did not respond.",
+    fix: fix(loggedOut ? "sbx login" : "sbx diagnose", true, SBX_DOCS)
+  };
+}
+async function checkTmux(brew) {
+  const base = { id: "tmux", label: "tmux (keeps agents running if HQ closes)", neededFor: "all" };
+  if (!usesTmux())
+    return { ...base, label: "Agent sessions", status: "ok", detail: "HQ runs agents itself on Windows (no tmux needed). They stop when HQ stops; sandboxes and folders are kept.", fix: null };
+  const v = await run("tmux", ["-V"], { timeoutMs: 5e3 });
+  if (v.ok) return { ...base, status: "ok", detail: v.stdout.trim(), fix: null };
+  if (os === "win32") return { ...base, status: "unsupported", detail: "tmux needs WSL on Windows. Run HQ inside WSL.", fix: fix("wsl --install", false, "https://learn.microsoft.com/windows/wsl/install") };
+  return {
+    ...base,
+    status: "missing",
+    detail: "Not installed.",
+    fix: os === "darwin" ? fix("brew install tmux", brew, "https://github.com/tmux/tmux/wiki/Installing") : fix("sudo apt install tmux", false, "https://github.com/tmux/tmux/wiki/Installing")
+  };
+}
+async function checkClaude() {
+  const base = { id: "claude", label: "Claude Code (for Local mode)", neededFor: "local" };
+  const v = await run("claude", ["--version"], { timeoutMs: 8e3 });
+  if (v.ok) return { ...base, status: "ok", detail: v.stdout.trim(), fix: null };
+  return {
+    ...base,
+    status: "missing",
+    detail: "Not installed. Only needed for agents in Local mode.",
+    fix: fix(os === "win32" ? "irm https://claude.ai/install.ps1 | iex" : "curl -fsSL https://claude.ai/install.sh | bash", false, "https://docs.claude.com/en/docs/claude-code/setup")
+  };
+}
+async function checkGh(brew) {
+  const base = { id: "gh", label: "GitHub CLI (reads PRs and reviews)", neededFor: "github" };
+  if (!await has("gh"))
+    return {
+      ...base,
+      status: "missing",
+      detail: "Not installed.",
+      fix: fix(os === "darwin" ? "brew install gh" : os === "win32" ? "winget install --id GitHub.cli" : "sudo apt install gh", os === "darwin" ? brew : os === "win32", "https://cli.github.com")
+    };
+  const r = await run("gh", ["auth", "status"], { timeoutMs: 1e4 });
+  const out = r.stdout + r.stderr;
+  if (r.ok) return { ...base, status: "ok", detail: `Signed in as ${out.match(/account (\S+)/)?.[1] ?? "you"}`, fix: null };
+  return { ...base, status: "missing", detail: "Not signed in.", fix: fix("gh auth login", true, "https://cli.github.com/manual/gh_auth_login") };
+}
+function checkRemote(repo) {
+  const base = { id: "gh-remote", label: "GitHub remote", neededFor: "github" };
+  if (repo.github) return { ...base, status: "ok", detail: repo.github, fix: null };
+  return {
+    ...base,
+    status: "warning",
+    detail: repo.originUrl ? `origin is ${repo.originUrl} (not GitHub)` : "No origin remote. Agents can't push or open PRs.",
+    fix: fix("gh repo create --source . --private --push", false, "https://cli.github.com/manual/gh_repo_create")
+  };
+}
+async function checkGithubSecret(sbxOk) {
+  const base = { id: "github-secret", label: "GitHub access inside sandboxes", neededFor: "sandbox" };
+  if (!sbxOk) return { ...base, status: "missing", detail: "Waiting for sbx.", fix: null };
+  const r = await run("sbx", ["secret", "ls"], { timeoutMs: 1e4 });
+  if (r.ok && /\bgithub\b/.test(r.stdout)) return { ...base, status: "ok", detail: "Stored in Docker's secret store; injected by the proxy.", fix: null };
+  return {
+    ...base,
+    status: "missing",
+    detail: "Agents can't push or open PRs until this is set.",
+    fix: fix("sbx secret set github --command 'gh auth token'", true, "https://docs.docker.com/ai/sandboxes/get-started/")
+  };
+}
+async function checkCodex() {
+  const base = { id: "codex", label: "Codex (for Codex agents in Local mode)", neededFor: "local" };
+  const v = await run("codex", ["--version"], { timeoutMs: 8e3 });
+  if (v.ok) return { ...base, status: "ok", detail: v.stdout.trim(), fix: null };
+  return { ...base, status: "missing", detail: "Not installed. Only needed for Codex agents in Local mode (sandboxes have it).", fix: fix("npm install -g @openai/codex", false, "https://developers.openai.com/codex/cli") };
+}
+async function checkOpenAiSecret(sbxOk) {
+  const base = { id: "openai-secret", label: "OpenAI sign-in for Codex agents", neededFor: "sandbox" };
+  if (!sbxOk) return { ...base, status: "missing", detail: "Waiting for sbx.", fix: null };
+  const r = await run("sbx", ["secret", "ls", "--json"], { timeoutMs: 1e4 });
+  let has2 = false;
+  try {
+    has2 = (parseCliJson(r.stdout)?.secrets ?? []).some((s) => s.name === "openai" && s.scope === "global");
+  } catch {
+  }
+  if (has2) return { ...base, status: "ok", detail: "Stored in Docker's secret store.", fix: null };
+  return { ...base, status: "missing", detail: "Codex agents can't sign in until this is set. Opens your browser to sign in with ChatGPT.", fix: fix("sbx secret set openai --oauth", true, "https://docs.docker.com/ai/sandboxes/") };
+}
+async function runSetupChecks(repo, team = []) {
+  const brew = os === "darwin" && await has("brew");
+  const [osCheck, sbx, tmux, claude2, gh] = await Promise.all([checkOs(), checkSbx(brew), checkTmux(brew), checkClaude(), checkGh(brew)]);
+  const sbxOk = sbx.status === "ok";
+  const [login, secret] = await Promise.all([checkSbxLogin(sbxOk), checkGithubSecret(sbxOk)]);
+  const policy = await checkSbxPolicy(login.status === "ok");
+  const checks = [osCheck, sbx, login, policy, secret, tmux, claude2, gh, checkRemote(repo)];
+  const codexAgents = team.filter((a) => a.cli === "codex");
+  if (codexAgents.some((a) => a.mode === "sandbox")) checks.splice(5, 0, await checkOpenAiSecret(sbxOk));
+  if (codexAgents.some((a) => a.mode === "local")) checks.push(await checkCodex());
+  const ok2 = (c) => c.status === "ok";
+  return {
+    machine: { cpus: cpus().length, memoryGb: Math.round(totalmem() / 1024 ** 3), persistentAgents: usesTmux() },
+    checks,
+    sandboxReady: osCheck.status !== "unsupported" && ok2(sbx) && ok2(login) && ok2(policy) && ok2(tmux),
+    localReady: ok2(tmux) && ok2(claude2),
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// server/sbx.ts
+var key2 = (decision, resource) => `${decision} ${resource}`;
+function approvalHost(title) {
+  const m = title.trim().match(/^(?:[A-Z]+\s+)?(?:[a-z]+:\/\/)?([^/\s?#]+)/);
+  return (m?.[1] ?? title.trim()).toLowerCase();
+}
+var Sbx = class {
+  // sandbox name → "allow foo.com" entries HQ added
+  constructor(hub) {
+    this.hub = hub;
+    this.ownedFile = join9(projectHome(hub.slug), "sbx-owned.json");
+    this.owned = existsSync7(this.ownedFile) && parseCliJson(readFileSync7(this.ownedFile, "utf8")) || {};
+    this.state = { basePolicy: "unknown", proxy: null, globalKeys: [], agents: {}, checkedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  hub;
+  state;
+  ownedFile;
+  owned;
+  saveOwned() {
+    writeFileSync7(this.ownedFile, JSON.stringify(this.owned, null, 2));
+  }
+  name(agentId) {
+    return sessionName(this.hub.slug, agentId);
+  }
+  envFile(agentId) {
+    return join9(projectHome(this.hub.slug), `${agentId}.env`);
+  }
+  publish() {
+    this.state.checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.hub.snap.sbx = this.state;
+    this.hub.emit({ type: "sbx.updated", sbx: structuredClone(this.state) });
+  }
+  // ------------------------------------------------------------ read back
+  /** Network rules in effect, or null when sbx's list couldn't be read (not the same as "no rules"). */
+  async rules() {
+    const r = await run("sbx", ["policy", "ls", "--json", "--type", "network"], { timeoutMs: 15e3 });
+    if (!r.ok) return null;
+    const data = parseCliJson(r.stdout);
+    if (!data) return null;
+    return (data.rules ?? []).filter((x) => x.resource_type === "network" && x.status !== "inactive");
+  }
+  async basePolicy() {
+    const allowed = async (target) => (await policyVerdict(target)).verdict === "allowed";
+    if (await allowed("hq-probe.invalid")) return "allow-all";
+    if (await allowed("registry.npmjs.org")) return "balanced";
+    return "deny-all";
+  }
+  /** Re-reads everything from sbx and publishes it. */
+  async refresh() {
+    if (!this.hub.snap.setup.sandboxReady) {
+      this.state.agents = Object.fromEntries(this.hub.snap.config.team.map((a) => [a.id, this.emptyAgent(a.id)]));
+      return this.publish();
+    }
+    const [rules, keysOut, proxyOut, base] = await Promise.all([
+      this.rules().then((list) => list ?? []),
+      run("sbx", ["secret", "ls", "--json"], { timeoutMs: 15e3 }),
+      run("sbx", ["settings", "get", "proxy.sandbox"], { timeoutMs: 1e4 }),
+      this.basePolicy()
+    ]);
+    let secrets = [];
+    try {
+      secrets = parseCliJson(keysOut.stdout)?.secrets ?? [];
+    } catch {
+    }
+    this.state.basePolicy = base;
+    this.state.proxy = proxyOut.stdout.trim() || null;
+    this.state.globalKeys = secrets.filter((s) => s.type === "service" && s.scope === "global").map((s) => s.name);
+    const prevErrors = this.state.agents;
+    this.state.agents = {};
+    for (const a of this.hub.snap.config.team) {
+      const name = this.name(a.id);
+      const mine = new Set(this.owned[name] ?? []);
+      const sandboxRules = rules.filter((r) => r.applies_to === `sandbox:${name}`).map((r) => ({
+        id: r.id,
+        decision: r.decision,
+        resources: r.resources,
+        source: r.layer === "org" ? "org" : r.origin === "kit" || ["default", "provisioned"].includes(r.provenance?.created_via ?? "") ? "kit" : r.resources.every((x) => mine.has(key2(r.decision, x))) ? "hq" : "cli"
+      }));
+      this.state.agents[a.id] = {
+        rules: sandboxRules,
+        // sbx reports a sandbox scope as the bare sandbox name.
+        keys: secrets.filter((s) => s.type === "service" && (s.scope === name || s.scope === `sandbox:${name}`)).map((s) => s.name),
+        envFile: { path: this.envFile(a.id), exists: existsSync7(this.envFile(a.id)) },
+        syncError: prevErrors[a.id]?.syncError ?? null,
+        approvals: prevErrors[a.id]?.approvals ?? [],
+        ports: prevErrors[a.id]?.ports ?? []
+      };
+    }
+    this.publish();
+    await this.refreshPorts();
+  }
+  emptyAgent(agentId) {
+    return { rules: [], keys: [], envFile: { path: this.envFile(agentId), exists: existsSync7(this.envFile(agentId)) }, syncError: null, approvals: [], ports: [] };
+  }
+  // ------------------------------------------------------------ ports
+  /** Published ports of one sandbox, or null if sbx couldn't list them (e.g. the sandbox is gone). */
+  async readPorts(agentId) {
+    const r = await run("sbx", ["ports", this.name(agentId), "--json"], { timeoutMs: 1e4 });
+    const data = r.ok ? parseCliJson(r.stdout) : null;
+    if (!data) return null;
+    const rows = Array.isArray(data) ? data : data.ports ?? [];
+    const seen = /* @__PURE__ */ new Map();
+    for (const p of rows) if (p.sandbox_port && p.host_port) seen.set(p.sandbox_port, { sandbox: p.sandbox_port, host: p.host_port });
+    return [...seen.values()].sort((a, b) => a.sandbox - b.sandbox);
+  }
+  /** Re-reads forwarded ports for running sandboxed agents. */
+  async refreshPorts(agentId) {
+    const ids = agentId ? [agentId] : this.hub.snap.config.team.map((a) => a.id);
+    let changed = false;
+    for (const id of ids) {
+      const a = this.hub.cfg(id);
+      const st = this.state.agents[id];
+      if (!a || !st) continue;
+      const running = a.mode === "sandbox" && this.hub.status(id)?.session.state === "running";
+      const ports = running ? await this.readPorts(id) ?? [] : [];
+      if (JSON.stringify(ports) !== JSON.stringify(st.ports ?? [])) st.ports = ports, changed = true;
+    }
+    if (changed) this.publish();
+  }
+  /**
+   * Makes a port inside the agent's sandbox reachable at the same port on this machine (loopback
+   * only), e.g. for a CLI sign-in whose browser callback goes to localhost:<port>.
+   */
+  async forwardPort(agentId, port) {
+    const a = this.hub.cfg(agentId);
+    if (!a || a.mode !== "sandbox" || !Number.isInteger(port) || port < 1 || port > 65535) return;
+    const r = await run("sbx", ["ports", this.name(agentId), "--publish", `127.0.0.1:${port}:${port}`], { timeoutMs: 3e4 });
+    if (r.ok) this.hub.activity("config", agentId, `Forwarded port ${port} from ${a.name}'s sandbox to localhost:${port} on this machine.`);
+    else {
+      const why = `${r.stdout}
+${r.stderr}`.trim().split("\n").filter(Boolean).pop()?.replace(/^error: /i, "") ?? "";
+      const inUse = /in use|already allocated|address already/i.test(why);
+      this.hub.activity(
+        "config",
+        agentId,
+        `Couldn't forward port ${port} from ${a.name}'s sandbox: ${inUse ? `something on this machine already uses port ${port}. Stop it and try again.` : why.slice(0, 160)}`
+      );
+    }
+    await this.refreshPorts(agentId);
+  }
+  async unforwardPort(agentId, port) {
+    const a = this.hub.cfg(agentId);
+    if (!a || !Number.isInteger(port) || port < 1 || port > 65535) return;
+    const host = this.state.agents[agentId]?.ports?.find((p) => p.sandbox === port)?.host ?? port;
+    const r = await run("sbx", ["ports", this.name(agentId), "--unpublish", `127.0.0.1:${host}:${port}`], { timeoutMs: 3e4 });
+    if (!r.ok) this.hub.activity("config", agentId, `Couldn't stop forwarding port ${port}: ${(r.stderr || r.stdout).trim().split("\n").pop()?.slice(0, 160)}`);
+    await this.refreshPorts(agentId);
+  }
+  // ------------------------------------------------------------ approvals
+  seenApprovals = /* @__PURE__ */ new Set();
+  approvalTimer = null;
+  /** sbx's queue of blocked requests. It has no JSON output, so the table is read by its header's columns. */
+  async readApprovals() {
+    const r = await run("sbx", ["policy", "approval", "ls"], { timeoutMs: 1e4 });
+    if (!r.ok) return null;
+    const lines = r.stdout.split("\n").filter((l) => l.trim());
+    const head = lines.findIndex((l) => /^APPROVAL\s+SANDBOX\s+TITLE\s+DETAIL/.test(l));
+    if (head === -1) return lines.every((l) => /no pending approvals/i.test(l)) ? [] : null;
+    const at = ["APPROVAL", "SANDBOX", "TITLE", "DETAIL", "OPTIONS"].map((c) => lines[head].indexOf(c));
+    const cell = (l, i) => l.slice(at[i], at[i + 1] > 0 ? at[i + 1] : void 0).trim();
+    return lines.slice(head + 1).map((l) => ({ id: cell(l, 0), sandbox: cell(l, 1), title: cell(l, 2), detail: cell(l, 3) })).filter((a) => /^network:\S+$/.test(a.id));
+  }
+  approvalReads = Promise.resolve();
+  approvalReadsPending = 0;
+  /** Reads run one at a time, in order, so an older, slower read can't overwrite a newer one. */
+  refreshApprovals() {
+    this.approvalReadsPending++;
+    const next = this.approvalReads.then(() => this.readAndShowApprovals());
+    this.approvalReads = next.catch(() => {
+    }).finally(() => this.approvalReadsPending--);
+    return next;
+  }
+  /** Re-reads the approval queue and shows each HQ agent's blocked requests (new ones once in the activity feed). */
+  async readAndShowApprovals() {
+    if (!this.hub.snap.setup.sandboxReady) return;
+    const all = await this.readApprovals();
+    if (!all) return;
+    let changed = false;
+    const fresh = [];
+    for (const a of this.hub.snap.config.team) {
+      const name = this.name(a.id);
+      const list = all.filter((x) => x.sandbox === name).map((x) => ({
+        id: x.id,
+        host: approvalHost(x.title),
+        title: x.title.trim(),
+        detail: x.detail.replace(/^Protocol: \S+ Resource type: \S+ /, ""),
+        hostWide: approvalHost(x.title) === x.title.trim().toLowerCase(),
+        protocol: x.detail.match(/Protocol:\s*(\S+)/i)?.[1]?.toUpperCase()
+      }));
+      const st = this.state.agents[a.id] ??= this.emptyAgent(a.id);
+      if (JSON.stringify(st.approvals) !== JSON.stringify(list)) {
+        st.approvals = list;
+        changed = true;
+      }
+      for (const x of list) if (!this.seenApprovals.has(x.id)) this.seenApprovals.add(x.id), fresh.push({ agentId: a.id, host: x.host });
+    }
+    if (changed) this.publish();
+    const byAgent = /* @__PURE__ */ new Map();
+    for (const f of fresh) byAgent.set(f.agentId, [...byAgent.get(f.agentId) ?? [], f.host]);
+    for (const [id, hosts] of byAgent)
+      this.hub.activity("agent.needs-input", id, `${this.hub.name(id)}'s sandbox blocked ${hosts.slice(0, 3).join(", ")}${hosts.length > 3 ? ` and ${hosts.length - 3} more` : ""}. Allow or dismiss in the agent's drawer.`);
+  }
+  startApprovalPolling(ms = 5e3) {
+    if (this.approvalTimer) return;
+    const tick = () => void (this.approvalReadsPending ? Promise.resolve() : this.refreshApprovals()).catch((e) => log.warn("approvals:", e));
+    tick();
+    this.approvalTimer = setInterval(tick, ms);
+  }
+  stopApprovalPolling() {
+    if (this.approvalTimer) clearInterval(this.approvalTimer);
+    this.approvalTimer = null;
+  }
+  answering = /* @__PURE__ */ new Set();
+  // agents with an answer in flight
+  /**
+   * Answers blocked requests. Allow adds an HQ-owned allow rule for exactly that host:port (shown and
+   * removable in Settings → Sandbox) and clears every queued request for it; Dismiss clears only the one.
+   * "all" answers every listed request the same way. One answer per agent at a time; a second click meanwhile is ignored.
+   */
+  async answerApproval(agentId, approvalId, decision) {
+    if (this.answering.has(agentId)) return;
+    this.answering.add(agentId);
+    try {
+      await this.answer(agentId, approvalId, decision);
+    } finally {
+      this.answering.delete(agentId);
+    }
+  }
+  async respondApproval(id, option) {
+    return (await run("sbx", ["policy", "approval", "respond", id, "--option", option], { timeoutMs: 1e4 })).ok;
+  }
+  async answer(agentId, approvalId, decision) {
+    const list = [...this.state.agents[agentId]?.approvals ?? []];
+    const target = approvalId === "all" ? null : list.find((a) => a.id === approvalId);
+    if (approvalId !== "all" && !target) return;
+    const respond = (id, option) => this.respondApproval(id, option);
+    if (decision === "allow" && approvalId === "all") return this.allowAll(agentId, list);
+    if (decision === "allow" && target) {
+      const who = this.hub.name(agentId);
+      const tcp = !target.protocol || target.protocol === "TCP";
+      if (/required by policy|organi[sz]ation/i.test(target.detail) || target.hostWide === false || !tcp) {
+        if (await respond(target.id, "allow")) this.hub.activity("config", agentId, `You approved ${target.host} for ${who}'s sandbox`);
+        else this.hub.activity("config", agentId, `Couldn't approve ${target.host}: sbx refused it.`);
+        return this.refreshApprovals();
+      }
+      const agent = this.hub.cfg(agentId);
+      if (!agent) return;
+      const added = !agent.sandbox.allow.includes(target.host);
+      if (added) {
+        agent.sandbox.allow = [...agent.sandbox.allow, target.host];
+        this.hub.configChanged();
+      }
+      await this.syncRules(agentId);
+      const err = this.state.agents[agentId]?.syncError;
+      const applied = this.state.agents[agentId]?.rules.some((r) => r.decision === "allow" && r.resources.includes(target.host));
+      if (!applied || err?.includes(target.host)) {
+        if (added) {
+          agent.sandbox.allow = agent.sandbox.allow.filter((h) => h !== target.host);
+          this.hub.configChanged();
+          await this.syncRules(agentId);
+        }
+        const why = err ? err.slice(0, 160) : agent.mode !== "sandbox" ? `${who} isn't in Sandbox mode` : "sbx didn't apply the rule";
+        this.hub.activity("config", agentId, `Couldn't allow ${target.host}: ${why}. The request is still listed.`);
+        return;
+      }
+      for (const a of list.filter((x) => x.host === target.host && (!x.protocol || x.protocol === "TCP") && x.hostWide !== false)) await respond(a.id, "dismiss");
+      this.hub.activity("config", agentId, `You allowed ${target.host} for ${who}'s sandbox`);
+    } else {
+      for (const a of approvalId === "all" ? list : [target]) await respond(a.id, "dismiss");
+    }
+    await this.refreshApprovals();
+  }
+  /** Allow all: one sync for every host:port rule, then sbx's own approval for the rest (same split as one Allow). */
+  async allowAll(agentId, list) {
+    const agent = this.hub.cfg(agentId);
+    if (!agent || !list.length) return;
+    const who = this.hub.name(agentId);
+    const viaRule = (a) => (!a.protocol || a.protocol === "TCP") && a.hostWide !== false && !/required by policy|organi[sz]ation/i.test(a.detail);
+    const failed = [];
+    for (const a of list.filter((x) => !viaRule(x))) if (!await this.respondApproval(a.id, "allow")) failed.push(a.host);
+    const hosts = [...new Set(list.filter(viaRule).map((a) => a.host))];
+    const added = hosts.filter((h) => !agent.sandbox.allow.includes(h));
+    if (added.length) {
+      agent.sandbox.allow = [...agent.sandbox.allow, ...added];
+      this.hub.configChanged();
+    }
+    if (hosts.length) await this.syncRules(agentId);
+    const st = this.state.agents[agentId];
+    const applied = (h) => st?.rules.some((r) => r.decision === "allow" && r.resources.includes(h)) && !st?.syncError?.includes(h);
+    const notApplied = hosts.filter((h) => !applied(h));
+    const undo = added.filter((h) => notApplied.includes(h));
+    if (undo.length) {
+      agent.sandbox.allow = agent.sandbox.allow.filter((h) => !undo.includes(h));
+      this.hub.configChanged();
+      await this.syncRules(agentId);
+    }
+    failed.push(...notApplied);
+    for (const a of list.filter((x) => viaRule(x) && !notApplied.includes(x.host))) await this.respondApproval(a.id, "dismiss");
+    const ok2 = new Set(list.map((a) => a.host).filter((h) => !failed.includes(h))).size;
+    if (ok2) this.hub.activity("config", agentId, `You allowed ${ok2} site${ok2 === 1 ? "" : "s"} for ${who}'s sandbox`);
+    if (failed.length) {
+      const why = agent.mode !== "sandbox" ? `${who} isn't in Sandbox mode` : st?.syncError?.slice(0, 120) || "sbx didn't apply them";
+      this.hub.activity("config", agentId, `Couldn't allow ${failed.slice(0, 3).join(", ")}${failed.length > 3 ? ` and ${failed.length - 3} more` : ""}: ${why}. They're still listed.`);
+    }
+    await this.refreshApprovals();
+  }
+  // ------------------------------------------------------------ apply
+  /** True if sbx knows a sandbox with this name. */
+  async exists(agentId) {
+    const r = await run("sbx", ["ls", "--json"], { timeoutMs: 1e4 });
+    try {
+      return (sandboxList(r.stdout) ?? []).some((s) => s.name === this.name(agentId));
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Makes the sandbox's allow/deny rules match the agent's lists. Adds what's
+   * missing; removes only rules HQ added earlier. Needs the sandbox to exist.
+   */
+  async syncRules(agentId) {
+    const agent = this.hub.cfg(agentId);
+    if (!agent || agent.mode !== "sandbox" || !await this.exists(agentId)) return;
+    const name = this.name(agentId);
+    const want = /* @__PURE__ */ new Set([...agent.sandbox.allow.map((r) => key2("allow", r)), ...agent.sandbox.deny.map((r) => key2("deny", r))]);
+    const owned = new Set(this.owned[name] ?? []);
+    const all = await this.rules();
+    if (!all) {
+      log.warn(`sbx rules for ${name}: couldn't read sbx's rule list; nothing changed`);
+      (this.state.agents[agentId] ??= this.emptyAgent(agentId)).syncError = "Couldn't read sbx's rules; nothing was changed. Try again.";
+      this.publish();
+      return;
+    }
+    const rules = all.filter((r) => r.applies_to === `sandbox:${name}`);
+    const have = new Set(rules.flatMap((r) => r.resources.map((x) => key2(r.decision, x))));
+    const errors = [];
+    for (const entry of want) {
+      if (have.has(entry)) continue;
+      const [decision, resource] = entry.split(" ");
+      const r = await run("sbx", ["policy", decision, "network", "--sandbox", name, resource], { timeoutMs: 15e3 });
+      if (r.ok) owned.add(entry);
+      else errors.push(`${decision} ${resource}: ${r.stderr.trim().split("\n")[0]}`);
+    }
+    for (const entry of [...owned]) {
+      if (want.has(entry)) continue;
+      const [decision, resource] = entry.split(" ");
+      const rule = rules.find((r2) => r2.decision === decision && r2.resources.includes(resource));
+      const r = rule ? await run("sbx", ["policy", "rm", "network", "--sandbox", name, "--id", rule.id, "--force"], { timeoutMs: 15e3 }) : { ok: true, stderr: "" };
+      if (r.ok) owned.delete(entry);
+      else errors.push(`remove ${resource}: ${r.stderr.trim().split("\n")[0]}`);
+    }
+    this.owned[name] = [...owned];
+    this.saveOwned();
+    if (errors.length) log.warn(`sbx rules for ${name}:`, errors.join("; "));
+    await this.refresh();
+    if (this.state.agents[agentId]) {
+      this.state.agents[agentId].syncError = errors.length ? errors.join("; ") : null;
+      this.publish();
+    }
+  }
+  /** Stores a service key (value via stdin, never kept). agentId null = every sandbox. */
+  async setKey(agentId, service, value) {
+    const args = ["secret", "set", service, ...agentId ? ["--sandbox", this.name(agentId)] : [], "--force"];
+    const r = await run("sbx", args, { timeoutMs: 2e4, input: value.trim() + "\n" });
+    if (!r.ok) throw new Error(r.stderr.trim().split("\n")[0] || "sbx secret set failed");
+    await this.refresh();
+  }
+  async removeKey(agentId, service) {
+    const r = await run("sbx", ["secret", "rm", service, ...agentId ? ["--sandbox", this.name(agentId)] : [], "--force"], { timeoutMs: 2e4 });
+    if (!r.ok) throw new Error(r.stderr.trim().split("\n")[0] || "sbx secret rm failed");
+    await this.refresh();
+  }
+  async setProxy(url) {
+    const r = url ? await run("sbx", ["settings", "set", "proxy.sandbox", url], { timeoutMs: 15e3 }) : await run("sbx", ["settings", "unset", "proxy.sandbox"], { timeoutMs: 15e3 });
+    if (!r.ok) throw new Error(r.stderr.trim().split("\n")[0] || "sbx settings failed");
+    await this.refresh();
+  }
+  /** Creates the agent's env file (0600) if missing. Returns its path. Never reads values. */
+  ensureEnvFile(agentId) {
+    const file = this.envFile(agentId);
+    if (!existsSync7(file)) {
+      writeFileSync7(
+        file,
+        `# App variables for ${this.hub.name(agentId)} (${this.hub.snap.config.project.name}).
+# One KEY=value per line. These values ENTER the agent's VM \u2014 use test/dev credentials.
+# Restart the agent after editing. Setups Works Office never reads or commits this file.
+`,
+        { mode: 384 }
+      );
+    }
+    chmodSync(file, 384);
+    return file;
+  }
+};
+
+// server/sbxMcp.ts
+import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join10 } from "node:path";
+var MCP_NAME = /^[a-z0-9][a-z0-9_-]{0,39}$/;
+var firstLine = (s) => s.trim().split("\n").filter(Boolean).pop() ?? "";
+var SbxMcp = class {
+  constructor(hub, runTerminal) {
+    this.hub = hub;
+    this.runTerminal = runTerminal;
+    this.attachedFile = join10(projectHome(hub.slug), "mcp-attached.json");
+    try {
+      if (existsSync8(this.attachedFile)) this.state.attached = parseCliJson(readFileSync8(this.attachedFile, "utf8")) ?? {};
+    } catch {
+    }
+  }
+  hub;
+  runTerminal;
+  state = { servers: [], attached: {}, error: null, checkedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  attachedFile;
+  queue = Promise.resolve();
+  /** One sbx mcp operation at a time, so attach/forget records stay consistent. */
+  serial(fn) {
+    const next = this.queue.then(fn, fn);
+    this.queue = next.catch(() => {
+    });
+    return next;
+  }
+  publish() {
+    this.state.checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.hub.snap.mcp = this.state;
+    this.hub.emit({ type: "mcp.updated", mcp: structuredClone(this.state) });
+  }
+  saveAttached() {
+    writeFileSync8(this.attachedFile, JSON.stringify(this.state.attached, null, 2));
+  }
+  /** Re-reads sbx's registry. */
+  async refresh() {
+    if (!this.hub.snap.setup.sandboxReady) {
+      this.state.error = "Docker Sandboxes isn't ready on this machine.";
+      return this.publish();
+    }
+    const r = await run("sbx", ["mcp", "ls", "--json"], { timeoutMs: 15e3 });
+    const data = r.ok ? parseCliJson(r.stdout) : null;
+    if (!data) {
+      this.state.error = firstLine(r.stderr || r.stdout) || "Couldn't read sbx's MCP servers.";
+      return this.publish();
+    }
+    this.state.servers = (Array.isArray(data) ? data : data.servers ?? []).map(
+      (s) => ({ name: s.name, transport: s.transport ?? "", status: s.status ?? "unknown", nextStep: s.next_step ?? null })
+    );
+    this.state.error = null;
+    this.publish();
+  }
+  /** Registers a server. OAuth sign-in is a separate step (authorize). An API key goes to sbx's secret store. */
+  add(input) {
+    return this.serial(async () => {
+      const name = input.name.trim().toLowerCase();
+      if (!MCP_NAME.test(name)) return this.hub.activity("config", null, `MCP server name "${input.name}" isn't valid: use letters, numbers, - or _.`);
+      const url = input.url?.trim();
+      const command = input.command?.trim();
+      if (!url && !command || url?.startsWith("-") || command?.startsWith("-")) return this.hub.activity("config", null, "Give the MCP server a URL (or a command for a local server).");
+      const args = ["mcp", "add", name, "--skip-auth"];
+      if (url) args.push("--url", url);
+      else args.push("--command", command, ...input.args?.length ? ["--args", input.args.join(",")] : []);
+      const key3 = input.apiKey?.trim();
+      if (key3 && url) args.push("--header", "Authorization: Bearer ${token}");
+      const r = await run("sbx", args, { timeoutMs: 12e4 });
+      if (!r.ok) {
+        this.hub.activity("config", null, `Couldn't add MCP server ${name}: ${firstLine(r.stderr || r.stdout).slice(0, 200)}`);
+        return this.refresh();
+      }
+      if (key3 && url) {
+        const s = await run("sbx", ["secret", "set", `mcp:${name}:token`, "--force"], { timeoutMs: 2e4, input: key3 + "\n" });
+        if (!s.ok) this.hub.activity("config", null, `Added ${name}, but couldn't store its key: ${firstLine(s.stderr).slice(0, 160)}`);
+      }
+      this.hub.activity("config", null, `Added MCP server ${name}`);
+      await this.refresh();
+    });
+  }
+  /** Signs in to a server (opens the browser) in a terminal you can watch. */
+  authorize(name) {
+    if (!MCP_NAME.test(name)) return;
+    this.runTerminal(`setup:mcp-auth-${name}`, "sbx", ["mcp", "auth", name], () => void this.refresh());
+  }
+  /** Unregisters a server from sbx (every sandbox on this machine), and from every agent. */
+  remove(name) {
+    return this.serial(async () => {
+      if (!MCP_NAME.test(name)) return;
+      const r = await run("sbx", ["mcp", "rm", name, "--force"], { timeoutMs: 3e4 });
+      if (!r.ok) {
+        this.hub.activity("config", null, `Couldn't remove MCP server ${name}: ${firstLine(r.stderr || r.stdout).slice(0, 200)}`);
+        return this.refresh();
+      }
+      for (const secret of [`mcp:${name}:token`, `mcp:${name}:token:endpoint`]) await run("sbx", ["secret", "rm", secret, "--force"], { timeoutMs: 15e3 });
+      let changed = false;
+      for (const a of this.hub.snap.config.team)
+        if (a.mcp?.includes(name)) {
+          a.mcp = a.mcp.filter((n) => n !== name);
+          changed = true;
+        }
+      if (changed) this.hub.configChanged();
+      for (const id of Object.keys(this.state.attached)) this.state.attached[id] = this.state.attached[id].filter((n) => n !== name);
+      this.saveAttached();
+      this.hub.activity("config", null, `Removed MCP server ${name} from Docker Sandboxes`);
+      await this.refresh();
+    });
+  }
+  /** Which servers an agent gets. New ones are attached now if its sandbox is running. */
+  setAgent(agentId, names) {
+    return this.serial(async () => {
+      const agent = this.hub.cfg(agentId);
+      if (!agent) return;
+      const want = [...new Set(names.map((n) => n.trim().toLowerCase()).filter((n) => MCP_NAME.test(n)))];
+      const before = agent.mcp ?? [];
+      agent.mcp = want;
+      this.hub.configChanged();
+      const running = agent.mode === "sandbox" && this.hub.status(agentId)?.session.state === "running";
+      if (running) await this.attach(agentId, want.filter((n) => !before.includes(n)));
+      const stuck = before.filter((n) => !want.includes(n) && this.state.attached[agentId]?.includes(n));
+      if (stuck.length)
+        this.hub.activity(
+          "config",
+          agentId,
+          `${agent.name}'s sandbox keeps ${stuck.join(", ")} until it's recreated (sbx can't detach a server). Settings \u2192 MCP \u2192 Recreate sandbox.`
+        );
+      this.publish();
+    });
+  }
+  /** The agent's sandbox just started: attach its servers. */
+  attachAll(agentId) {
+    return this.serial(async () => {
+      const agent = this.hub.cfg(agentId);
+      if (!agent || agent.mode !== "sandbox" || !agent.mcp?.length) return;
+      await this.attach(agentId, agent.mcp);
+      this.publish();
+    });
+  }
+  /** The agent's sandbox was removed or recreated: nothing is attached any more. */
+  forget(agentId) {
+    delete this.state.attached[agentId];
+    this.saveAttached();
+    this.publish();
+  }
+  async attach(agentId, names) {
+    const sandbox = sessionName(this.hub.slug, agentId);
+    const failed = [];
+    for (const name of names) {
+      const r = await run("sbx", ["mcp", "load", name, "--sandbox", sandbox], { timeoutMs: 6e4 });
+      if (r.ok) this.state.attached[agentId] = [.../* @__PURE__ */ new Set([...this.state.attached[agentId] ?? [], name])];
+      else failed.push(`${name}: ${firstLine(r.stderr || r.stdout).replace(/^error: /, "").slice(0, 140)}`);
+    }
+    this.saveAttached();
+    const needsSignIn = names.filter((n) => this.state.servers.find((s) => s.name === n)?.status === "needs-auth");
+    if (failed.length) this.hub.activity("config", agentId, `Couldn't attach MCP to ${this.hub.name(agentId)}: ${failed.join("; ")}`);
+    if (needsSignIn.length) this.hub.activity("config", agentId, `${needsSignIn.join(", ")} needs sign-in before ${this.hub.name(agentId)} can use it (Settings \u2192 MCP \u2192 Sign in).`);
+  }
+};
+
+// server/lib/ptyFix.ts
+import { chmodSync as chmodSync2, existsSync as existsSync9, statSync as statSync2 } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname as dirname2, join as join11 } from "node:path";
+function ensurePtyHelperExecutable() {
+  if (process.platform === "win32") return;
+  try {
+    const require2 = createRequire(createRequire(import.meta.url).resolve("@lydell/node-pty"));
+    const root = dirname2(dirname2(require2.resolve(`@lydell/node-pty-${process.platform}-${process.arch}`)));
+    const helper = join11(root, "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper");
+    if (existsSync9(helper) && !(statSync2(helper).mode & 73)) chmodSync2(helper, 493);
+  } catch {
+  }
+}
+
+// server/repo.ts
+import { existsSync as existsSync10 } from "node:fs";
+import { basename, join as join12 } from "node:path";
+async function detectRepo(start) {
+  const top = await run("git", ["rev-parse", "--show-toplevel"], { cwd: start });
+  if (!top.ok) throw new Error(`${start} is not inside a git repository. Run HQ from your project folder or pass --repo <path>.`);
+  const root = top.stdout.trim();
+  const origin = await run("git", ["remote", "get-url", "origin"], { cwd: root });
+  const originUrl = origin.ok ? origin.stdout.trim() : null;
+  const m = originUrl?.match(/github\.com[:/]([^/]+\/[^/]+?)(\.git)?$/);
+  return {
+    root,
+    name: basename(root),
+    originUrl,
+    github: m ? m[1] : null,
+    hasCodeRabbit: existsSync10(join12(root, ".coderabbit.yaml")) || existsSync10(join12(root, ".coderabbit.yml")),
+    hasInsta: existsSync10(join12(root, ".insta"))
+  };
+}
+
+// server/sessions.ts
+import { spawn as spawnPty3 } from "@lydell/node-pty";
+import { existsSync as existsSync12, rmSync as rmSync3, statSync as statSync3 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { resolve as resolve3, sep as sep3 } from "node:path";
+
+// server/adapters.ts
+var claude = {
+  async writeFiles(dir2, agent, cfg, token, extras = {}) {
+    const ownRole = await adoptRoleFile(dir2);
+    writeClaudeFiles(dir2, agent, cfg, token, { ...extras, ownRole });
+  },
+  launch(agent, dir2) {
+    const m = agent.model.trim();
+    const model = !m || /^default$/i.test(m) ? null : /^(opus|sonnet|haiku)$/i.test(m) ? m.toLowerCase() : m;
+    return { sbxAgent: "claude", args: ["--mcp-config", `${dir2}/${MCP_CONFIG}`, ...model ? ["--model", model] : []] };
+  }
+};
+var CODEX_CONFIG = ".codex/config.toml";
+var CODEX_EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PermissionRequest", "Stop", "SessionEnd"];
+var t = (s) => JSON.stringify(s);
+function codexConfig(agent, cfg, token, dir2, extras = {}) {
+  const url = hqUrl(agent, cfg.project.hqPort);
+  const script = hookScriptFor(agent, dir2);
+  const lines = [
+    "# Written by Setups Works Office for this agent (git-excluded). Codex loads it once you trust this folder.",
+    `developer_instructions = ${t(roleMd(agent, cfg, extras))}`,
+    "",
+    "[features]",
+    "hooks = true",
+    "",
+    "[mcp_servers.hq]",
+    `url = ${t(`${url}/mcp`)}`,
+    `http_headers = { Authorization = ${t(`Bearer ${token}`)}, "X-HQ-Agent" = ${t(agent.id)} }`
+  ];
+  for (const event of CODEX_EVENTS)
+    lines.push("", `[[hooks.${event}]]`, `[[hooks.${event}.hooks]]`, 'type = "command"', `command = ${t(hookCommand(url, token, agent.id, event, script))}`);
+  return lines.join("\n") + "\n";
+}
+var codex = {
+  async writeFiles(dir2, agent, cfg, token, extras = {}) {
+    const tracked = await run("git", ["ls-files", "--error-unmatch", CODEX_CONFIG], { cwd: dir2 });
+    if (tracked.ok) throw new Error(`This repo commits ${CODEX_CONFIG}, so HQ can't add its Codex settings without changing a tracked file. Use Claude Code for this agent, or remove that file from the repo.`);
+    const ownRole = await adoptRoleFile(dir2);
+    agentWrite(dir2, CODEX_CONFIG, codexConfig(agent, cfg, token, dir2, { ...extras, ownRole }), { mode: 384 });
+    if (hookScriptFor(agent, dir2)) writeHookScript(dir2);
+    excludeFromGit(dir2, [CODEX_CONFIG, HOOK_SCRIPT]);
+  },
+  launch(agent) {
+    const model = agent.model.trim() && !/^default$/i.test(agent.model.trim()) ? agent.model.trim() : null;
+    return { sbxAgent: "codex", args: model ? ["-m", model] : [] };
+  }
+};
+var adapters = { claude, codex };
+var localBinary = { claude: "claude", codex: "codex" };
+
+// server/workspace.ts
+import { existsSync as existsSync11 } from "node:fs";
+function workspaceFor(agent, projectSlug) {
+  return agent.workspacePath || managedWorkspace(projectSlug, agent.id);
+}
+async function ensureWorkspace(agent, projectSlug, repo) {
+  const dir2 = workspaceFor(agent, projectSlug);
+  if (agent.workspacePath) {
+    if (!existsSync11(dir2)) throw new Error(`Folder not found: ${dir2}`);
+    if (!(await run("git", ["rev-parse", "--git-dir"], { cwd: dir2 })).ok) throw new Error(`${dir2} is not a git repository.`);
+    return dir2;
+  }
+  if (!existsSync11(dir2)) {
+    const clone = await run("git", ["clone", "--quiet", repo.root, dir2], { timeoutMs: 3e5 });
+    if (!clone.ok) throw new Error(`git clone failed: ${clone.stderr.trim()}`);
+  }
+  if (repo.originUrl) await run("git", ["remote", "set-url", "origin", repo.originUrl], { cwd: dir2 });
+  return dir2;
+}
+
+// server/sessions.ts
+var TERM_ENV3 = { ...process.env, TERM: "xterm-256color", COLORTERM: "truecolor" };
+var SHELL_ENV = { ...TERM_ENV3, FORCE_HYPERLINK: "1" };
+var SANDBOX_BROWSER = "/usr/local/bin/xdg-open";
+var BUSY = /esc to interrupt/i;
+var DIALOG = /Enter to select|↑\/↓ to navigate|Do you want to (proceed|make this edit|create)|Would you like to|^\s*[❯›]\s*1\.\s/im;
+var PROMPT_READY = /⏵⏵|\? for shortcuts|Ask Codex to do anything/;
+var SCREEN_QUIET_MS = 4e3;
+var STALE_WORKING_MS = 15e3;
+var SANDBOX_SHELL = `export FORCE_HYPERLINK=1; [ -x ${SANDBOX_BROWSER} ] && export BROWSER=${SANDBOX_BROWSER}; command -v bash >/dev/null && exec bash -l || exec sh -l`;
+var Sessions = class {
+  constructor(hub, agentToken2) {
+    this.hub = hub;
+    this.agentToken = agentToken2;
+  }
+  hub;
+  agentToken;
+  backend = sessionBackend();
+  terms = /* @__PURE__ */ new Map();
+  sizes = /* @__PURE__ */ new Map();
+  fixes = /* @__PURE__ */ new Map();
+  /** "Shell" tab: a plain shell in the agent's sandbox (or folder), separate from its agent session. */
+  shells = /* @__PURE__ */ new Map();
+  closing = /* @__PURE__ */ new WeakSet();
+  // closed on purpose: no "[shell closed]" line
+  shellGen = /* @__PURE__ */ new Map();
+  policyOk = false;
+  /** Called whenever an agent's Claude Code session goes away (stop, restart, crash). */
+  onSessionDown = () => {
+  };
+  /** Called once an agent's sandbox exists after Start (to apply its network rules). */
+  onSandboxReady = () => {
+  };
+  /** Called when an agent's sandbox is removed or recreated (what was attached to it is gone). */
+  onSandboxRemoved = () => {
+  };
+  /** The agent's env file, if it has one (passed with --env-file / sourced). */
+  envFileFor = () => null;
+  /** Called when HQ reattaches to a session that was already running (e.g. after an HQ restart). */
+  onSessionReattached = () => {
+  };
+  /** When the agent's last hook arrived (from the inbox). */
+  lastHookAt = () => 0;
+  polling = null;
+  /** Consecutive polls that saw a "working" agent's screen sitting idle. */
+  idleScreens = /* @__PURE__ */ new Map();
+  name(agentId) {
+    return sessionName(this.hub.slug, agentId);
+  }
+  // ------------------------------------------------------------ lifecycle
+  async start(id) {
+    const hub = this.hub;
+    const agent = hub.cfg(id);
+    const st = hub.status(id);
+    if (!agent || !st || st.session.state === "running" || st.session.state === "starting") return;
+    const setup = hub.snap.setup;
+    const fail2 = (detail) => {
+      hub.setSession(id, { state: "failed", detail });
+      hub.setStatus(id, { state: "idle", note: "Could not start" });
+      hub.activity("session", id, `${agent.name} could not start: ${detail.split("\n")[0]}`);
+    };
+    if (!setup.checks.find((c) => c.id === "tmux" && c.status === "ok")) return fail2("tmux is not installed. See the setup checklist.");
+    if (agent.mode === "sandbox" && !setup.sandboxReady) return fail2("Docker Sandboxes isn't ready on this machine. Finish the setup checklist, or switch this agent to Local mode.");
+    const check = (cid) => setup.checks.find((c) => c.id === cid)?.status;
+    if (agent.mode === "local" && agent.cli === "claude" && check("claude") !== "ok") return fail2("Claude Code isn't installed. See the setup checklist.");
+    if (agent.mode === "local" && agent.cli === "codex" && check("codex") !== "ok") return fail2("Codex isn't installed on this machine. See the setup checklist, or run this agent in a sandbox.");
+    if (agent.mode === "sandbox" && agent.cli === "codex" && check("openai-secret") !== "ok")
+      return fail2("Codex needs an OpenAI key in sbx. Run `sbx secret set openai --oauth` (Setup checklist \u2192 Run in terminal).");
+    const name = this.name(id);
+    this.onSessionDown(id);
+    try {
+      hub.setSession(id, { state: "starting", detail: "Preparing folder\u2026", workspace: workspaceFor(agent, hub.slug) });
+      const dir2 = await ensureWorkspace(agent, hub.slug, hub.repo);
+      const adapter = adapters[agent.cli];
+      const hasEnvFile = !!this.envFileFor(id) && (agent.mode === "sandbox" || this.backend.persistent);
+      await adapter.writeFiles(dir2, agent, hub.snap.config, this.agentToken, { hasEnvFile });
+      const specs = stackSkills(hub.snap.config.stack);
+      if (specs.length || hasHqSkills(hub.slug, dir2)) {
+        hub.setSession(id, { detail: "Installing agent skills\u2026" });
+        const skills = await prepareSkills(hub.slug, dir2, specs);
+        if (skills.error) hub.activity("session", id, `${agent.name}: some agent skills didn't install (${skills.error.slice(0, 120)}). Starting anyway.`);
+      }
+      if (!await this.backend.exists(name)) {
+        const launch = adapter.launch(agent, dir2);
+        const envFile = this.envFileFor(id);
+        let spec = { file: localBinary[agent.cli], args: launch.args, envFile };
+        if (agent.mode === "local" && envFile && !this.backend.persistent)
+          hub.activity("session", id, `${agent.name}'s env file isn't loaded in Local mode on Windows. Use Sandbox mode for app variables.`);
+        if (agent.mode === "sandbox") {
+          hub.setSession(id, { detail: "Allowing the sandbox to reach HQ\u2026" });
+          await this.ensurePolicy();
+          hub.setSession(id, { detail: "Starting sandbox\u2026" });
+          const { cpus: cpus2, memoryGb } = agent.sandbox.resources;
+          const isNew = !await this.sandboxExists(name);
+          const size = !isNew ? [] : [...cpus2 ? ["--cpus", String(cpus2)] : [], ...memoryGb ? ["--memory", `${Math.round(memoryGb * 1024)}m`] : []];
+          const env = [...envFile ? ["--env-file", envFile] : [], "-e", `BROWSER=${SANDBOX_BROWSER}`];
+          const args = launch.args.length ? ["--", ...launch.args] : [];
+          spec = { file: "sbx", args: ["run", "--name", name, ...size, ...env, launch.sbxAgent, dir2, ...args], envFile: null };
+        }
+        await this.backend.create(name, dir2, spec, { cols: 200, rows: 50 });
+      }
+      this.attach(id);
+      hub.setSession(id, { state: "running", detail: null, workspace: dir2 });
+      hub.setStatus(id, { state: "idle", note: agent.mode === "sandbox" ? "Sandbox running" : "Running locally" });
+      hub.activity("session", id, `${agent.name} started (${agent.cli === "codex" ? "Codex" : "Claude Code"}, ${agent.mode === "sandbox" ? "Docker Sandbox" : "Local mode"})`);
+      if (agent.mode === "sandbox") {
+        setTimeout(() => void this.refreshSandboxSizes(), 4e3);
+        void this.whenSandboxExists(id).then((ok2) => ok2 && this.onSandboxReady(id));
+      }
+    } catch (err) {
+      fail2(err instanceof Error ? err.message : String(err));
+    }
+  }
+  async stop(id) {
+    const hub = this.hub;
+    const agent = hub.cfg(id);
+    if (!agent) return;
+    const name = this.name(id);
+    this.onSessionDown(id);
+    this.detach(id);
+    this.closeShell(id);
+    await this.backend.kill(name);
+    if (agent.mode === "sandbox") void run("sbx", ["stop", name], { timeoutMs: 3e4 });
+    hub.setSession(id, { state: "stopped", detail: null });
+    hub.setStatus(id, { state: "idle", currentTaskId: null, note: "Stopped" });
+    hub.activity("session", id, `${agent.name} stopped`);
+  }
+  /** What removing this agent would delete: folder state and whether a sandbox exists. */
+  async inspectWorkspace(id) {
+    const agent = this.hub.cfg(id);
+    if (!agent) return null;
+    const dir2 = workspaceFor(agent, this.hub.slug);
+    const exists = existsSync12(dir2);
+    let changedFiles = 0;
+    let unpushedCommits = 0;
+    if (exists) {
+      const status = await run("git", ["status", "--porcelain"], { cwd: dir2 });
+      changedFiles = status.stdout.split("\n").filter(Boolean).length;
+      const log2 = await run("git", ["log", "--oneline", "--branches", "--not", "--remotes"], { cwd: dir2 });
+      unpushedCommits = log2.stdout.split("\n").filter(Boolean).length;
+    }
+    const name = this.name(id);
+    const ls = await run("sbx", ["ls", "--json"], { timeoutMs: 1e4 });
+    let sandboxExists = false;
+    try {
+      sandboxExists = ls.ok && (sandboxList(ls.stdout) ?? []).some((s) => s.name === name);
+    } catch {
+    }
+    return { agentId: id, path: dir2, managed: !agent.workspacePath, exists, changedFiles, unpushedCommits, sandboxName: name, sandboxExists };
+  }
+  /** Stops the agent and deletes what was asked. Only HQ-made folders inside HQ's home can be deleted. */
+  async removeResources(id, opts) {
+    const agent = this.hub.cfg(id);
+    if (!agent) return [];
+    const done = [];
+    const name = this.name(id);
+    this.onSessionDown(id);
+    this.detach(id);
+    this.closeShell(id);
+    await this.backend.kill(name);
+    if (opts.deleteSandbox) {
+      const rm = await run("sbx", ["rm", "-f", name], { timeoutMs: 6e4 });
+      if (rm.ok) done.push("sandbox"), this.onSandboxRemoved(id);
+      else if (!/not found|no such/i.test(rm.stderr)) log.warn(`sbx rm ${name}: ${rm.stderr.trim()}`);
+    } else if (agent.mode === "sandbox") void run("sbx", ["stop", name], { timeoutMs: 3e4 });
+    if (opts.deleteFolder && !agent.workspacePath) {
+      const home = resolve3(projectHome(this.hub.slug));
+      const dir2 = resolve3(workspaceFor(agent, this.hub.slug));
+      if (dir2.startsWith(home + sep3) && dir2 !== home && existsSync12(dir2)) {
+        rmSync3(dir2, { recursive: true, force: true });
+        done.push("folder");
+      }
+    }
+    return done;
+  }
+  /** True if sbx lists a sandbox with this name (running or stopped). */
+  async sandboxExists(name) {
+    const r = await run("sbx", ["ls", "--json"], { timeoutMs: 1e4 });
+    try {
+      return (sandboxList(r.stdout) ?? []).some((s) => s.name === name);
+    } catch {
+      return false;
+    }
+  }
+  /** Waits (up to ~90s) for sbx to list the agent's sandbox — creation can take a while the first time. */
+  async whenSandboxExists(id) {
+    for (let i = 0; i < 45; i++) {
+      const r = await run("sbx", ["ls", "--json"], { timeoutMs: 1e4 });
+      try {
+        if ((sandboxList(r.stdout) ?? []).some((s) => s.name === this.name(id))) return true;
+      } catch {
+      }
+      await new Promise((res) => setTimeout(res, 2e3));
+    }
+    return false;
+  }
+  /** Removes the agent's sandbox and starts a fresh one (applies new CPU/memory). The folder is kept. */
+  async recreate(id) {
+    const agent = this.hub.cfg(id);
+    if (!agent || agent.mode !== "sandbox") return;
+    const name = this.name(id);
+    if (this.hub.status(id)?.session.state === "running") await this.stop(id);
+    this.hub.setSession(id, { state: "starting", detail: "Removing the old sandbox\u2026", sandbox: null });
+    const rm = await run("sbx", ["rm", "-f", name], { timeoutMs: 6e4 });
+    if (!rm.ok && !/not found|no such/i.test(rm.stderr)) {
+      this.hub.setSession(id, { state: "failed", detail: `sbx rm failed: ${rm.stderr.trim()}` });
+      return;
+    }
+    this.onSandboxRemoved(id);
+    this.hub.setSession(id, { state: "stopped", detail: null });
+    this.hub.activity("session", id, `Recreating ${agent.name}'s sandbox with new resources`);
+    await this.start(id);
+  }
+  /** Reads each HQ sandbox's real CPU/memory from `sbx ls --json`. */
+  async refreshSandboxSizes() {
+    const r = await run("sbx", ["ls", "--json"], { timeoutMs: 1e4 });
+    if (!r.ok) return;
+    let list = [];
+    try {
+      list = sandboxList(r.stdout) ?? [];
+    } catch {
+      return;
+    }
+    for (const agent of this.hub.snap.config.team) {
+      const found = list.find((s) => s.name === this.name(agent.id));
+      const m = this.hub.snap.setup.machine;
+      const size = !found ? null : found.cpus && found.memory_mib ? { cpus: found.cpus, memoryGb: Math.round(found.memory_mib / 1024 * 10) / 10 } : { cpus: m.cpus, memoryGb: Math.min(32, Math.max(0.5, m.memoryGb / 2)) };
+      const cur = this.hub.status(agent.id)?.session.sandbox;
+      if (JSON.stringify(cur ?? null) !== JSON.stringify(size)) this.hub.setSession(agent.id, { sandbox: size });
+    }
+  }
+  /**
+   * Lets sandboxes reach HQ's port (checked once per run, added only if missing).
+   * The sandbox proxy evaluates host.docker.internal as localhost, so both are allowed.
+   */
+  async ensurePolicy() {
+    if (this.policyOk) return;
+    const port = this.hub.snap.config.project.hqPort;
+    for (const target of [`localhost:${port}`, `host.docker.internal:${port}`]) {
+      if ((await policyVerdict(target)).verdict === "allowed") continue;
+      const add = await run("sbx", ["policy", "allow", "network", target], { timeoutMs: 1e4 });
+      if (!add.ok && POLICY_NOT_INITIALIZED.test(add.stderr + add.stdout)) {
+        void this.recheckSetup();
+        throw new Error("Docker Sandboxes needs a base network policy first. Open the setup checklist \u2192 \u201CSandbox network policy\u201D, or run: sbx policy init balanced");
+      }
+      if (!add.ok) throw new Error(`Could not allow ${target}: ${add.stderr.trim()}`);
+      log.info(`added sandbox network rule: allow ${target}`);
+    }
+    this.policyOk = true;
+  }
+  // ------------------------------------------------------------ terminals
+  /** One terminal view per agent; output goes to every browser. */
+  attach(id) {
+    if (this.terms.has(id)) return;
+    const size = this.sizes.get(id) ?? { cols: 120, rows: 36 };
+    const term = this.backend.attach(
+      this.name(id),
+      size,
+      (d) => this.hub.terminal(id, d),
+      () => {
+        if (this.terms.get(id) === term) this.terms.delete(id);
+      }
+    );
+    this.terms.set(id, term);
+  }
+  detach(id) {
+    this.terms.get(id)?.close();
+    this.terms.delete(id);
+  }
+  /** Types a line into an agent's prompt and submits it. */
+  async typeInto(agentId, text) {
+    if (!await this.backend.type(this.name(agentId), text)) return false;
+    await new Promise((r) => setTimeout(r, 200));
+    return this.backend.enter(this.name(agentId));
+  }
+  async pressEnter(agentId) {
+    return this.backend.enter(this.name(agentId));
+  }
+  input(id, data) {
+    if (id.startsWith("setup:")) return this.fixes.get(id)?.write(data);
+    if (id.startsWith("shell:")) return this.shells.get(id)?.write(data);
+    this.terms.get(id)?.write(data);
+  }
+  resize(id, cols, rows) {
+    const c = Math.max(20, Math.min(400, Math.floor(cols)));
+    const r = Math.max(5, Math.min(200, Math.floor(rows)));
+    const same = this.sizes.get(id)?.cols === c && this.sizes.get(id)?.rows === r;
+    this.sizes.set(id, { cols: c, rows: r });
+    const current = () => id.startsWith("setup:") ? this.fixes.get(id) : id.startsWith("shell:") ? this.shells.get(id) : this.terms.get(id);
+    const pty = current();
+    if (!pty) return;
+    const safeResize = (cs, rs) => {
+      if (current() !== pty) return;
+      try {
+        pty.resize(cs, rs);
+      } catch {
+      }
+    };
+    if (same) {
+      safeResize(c, Math.max(5, r - 1));
+      setTimeout(() => safeResize(c, r), 60);
+    } else safeResize(c, r);
+  }
+  async openWorkspace(id) {
+    const st = this.hub.status(id);
+    const agent = this.hub.cfg(id);
+    const dir2 = st?.session.workspace ?? (agent ? workspaceFor(agent, this.hub.slug) : null);
+    if (!dir2) return;
+    const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer" : "xdg-open";
+    await run(opener, [dir2], { timeoutMs: 5e3 });
+  }
+  // ------------------------------------------------------------ health
+  /** Keeps session state honest: picks up sessions from before a restart, notices crashes. */
+  startPolling() {
+    const tick = async () => {
+      if (this.hub.snap.setup.checks.find((c) => c.id === "tmux")?.status !== "ok") return;
+      for (const agent of this.hub.snap.config.team) {
+        const st = this.hub.status(agent.id);
+        if (!st || st.session.state === "starting") continue;
+        const name = this.name(agent.id);
+        const alive = await this.backend.exists(name);
+        if (alive) {
+          const pane = await this.backend.exitInfo(name);
+          if (pane?.dead) {
+            const detail = await this.backend.screenText(name, 6) || `Exited with code ${pane.exitStatus}`;
+            await this.backend.kill(name);
+            this.detach(agent.id);
+            this.closeShell(agent.id);
+            this.onSessionDown(agent.id);
+            this.hub.setSession(agent.id, { state: "failed", detail });
+            this.hub.setStatus(agent.id, { state: "idle", note: "Session ended" });
+            this.hub.activity("session", agent.id, `${agent.name}'s session ended`);
+            continue;
+          }
+          this.attach(agent.id);
+          if (st.session.state !== "running") {
+            this.hub.setSession(agent.id, { state: "running", detail: null, workspace: workspaceFor(agent, this.hub.slug) });
+            this.hub.setStatus(agent.id, { note: "Reattached" });
+            this.onSessionReattached(agent.id);
+          }
+          if (agent.cli === "codex") await this.watchCodexScreen(agent.id, name);
+          await this.reconcileFromScreen(agent.id, agent.cli, name);
+        } else if (st.session.state === "running") {
+          this.detach(agent.id);
+          this.closeShell(agent.id);
+          this.onSessionDown(agent.id);
+          this.hub.setSession(agent.id, { state: "stopped", detail: null });
+          this.hub.setStatus(agent.id, { state: "idle", note: "Stopped" });
+        }
+      }
+    };
+    void tick();
+    let n = 0;
+    this.polling = setInterval(() => {
+      void tick().catch((e) => log.warn("poll:", e));
+      if (n++ % 10 === 0 && this.hub.snap.setup.sandboxReady) void this.refreshSandboxSizes();
+    }, 3e3);
+  }
+  /**
+   * Codex fires SessionStart only on the first prompt, so HQ reads its screen:
+   * the trust prompts mean "needs you"; the empty prompt means HQ can type.
+   */
+  async watchCodexScreen(agentId, name) {
+    const st = this.hub.status(agentId);
+    if (!st) return;
+    const screen = await this.backend.screenText(name, 14);
+    const TRUST_NOTE = "Asking: approve Codex's folder and hook prompts in the terminal (choose Yes, then Trust all)";
+    if (/Do you trust the contents of this directory|Hooks need review/i.test(screen)) {
+      if (st.note !== TRUST_NOTE) {
+        this.hub.setStatus(agentId, { state: "needs-input", note: TRUST_NOTE });
+        this.hub.activity("agent.needs-input", agentId, `${this.hub.name(agentId)} needs you: approve Codex's trust prompts`);
+      }
+      return;
+    }
+    if (/Ask Codex to do anything/i.test(screen)) {
+      this.onSessionReattached(agentId);
+      if (st.note === TRUST_NOTE || st.note === "Sandbox running" || st.note === "Running locally" || st.note === "Reattached")
+        this.hub.setStatus(agentId, { state: "idle", note: "Ready" });
+    }
+  }
+  /**
+   * Hooks are the main signal, but one can be missed or arrive late (a hook
+   * that timed out, an answer with no tool call after it). When hooks have been
+   * quiet for a while, the screen says what the agent is really doing, and a
+   * wrong state would otherwise hold back queued messages.
+   */
+  async reconcileFromScreen(agentId, cli, name) {
+    const st = this.hub.status(agentId);
+    if (!st || st.session.state !== "running") return;
+    const quietMs = Date.now() - this.lastHookAt(agentId);
+    if (quietMs < SCREEN_QUIET_MS) return;
+    const screen = await this.backend.screenText(name, 10);
+    if (!screen) return;
+    const busy = BUSY.test(screen);
+    const dialog = DIALOG.test(screen);
+    const set = (state, note) => {
+      if (process.env.HQ_DEBUG) log.info(`screen ${agentId}: ${st.state} \u2192 ${state} (${note})`);
+      this.hub.setStatus(agentId, { state, note });
+    };
+    if (st.state === "needs-input") {
+      if (dialog || st.note?.includes("Codex's folder")) return;
+      this.idleScreens.delete(agentId);
+      if (busy) return set("working", "Continuing after your answer");
+      if (cli === "claude" && PROMPT_READY.test(screen)) set("idle", "Waiting for you");
+      return;
+    }
+    if (dialog) return set("needs-input", "Asking: answer the question in the terminal");
+    if (st.state === "idle" && busy) return set("working", "Working");
+    if (st.state === "working" && !busy && cli === "claude") {
+      const n = (this.idleScreens.get(agentId) ?? 0) + 1;
+      this.idleScreens.set(agentId, n);
+      if (n >= 2 && quietMs >= STALE_WORKING_MS) {
+        this.idleScreens.delete(agentId);
+        set("idle", "Finished \u2014 ready for the next instruction");
+      }
+      return;
+    }
+    this.idleScreens.delete(agentId);
+    if (st.state === "idle" && !busy && PROMPT_READY.test(screen)) this.onSessionReattached(agentId);
+  }
+  // ------------------------------------------------------------ setup helper
+  async recheckSetup() {
+    this.hub.setSetup(await runSetupChecks(this.hub.repo, this.hub.snap.config.team));
+  }
+  /** Runs a program in a terminal the browser can watch and type into (id must start with "setup:"). */
+  runTerminal(id, file, args, onExit = () => {
+  }) {
+    if (!id.startsWith("setup:") || this.fixes.has(id)) return;
+    const size = this.sizes.get(id) ?? { cols: 100, rows: 16 };
+    const pty = spawnPty3(file, args, { name: "xterm-256color", cols: size.cols, rows: size.rows, cwd: this.hub.repo.root, env: TERM_ENV3 });
+    this.fixes.set(id, pty);
+    this.hub.terminal(id, `\x1B[2m$ ${[file, ...args].join(" ")}\x1B[0m\r
+`);
+    pty.onData((d) => this.hub.terminal(id, d));
+    pty.onExit(({ exitCode }) => {
+      this.fixes.delete(id);
+      this.hub.terminal(id, `\r
+\x1B[${exitCode === 0 ? "32m\u2713 Done" : `31m\u2717 Exited with code ${exitCode}`}\x1B[0m\r
+`);
+      onExit(exitCode);
+    });
+  }
+  /** Runs a check's fix command in a visible terminal. Only commands HQ itself suggested. */
+  runFix(checkId) {
+    const check = this.hub.snap.setup.checks.find((c) => c.id === checkId);
+    if (!check?.fix?.runnable || !check.fix.command) return;
+    const id = `setup:${checkId}`;
+    if (this.fixes.has(id)) return;
+    const shell = process.platform === "win32" ? "powershell.exe" : process.env.SHELL || "/bin/sh";
+    const args = process.platform === "win32" ? ["-NoProfile", "-Command", check.fix.command] : ["-lc", check.fix.command];
+    const size = this.sizes.get(id) ?? { cols: 100, rows: 16 };
+    const pty = spawnPty3(shell, args, { name: "xterm-256color", cols: size.cols, rows: size.rows, cwd: this.hub.repo.root, env: TERM_ENV3 });
+    this.fixes.set(id, pty);
+    this.hub.terminal(id, `\x1B[2m$ ${check.fix.command}\x1B[0m\r
+`);
+    pty.onData((d) => this.hub.terminal(id, d));
+    pty.onExit(({ exitCode }) => {
+      this.fixes.delete(id);
+      this.hub.terminal(id, `\r
+\x1B[${exitCode === 0 ? "32m\u2713 Done" : `31m\u2717 Exited with code ${exitCode}`}\x1B[0m\r
+`);
+      void this.recheckSetup();
+    });
+  }
+  // ------------------------------------------------------------ shell tab
+  /**
+   * Opens a shell for the "Shell" tab (terminal id `shell:<agentId>`): `sbx exec -it <sandbox> bash`
+   * for a sandboxed agent, your own shell in its folder for Local mode. It runs beside the agent's
+   * session, so the agent keeps working; it closes when you close it or HQ stops.
+   */
+  async openShell(agentId) {
+    const id = `shell:${agentId}`;
+    const agent = this.hub.cfg(agentId);
+    const st = this.hub.status(agentId);
+    if (!agent || this.shells.has(id)) return;
+    if (st?.session.state !== "running") return this.hub.terminal(id, "\x1B[2mStart the agent first; the shell opens inside its sandbox.\x1B[0m\r\n");
+    const gen = (this.shellGen.get(id) ?? 0) + 1;
+    this.shellGen.set(id, gen);
+    const dir2 = st.session.workspace ?? workspaceFor(agent, this.hub.slug);
+    const win = process.platform === "win32";
+    let pty;
+    let banner;
+    try {
+      let file;
+      let args;
+      if (agent.mode === "sandbox") {
+        const name = this.name(agentId);
+        const env = this.envFileFor(agentId);
+        ({ file, args } = await resolveCommand("sbx", ["exec", "-it", ...env ? ["--env-file", env] : [], ...win ? [] : ["-w", dir2], name, "sh", "-c", SANDBOX_SHELL]));
+        banner = `sbx exec -it ${name} bash`;
+      } else {
+        const sh = process.env.SHELL || "/bin/sh";
+        const env = win ? null : this.envFileFor(agentId);
+        file = win ? "powershell.exe" : env ? "/bin/sh" : sh;
+        args = win ? ["-NoLogo"] : env ? ["-c", `${loadEnvFile('"$1"')}; exec "$2" -l`, "sh", env, sh] : ["-l"];
+        banner = `${sh} in ${dir2}`;
+      }
+      if (this.shellGen.get(id) !== gen || this.shells.has(id) || this.hub.status(agentId)?.session.state !== "running") return;
+      const size = this.sizes.get(id) ?? { cols: 100, rows: 30 };
+      pty = spawnPty3(file, args, { name: "xterm-256color", cols: size.cols, rows: size.rows, cwd: dir2, env: SHELL_ENV });
+    } catch (err) {
+      return this.hub.terminal(id, `\x1B[31mCouldn't open a shell: ${err instanceof Error ? err.message : String(err)}\x1B[0m\r
+`);
+    }
+    this.shells.set(id, pty);
+    this.hub.terminal(id, `\x1B[2m$ ${banner}\x1B[0m\r
+`);
+    const startedAt = Date.now();
+    pty.onData((d) => this.hub.terminal(id, d));
+    pty.onExit(({ exitCode }) => {
+      if (this.shells.get(id) === pty) this.shells.delete(id);
+      if (this.closing.has(pty)) return;
+      if (exitCode && Date.now() - startedAt < 2500)
+        return this.hub.terminal(id, `\r
+\x1B[31m[couldn't start the shell (exit ${exitCode}). ${agent.mode === "sandbox" ? "Check that sbx is installed and you're signed in (sbx login)." : "Check your shell."}]\x1B[0m\r
+`);
+      this.hub.terminal(id, `\r
+\x1B[2m[shell closed${exitCode ? ` (exit ${exitCode})` : ""}. Press "New shell" to open another.]\x1B[0m\r
+`);
+    });
+  }
+  closeShell(agentId) {
+    const id = `shell:${agentId}`;
+    this.shellGen.set(id, (this.shellGen.get(id) ?? 0) + 1);
+    const pty = this.shells.get(id);
+    if (!pty) return;
+    this.closing.add(pty);
+    pty.kill();
+    this.shells.delete(id);
+  }
+  /**
+   * The Terminal panel: your own shell on this machine (not in a sandbox), in the folder you pick.
+   * Reopening with the same folder keeps the running shell; `fresh` or a new folder starts a new one.
+   */
+  openHostShell(dir2, fresh) {
+    const id = HOST_TERMINAL;
+    const want = this.hostDir(dir2);
+    if (!want) return this.hub.terminal(id, `\x1B[31mNo such folder: ${dir2}\x1B[0m\r
+`);
+    if (this.shells.has(id) && !fresh && want === this.hostShellDir) return;
+    if (this.shells.has(id)) this.hub.terminal(id, "\x1Bc");
+    this.closeHostShell();
+    const win = process.platform === "win32";
+    const sh = win ? "powershell.exe" : process.env.SHELL || "/bin/sh";
+    const size = this.sizes.get(id) ?? { cols: 100, rows: 30 };
+    let pty;
+    try {
+      pty = spawnPty3(sh, win ? ["-NoLogo"] : ["-l"], { name: "xterm-256color", cols: size.cols, rows: size.rows, cwd: want, env: SHELL_ENV });
+    } catch (err) {
+      return this.hub.terminal(id, `\x1B[31mCouldn't open a shell: ${err instanceof Error ? err.message : String(err)}\x1B[0m\r
+`);
+    }
+    this.shells.set(id, pty);
+    this.hostShellDir = want;
+    this.hub.terminal(id, `\x1B[2m$ ${sh} in ${want}\x1B[0m\r
+`);
+    pty.onData((d) => this.hub.terminal(id, d));
+    pty.onExit(({ exitCode }) => {
+      if (this.shells.get(id) === pty) this.shells.delete(id);
+      if (this.closing.has(pty)) return;
+      this.hub.terminal(id, `\r
+\x1B[2m[shell closed${exitCode ? ` (exit ${exitCode})` : ""}. Press "New shell" to open another.]\x1B[0m\r
+`);
+    });
+  }
+  closeHostShell() {
+    const pty = this.shells.get(HOST_TERMINAL);
+    this.hostShellDir = null;
+    if (!pty) return;
+    this.closing.add(pty);
+    pty.kill();
+    this.shells.delete(HOST_TERMINAL);
+  }
+  hostShellDir = null;
+  /** An existing folder from what you typed ("~" works); the repo when empty. */
+  hostDir(dir2) {
+    const raw = dir2.trim();
+    if (!raw) return this.hub.repo.root;
+    const full = resolve3(this.hub.repo.root, raw === "~" || raw.startsWith("~/") ? homedir2() + raw.slice(1) : raw);
+    try {
+      return statSync3(full).isDirectory() ? full : null;
+    } catch {
+      return null;
+    }
+  }
+  shutdown() {
+    for (const p of this.shells.values()) p.kill();
+    if (this.polling) clearInterval(this.polling);
+    for (const t2 of this.terms.values()) t2.close();
+    this.backend.shutdown();
+    for (const p of this.fixes.values()) p.kill();
+  }
+};
+
+// server/main.ts
+function arg(name) {
+  const i = process.argv.indexOf(`--${name}`);
+  return i > -1 ? process.argv[i + 1] : void 0;
+}
+var flag = (name) => process.argv.includes(`--${name}`);
+async function main() {
+  ensurePtyHelperExecutable();
+  const dev = flag("dev");
+  const port = Number(arg("port") ?? process.env.HQ_PORT ?? 7420);
+  const repo = await detectRepo(resolve4(arg("repo") ?? process.env.HQ_REPO ?? process.cwd()));
+  const { config, isNew } = loadConfig(repo, port);
+  config.project.hqPort = port;
+  const slug2 = config.project.id;
+  const token = agentToken(slug2);
+  const uiToken = browserToken(slug2, dev);
+  log.info(`repo   ${repo.root}${repo.github ? `  (github.com/${repo.github})` : ""}`);
+  log.info("checking setup\u2026");
+  const setup = await runSetupChecks(repo, config.team);
+  for (const c of setup.checks) log.info(`  ${c.status === "ok" ? "\u2713" : c.status === "warning" ? "!" : "\u2717"} ${c.label}: ${c.detail}`);
+  const hub = new Hub(repo, slug2, config, loadPlan(repo.root), setup);
+  hub.snap.welcome = isNew;
+  const sessions = new Sessions(hub, token);
+  const inbox = new Inbox(hub, { type: (id, text) => sessions.typeInto(id, text), enter: (id) => sessions.pressEnter(id) });
+  sessions.onSessionDown = (id) => inbox.sessionDown(id);
+  sessions.onSessionReattached = (id) => inbox.sessionReattached(id);
+  sessions.lastHookAt = (id) => inbox.lastHookAt(id);
+  const sbx = new Sbx(hub);
+  sessions.envFileFor = (id) => existsSync13(sbx.envFile(id)) ? sbx.envFile(id) : null;
+  const mcp = new SbxMcp(hub, (id, file, args, onExit) => sessions.runTerminal(id, file, args, onExit));
+  sessions.onSandboxReady = (id) => {
+    void sbx.syncRules(id);
+    void mcp.attachAll(id);
+    void sbx.refreshPorts(id);
+  };
+  sessions.onSessionDown = /* @__PURE__ */ ((down) => (id) => {
+    down(id);
+    void sbx.refreshPorts(id);
+  })(sessions.onSessionDown);
+  sessions.onSandboxRemoved = (id) => {
+    mcp.forget(id);
+    void sbx.refreshPorts(id);
+  };
+  void sbx.refresh();
+  void mcp.refresh();
+  const planner = new Planner(hub, inbox);
+  planner.actions = new ActionItems(hub, planner);
+  const root = dirname3(dirname3(fileURLToPath(import.meta.url)));
+  const distDir = join13(root, "dist");
+  const uiPort = Number(process.env.HQ_UI_PORT ?? 5173);
+  const uiOrigin = dev ? `http://localhost:${uiPort}` : `http://127.0.0.1:${port}`;
+  if (!dev && !existsSync13(join13(distDir, "index.html"))) log.warn("No built UI found. Run `pnpm build` first, or use `pnpm dev:hq`.");
+  await startHttp({
+    hub,
+    inbox,
+    planner,
+    port,
+    browserToken: uiToken,
+    agentToken: token,
+    distDir: dev ? null : distDir,
+    allowedOrigins: [uiOrigin, `http://127.0.0.1:${uiPort}`, `http://localhost:${port}`, `http://127.0.0.1:${port}`],
+    commands: makeCommands(hub, sessions, planner, inbox, sbx, mcp)
+  });
+  sessions.startPolling();
+  sbx.startApprovalPolling();
+  const github = new GitHubSync(hub, planner, repo.github);
+  github.start();
+  const url = `${uiOrigin}/?token=${uiToken}`;
+  log.info(`
+
+  Setups Works Office is running \u2192 ${url}
+`);
+  if (!flag("no-open")) {
+    const [opener, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url]] : ["xdg-open", [url]];
+    setTimeout(() => void run(opener, args), dev ? 1500 : 0);
+  }
+  const quit = () => {
+    log.info(sessions.backend.persistent ? "stopping HQ \u2014 agent sessions keep running in tmux" : "stopping HQ and its agents \u2014 sandboxes and folders are kept");
+    sessions.shutdown();
+    sbx.stopApprovalPolling();
+    github.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", quit);
+  process.on("SIGTERM", quit);
+}
+main().catch((err) => {
+  if (err?.code === "EADDRINUSE") {
+    log.error(`Port ${arg("port") ?? 7420} is in use \u2014 another HQ may be running. Stop it, or pick another port: npx @setupsworks/office --port 7421`);
+    process.exit(1);
+  }
+  if (err?.code === "EACCES") {
+    const port = arg("port") ?? 7420;
+    log.error(
+      process.platform === "win32" ? `Windows reserved port ${port} (Hyper-V, WSL and Docker reserve port ranges). Pick another: npx @setupsworks/office --port 8420
+  See the reserved ranges with: netsh interface ipv4 show excludedportrange protocol=tcp` : `Not allowed to use port ${port}. Pick another: npx @setupsworks/office --port 8420`
+    );
+    process.exit(1);
+  }
+  log.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});