squadrant 0.9.0

package/dist/squadrantd.js

@@ -0,0 +1,3928 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// packages/core/dist/snapshot.js
+var snapshot_exports = {};
+__export(snapshot_exports, {
+  assembleDaemonSnapshot: () => assembleDaemonSnapshot,
+  buildFreshness: () => buildFreshness
+});
+function buildFreshness(processStartedAt, distBuiltAt2) {
+  return processStartedAt >= distBuiltAt2 ? "fresh" : "stale";
+}
+function assembleDaemonSnapshot(input, now) {
+  return {
+    tier0: {
+      pid: input.pid,
+      uptimeMs: now - input.processStartedAt,
+      version: input.version,
+      build: {
+        state: buildFreshness(input.processStartedAt, input.distBuiltAt),
+        processStartedAt: input.processStartedAt,
+        distBuiltAt: input.distBuiltAt
+      },
+      sweep: {
+        lastSweepAt: input.lastSweepAt,
+        ageMs: input.lastSweepAt == null ? null : now - input.lastSweepAt,
+        cadenceMs: input.sweepCadenceMs
+      },
+      log: input.log
+    },
+    tier1: input.health,
+    tier2: {
+      projects: input.projects.map((p) => ({
+        project: p.project,
+        mailbox: p.mailbox,
+        delivery: {
+          maxSeq: p.mailbox.maxSeq,
+          lastAckedSeq: p.lastAckedSeq,
+          behind: Math.max(0, p.mailbox.maxSeq - p.lastAckedSeq)
+        },
+        store: { byState: p.storeByState, corruptCount: p.corruptCount }
+      })),
+      results: input.results
+    }
+  };
+}
+var init_snapshot = __esm({
+  "packages/core/dist/snapshot.js"() {
+  }
+});
+
+// packages/cli/src/control/squadrantd.ts
+import { join as join13, dirname as dirname5 } from "path";
+import { homedir as homedir8 } from "os";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { readFileSync as readFileSync9 } from "fs";
+
+// packages/shared/dist/config.js
+import fs from "fs";
+import path from "path";
+import os from "os";
+import chalk from "chalk";
+var CONFIG_DIR = path.join(os.homedir(), ".config", "squadrant");
+var DEFAULT_CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+function getDefaultConfig() {
+  return {
+    commandName: "\u{1F3DB}\uFE0F command",
+    hubVault: path.join(os.homedir(), "squadrant-hub"),
+    projects: {},
+    agents: {
+      claude: { cli: "claude", driver: "claude" }
+    },
+    defaults: {
+      maxCrew: 5,
+      worktreeDir: ".worktrees",
+      teammateMode: "in-process",
+      permissions: {
+        command: "auto",
+        captain: "auto",
+        crew: "auto"
+      },
+      models: {
+        command: "opus",
+        captain: "opus",
+        crew: "opus",
+        exploration: "haiku",
+        review: "opus"
+      },
+      roles: {
+        command: { agent: "claude", model: "opus" },
+        captain: { agent: "claude", model: "opus" },
+        crew: { agent: "claude", model: "opus" },
+        exploration: { agent: "claude", model: "haiku" },
+        side: { agent: "claude", model: "opus" }
+      },
+      taskTimeoutMs: 8 * 60 * 60 * 1e3,
+      cmuxEventsBridge: true,
+      // Audit C2: OFF by design — cmux hibernation is global-only and would
+      // hibernate the captain. See the field doc above.
+      cmuxAgentHibernation: false,
+      crewRouting: {
+        rules: [
+          { tier: "extreme", match: "redesign|architect|rewrite|from scratch|deep reasoning", agent: "claude", model: "opus" },
+          { tier: "hard", match: "refactor|migrate|implement|feature|daemon|control-plane", agent: "claude", model: "sonnet" },
+          { tier: "mobile", match: "mobile|ios|swift|android|kotlin|react native", agent: "codex" },
+          { tier: "daily", match: "typo|rename|bump|docs|comment|lint|format", agent: "opencode" }
+        ]
+      }
+    },
+    metrics: {
+      enabled: true,
+      path: path.join(CONFIG_DIR, "metrics.json")
+    }
+  };
+}
+function loadConfig(configPath = DEFAULT_CONFIG_PATH) {
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    if (config.defaults.models && !config.defaults.roles) {
+      const m = config.defaults.models;
+      config.defaults.roles = {
+        command: { agent: "claude", model: m.command },
+        captain: { agent: "claude", model: m.captain },
+        crew: { agent: "claude", model: m.crew },
+        exploration: { agent: "claude", model: m.exploration }
+      };
+    }
+    if (!config.agents) {
+      config.agents = { claude: { cli: "claude", driver: "claude" } };
+    }
+    if (!config.defaults.crewRouting) {
+      config.defaults.crewRouting = getDefaultConfig().defaults.crewRouting;
+      saveConfig(config, configPath);
+      console.error(chalk.cyan("\u2B06 squadrant upgrade: added default crew routing rules to your config (leveled routing now active). Edit defaults.crewRouting in ~/.config/squadrant/config.json or use the squadrant:add-pick-crew-rule skill."));
+    }
+    return config;
+  } catch {
+    return getDefaultConfig();
+  }
+}
+function saveConfig(config, configPath = DEFAULT_CONFIG_PATH) {
+  const dir = path.dirname(configPath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+
+// packages/shared/dist/types/control.js
+var TERMINAL_STATES = /* @__PURE__ */ new Set([
+  "done",
+  "failed",
+  "cancelled"
+]);
+
+// packages/shared/dist/lib/cmux-autoconfig.js
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, rmSync as rmSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join4 } from "path";
+
+// packages/shared/dist/lib/cmux-config.js
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { parse, modify, applyEdits } from "jsonc-parser";
+function defaultCmuxConfigPath() {
+  return join(homedir(), ".config", "cmux", "cmux.json");
+}
+var SOCKET_CONTROL_MODE_PATH = ["automation", "socketControlMode"];
+var AUTOMATION_MODE = "automation";
+var MINIMAL_TEMPLATE = [
+  `{`,
+  `  // [squadrant] file-managed: allow the launchd squadrant daemon to reach the cmux`,
+  `  // control socket for daemon-direct notification delivery (#348/#332).`,
+  `  "automation": {`,
+  `    "socketControlMode": "${AUTOMATION_MODE}"`,
+  `  }`,
+  `}`,
+  ``
+].join("\n");
+function ensureSocketAutomation(opts = {}) {
+  const path13 = opts.path ?? defaultCmuxConfigPath();
+  if (!existsSync(path13)) {
+    mkdirSync(dirname(path13), { recursive: true });
+    writeFileSync(path13, MINIMAL_TEMPLATE);
+    return { path: path13, changed: true, alreadySet: false };
+  }
+  const text = readFileSync(path13, "utf-8");
+  const current = parse(text)?.automation?.socketControlMode;
+  if (current === AUTOMATION_MODE) {
+    return { path: path13, changed: false, alreadySet: true };
+  }
+  const edits = modify(text, [...SOCKET_CONTROL_MODE_PATH], AUTOMATION_MODE, {
+    formattingOptions: { insertSpaces: true, tabSize: 2 }
+  });
+  writeFileSync(path13, applyEdits(text, edits));
+  return { path: path13, changed: true, alreadySet: false };
+}
+
+// packages/shared/dist/lib/cmux-probe.js
+import { spawn } from "child_process";
+import { mkdtempSync, rmSync, existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+
+// packages/shared/dist/lib/cmux-bin.js
+import { execFileSync } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var _cached;
+function resolveBin() {
+  const envBin = process.env.SQUADRANT_CMUX_BIN;
+  if (envBin && existsSync2(envBin))
+    return envBin;
+  try {
+    const configPath = join2(homedir2(), ".config", "squadrant", "config.json");
+    if (existsSync2(configPath)) {
+      const cfg = JSON.parse(readFileSync2(configPath, "utf-8"));
+      const cfgBin = cfg.cmuxBin;
+      if (typeof cfgBin === "string" && existsSync2(cfgBin))
+        return cfgBin;
+    }
+  } catch {
+  }
+  try {
+    const which = execFileSync("which", ["cmux"], { encoding: "utf-8" }).trim();
+    if (which && existsSync2(which))
+      return which;
+  } catch {
+  }
+  return "/Applications/cmux.app/Contents/Resources/bin/cmux";
+}
+function resolveCmuxBin() {
+  return _cached ??= resolveBin();
+}
+
+// packages/shared/dist/lib/cmux-probe.js
+var DENIED_RE = /access denied|only processes started inside cmux|permission denied/i;
+function classifyProbe(r) {
+  if (r.ok)
+    return "reachable";
+  if (r.stderr && DENIED_RE.test(r.stderr))
+    return "denied";
+  return "unknown";
+}
+async function probeCmuxDaemonDirect(opts = {}) {
+  const run = opts.run ?? (() => orphanProbe(opts.timeoutMs ?? 8e3));
+  try {
+    return classifyProbe(await run());
+  } catch {
+    return "unknown";
+  }
+}
+var WORKER_SRC = `
+import { spawn, execFileSync } from "node:child_process";
+import { writeFileSync } from "node:fs";
+const [mode, resultFile, cmuxBin] = process.argv.slice(2);
+if (mode === "launch") {
+  const child = spawn(process.execPath, [process.argv[1], "work", resultFile, cmuxBin], {
+    detached: true, stdio: "ignore",
+  });
+  child.unref();
+  process.exit(0);
+}
+// work mode: wait to be reparented to launchd (PPID 1), then probe.
+const deadline = Date.now() + 3000;
+while (process.ppid !== 1 && Date.now() < deadline) {
+  const until = Date.now() + 25;
+  while (Date.now() < until) { /* tiny busy wait \u2014 no timers in a dying orphan */ }
+}
+let result;
+if (process.ppid !== 1) {
+  result = { ok: false, stderr: "orphan-timeout" };
+} else {
+  try {
+    execFileSync(cmuxBin, ["workspace", "list", "--json"], {
+      encoding: "utf-8", timeout: 10000, env: { ...process.env, CMUX_QUIET: "1" },
+    });
+    result = { ok: true };
+  } catch (e) {
+    const stderr = (e && (e.stderr?.toString?.() || e.message)) || "probe failed";
+    result = { ok: false, stderr };
+  }
+}
+writeFileSync(resultFile, JSON.stringify(result));
+`;
+async function orphanProbe(timeoutMs) {
+  const dir = mkdtempSync(join3(tmpdir(), "cmux-probe-"));
+  const scriptFile = join3(dir, "probe-worker.mjs");
+  const resultFile = join3(dir, "result.json");
+  writeFileSync2(scriptFile, WORKER_SRC);
+  try {
+    const launcher = spawn(process.execPath, [scriptFile, "launch", resultFile, resolveCmuxBin()], { detached: true, stdio: "ignore" });
+    launcher.unref();
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (existsSync3(resultFile)) {
+        try {
+          return JSON.parse(readFileSync3(resultFile, "utf-8"));
+        } catch {
+        }
+      }
+      await sleep(100);
+    }
+    return { ok: false, stderr: "probe-timeout" };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// packages/shared/dist/lib/cmux-autoconfig.js
+function defaultStatePath() {
+  return join4(homedir3(), ".config", "squadrant", "state", "cmux-autoconfig.json");
+}
+function readState(path13) {
+  try {
+    return JSON.parse(readFileSync4(path13, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+async function ensureCmuxAutoConfig(opts = {}) {
+  const statePath = opts.statePath ?? defaultStatePath();
+  const ensureConfig = opts.ensureConfig ?? ensureSocketAutomation;
+  const probe = opts.probe ?? probeCmuxDaemonDirect;
+  const cfg = ensureConfig({ path: opts.configPath });
+  const verdict = await probe();
+  const needsRestart = verdict === "denied";
+  let promptedThisRun = false;
+  if (needsRestart) {
+    const already = readState(statePath).promptedRestart === true;
+    if (!already) {
+      mkdirSync2(dirname2(statePath), { recursive: true });
+      writeFileSync3(statePath, JSON.stringify({ promptedRestart: true }));
+      promptedThisRun = true;
+    }
+  } else if (verdict === "reachable") {
+    if (existsSync4(statePath))
+      rmSync2(statePath, { force: true });
+  }
+  return {
+    configPath: cfg.path,
+    configChanged: cfg.changed,
+    configAlreadySet: cfg.alreadySet,
+    verdict,
+    needsRestart,
+    promptedThisRun
+  };
+}
+
+// packages/shared/dist/lib/compat-manifest.js
+var compatManifest = {
+  tools: {
+    cmux: { min: "0.64.0", lastVerified: "0.64.16" },
+    claude: { min: "2.1.32" },
+    node: { min: "18.0.0", lastVerified: "24.6.0" },
+    // presence-checked; no floor enforced yet
+    codex: { lastVerified: "0.139.0" },
+    gemini: { lastVerified: "0.38.2" },
+    opencode: { lastVerified: "1.17.4" }
+  }
+};
+
+// packages/shared/dist/lib/git-worktree.js
+import { execFileSync as execFileSync2 } from "child_process";
+import path2 from "path";
+
+// packages/shared/dist/lib/resolve-text-input.js
+import fs2 from "fs";
+
+// packages/shared/dist/lib/runtime-sync.js
+import fs3 from "fs";
+import path3 from "path";
+
+// packages/shared/dist/lib/tool-compat.js
+function parseSemVer(v) {
+  const m = v.match(/(\d+)\.(\d+)\.(\d+)/);
+  if (!m)
+    return null;
+  return [parseInt(m[1], 10), parseInt(m[2], 10), parseInt(m[3], 10)];
+}
+function cmpSemVer(a, b) {
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i])
+      return a[i] - b[i];
+  }
+  return 0;
+}
+function checkToolCompat(name, rawVersion, entry) {
+  const installed = parseSemVer(rawVersion);
+  if (!installed)
+    return null;
+  const min = entry.min ? parseSemVer(entry.min) : null;
+  if (min && cmpSemVer(installed, min) < 0) {
+    return `${name} ${rawVersion} < min ${entry.min} \u2014 upgrade to ${entry.min}+`;
+  }
+  if (entry.lastVerified) {
+    const lastVerified = parseSemVer(entry.lastVerified);
+    if (lastVerified && cmpSemVer(installed, lastVerified) > 0) {
+      return `${name} ${rawVersion} > last-verified ${entry.lastVerified} \u2014 re-run compat audit`;
+    }
+  }
+  return null;
+}
+
+// packages/shared/dist/lib/canonical-source.js
+import fs4 from "fs";
+import path4 from "path";
+
+// packages/shared/dist/lib/daily-logs.js
+import { execSync } from "child_process";
+import fs5 from "fs";
+import path5 from "path";
+import matter from "gray-matter";
+
+// packages/core/dist/state-machine.js
+function stampAttempt(rec, patch, now) {
+  const attempts = rec.attempts.slice();
+  const last = attempts.at(-1) ?? { attemptId: "a0", startedAt: now, lastHeartbeatAt: now };
+  attempts[attempts.length === 0 ? 0 : attempts.length - 1] = { ...last, ...patch, lastHeartbeatAt: now };
+  if (attempts.length === 0)
+    attempts.push(last);
+  return { ...rec, attempts };
+}
+function nextPendingTool(current, ev, now) {
+  if (ev.note === "agent.hook.PreToolUse")
+    return { name: ev.tool ?? "tool", since: now };
+  if (ev.note === "posttooluse" || ev.note === "agent.hook.UserPromptSubmit")
+    return void 0;
+  return current;
+}
+function reduce(rec, ev, now) {
+  if (ev.type === "task.reopened") {
+    return { ...rec, state: "working", question: void 0, error: void 0, lastHeartbeat: now, lastEvent: ev.type };
+  }
+  if (TERMINAL_STATES.has(rec.state))
+    return rec;
+  const base = { ...rec, lastHeartbeat: now, lastEvent: ev.type };
+  switch (ev.type) {
+    case "task.started":
+      return {
+        ...stampAttempt(base, { pid: ev.pid }, now),
+        state: "working",
+        pid: ev.pid ?? rec.pid,
+        sessionId: ev.sessionId ?? rec.sessionId,
+        question: void 0,
+        // resuming after a blocked→reply clears the question
+        pendingTool: void 0
+        // #354: a new turn closes any prior tool window
+      };
+    case "task.progress": {
+      const pendingTool = nextPendingTool(rec.pendingTool, ev, now);
+      if (rec.state === "blocked")
+        return { ...rec, lastHeartbeat: now, lastEvent: ev.type, pendingTool };
+      const b = { ...base, pendingTool };
+      if (rec.state === "awaiting-input" || rec.state === "stalled")
+        return { ...stampAttempt(b, {}, now), state: "working" };
+      return stampAttempt(b, {}, now);
+    }
+    case "heartbeat":
+      if (rec.state === "blocked")
+        return { ...rec, lastHeartbeat: now, lastEvent: ev.type };
+      if (rec.state === "awaiting-input")
+        return { ...base, state: "working" };
+      return base;
+    case "task.blocked":
+      if (rec.state === "blocked")
+        return { ...rec, lastHeartbeat: now, lastEvent: ev.type };
+      return { ...base, state: "blocked", question: ev.question, pendingTool: void 0 };
+    case "task.done":
+      return { ...base, state: "done", resultRef: ev.resultRef, parseWarning: ev.parseWarning };
+    case "task.failed":
+      return { ...base, state: "failed", error: ev.error, exitCode: ev.exitCode };
+    case "task.cancelled":
+      return { ...base, state: "cancelled" };
+    case "task.session.ended":
+      return { ...base, state: "cancelled" };
+    case "task.session":
+      return stampAttempt(base, { resumeRef: ev.resumeRef }, now);
+    case "task.turn.started":
+      return { ...stampAttempt(base, {}, now), state: "working", pendingTool: void 0 };
+    case "task.turn.completed":
+      if (rec.state === "blocked")
+        return { ...rec, lastHeartbeat: now, lastEvent: ev.type };
+      return { ...stampAttempt(base, {}, now), state: "awaiting-input", pendingTool: void 0 };
+    case "task.delta":
+      return stampAttempt(base, {}, now);
+    // heartbeat-only
+    case "task.input.requested":
+    case "task.approval.requested":
+      return { ...stampAttempt(base, {}, now), state: "blocked", question: ev.question, pendingTool: void 0 };
+    case "task.reattached":
+      return stampAttempt(base, {}, now);
+    case "task.stalled":
+    case "task.idle":
+    case "task.quiet":
+    case "task.timeout":
+    case "task.reconcile-failed":
+      return rec;
+    default:
+      return rec;
+  }
+}
+
+// packages/core/dist/watchdog.js
+var TOOL_STALL_BUDGET_MS = 10 * 60 * 1e3;
+function evaluateStall(rec, now, toolStallMs = TOOL_STALL_BUDGET_MS) {
+  if (rec.state !== "working")
+    return null;
+  if (rec.mode === "interactive") {
+    if (!rec.pendingTool)
+      return null;
+    if (now - rec.pendingTool.since <= toolStallMs)
+      return null;
+    return { ...rec, state: "stalled", lastEvent: "watchdog.tool-stall" };
+  }
+  const liveness = rec.attempts.at(-1)?.lastHeartbeatAt ?? rec.lastHeartbeat;
+  if (now - liveness <= rec.heartbeatBudgetMs)
+    return null;
+  return { ...rec, state: "stalled", lastEvent: "watchdog.stall" };
+}
+function recoverStall(rec, now) {
+  if (rec.state !== "stalled")
+    return null;
+  return { ...rec, state: "working", lastHeartbeat: now, lastEvent: "watchdog.recover", pendingTool: void 0 };
+}
+
+// packages/core/dist/daemon.js
+var DEFAULT_TASK_TIMEOUT_MS = 8 * 60 * 60 * 1e3;
+var TERMINAL_RECORD_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var ATTENTION_STATES = /* @__PURE__ */ new Set(["done", "blocked", "failed", "stalled", "awaiting-input"]);
+var REAPABLE_SURFACE_STATES = /* @__PURE__ */ new Set(["working", "stalled", "awaiting-input", "blocked"]);
+var IDLE_DEBOUNCE_MS = 12e3;
+function shortId(id) {
+  return id.slice(0, 8);
+}
+function crewTag(r) {
+  const suffix = shortId(r.id);
+  if (r.name != null) {
+    return `[${r.provider}/${r.name} \xB7 ${suffix}]`;
+  }
+  return `[${r.provider}/${suffix}]`;
+}
+function formatMessage(rec, event) {
+  const tag = crewTag(rec);
+  switch (rec.state) {
+    case "done": {
+      const doneMsg = event?.type === "task.done" ? event.message : void 0;
+      const body = doneMsg != null && doneMsg.trim().length > 0 ? doneMsg.split(/\r?\n/)[0].trim().slice(0, 200) : (rec.task ?? "").split(/\r?\n/)[0]?.trim().slice(0, 120) ?? "";
+      return `CREW DONE ${tag}: ${body}`;
+    }
+    case "blocked":
+      return `CREW BLOCKED ${tag}: ${(rec.question ?? "(no question)").trim()}`;
+    case "failed":
+      return `CREW FAILED ${tag}: ${(rec.error ?? "(no error)").trim()}`;
+    case "stalled": {
+      if (event?.type === "task.stalled" && event.tool) {
+        const mins = event.elapsedMs != null ? Math.max(1, Math.round(event.elapsedMs / 6e4)) : null;
+        return `CREW STALLED ${tag}: still running ${event.tool}${mins != null ? ` ~${mins}min` : ""} \u2014 possibly hung (no result yet).`;
+      }
+      return `CREW STALLED ${tag}: no heartbeat in ${rec.heartbeatBudgetMs}ms`;
+    }
+    case "awaiting-input":
+      return `CREW IDLE ${tag}: turn ended / awaiting your input \u2014 review and reply or close.`;
+    default:
+      return null;
+  }
+}
+function formatDelegationReport(rec, originProject, targetProject) {
+  const shortTask = (rec.task ?? "").split(/\r?\n/)[0]?.trim().slice(0, 120) ?? "";
+  switch (rec.state) {
+    case "done":
+      return `\u2705 Cross-project task \u2192 ${targetProject}: done \u2014 ${shortTask}`;
+    case "blocked":
+      return `\u26D4 Cross-project task \u2192 ${targetProject}: blocked \u2014 ${(rec.question ?? "(no question)").trim()}`;
+    case "failed":
+      return `\u26D4 Cross-project task \u2192 ${targetProject}: failed \u2014 ${(rec.error ?? "(no error)").trim()}`;
+    case "stalled":
+      return `\u26A0\uFE0F Cross-project task \u2192 ${targetProject}: stalled (no heartbeat in ${rec.heartbeatBudgetMs}ms)`;
+    default:
+      return null;
+  }
+}
+function firePush(deps, project, prev, next, event, lastCaptainTurnAt) {
+  if (!deps.notify)
+    return;
+  if (prev === next.state)
+    return;
+  if (!ATTENTION_STATES.has(next.state))
+    return;
+  if (next.state === "awaiting-input" && lastCaptainTurnAt != null && deps.now() - lastCaptainTurnAt <= IDLE_DEBOUNCE_MS) {
+    return;
+  }
+  const message = formatMessage(next, event);
+  if (!message)
+    return;
+  try {
+    const r = deps.notify({ project, message, record: next, event });
+    if (r && typeof r.catch === "function") {
+      r.catch(() => {
+      });
+    }
+  } catch {
+  }
+  const reportState = next.state === "done" || next.state === "blocked" || next.state === "failed" || next.state === "stalled" || next.state === "cancelled";
+  if (next.originProject && next.originProject !== project && reportState) {
+    const originMsg = formatDelegationReport(next, next.originProject, project);
+    if (originMsg && deps.notify) {
+      try {
+        const r = deps.notify({ project: next.originProject, message: originMsg, record: next, event });
+        if (r && typeof r.catch === "function")
+          r.catch(() => {
+          });
+      } catch {
+      }
+    }
+  }
+}
+var KNOWN_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "task.started",
+  "task.progress",
+  "heartbeat",
+  "task.blocked",
+  "task.done",
+  "task.failed",
+  "task.session",
+  "task.turn.started",
+  "task.turn.completed",
+  "task.delta",
+  "task.input.requested",
+  "task.approval.requested",
+  "task.reattached",
+  "task.reopened",
+  "task.stalled",
+  "task.idle",
+  "task.quiet",
+  "task.timeout",
+  "task.reconcile-failed",
+  "task.cancelled",
+  "task.session.ended"
+]);
+function createDaemon(deps) {
+  const { store, now } = deps;
+  const lastCaptainTurnAt = /* @__PURE__ */ new Map();
+  const quietNotifiedAt = /* @__PURE__ */ new Map();
+  return {
+    async handle(req) {
+      switch (req.kind) {
+        case "dispatch": {
+          store.put(req.record);
+          if (req.record.originProject) {
+            const origin = req.record.originProject;
+            const msg = `\u{1F4E8} Cross-project task from ${origin}: ${req.record.task}`;
+            if (deps.notify) {
+              try {
+                const r = deps.notify({ project: req.record.project, message: msg, record: req.record, event: { type: "task.started", id: req.record.id } });
+                if (r && typeof r.catch === "function")
+                  r.catch(() => {
+                  });
+              } catch {
+              }
+            }
+            return req.record;
+          }
+          if (req.record.mode === "headless" && deps.launchHeadless) {
+            deps.launchHeadless(req.record).catch((e) => {
+              const error = e instanceof Error ? e.message : String(e);
+              store.put({ ...req.record, state: "failed", lastEvent: "launch-error", error });
+            });
+            return req.record;
+          }
+          if (req.record.mode === "interactive" && deps.launchInteractive) {
+            deps.launchInteractive(req.record).catch((e) => {
+              const error = e instanceof Error ? e.message : String(e);
+              store.put({ ...req.record, state: "failed", lastEvent: "launch-error", error });
+            });
+            return req.record;
+          }
+          const failed = {
+            ...req.record,
+            state: "failed",
+            lastEvent: "no-launcher",
+            error: req.record.mode === "interactive" ? "interactive mode is not yet implemented (deferred interactive-wiring spec); use --mode headless" : `no launcher available for mode '${req.record.mode}'`
+          };
+          store.put(failed);
+          return failed;
+        }
+        case "event": {
+          if (!KNOWN_EVENT_TYPES.has(req.event.type)) {
+            throw new Error(`unknown event type '${req.event.type}' \u2014 not a valid ControlEvent`);
+          }
+          const cur = store.get(req.project, req.event.id);
+          if (!cur)
+            throw new Error(`unknown task ${req.event.id}`);
+          if (req.event.type === "task.started")
+            lastCaptainTurnAt.set(req.event.id, now());
+          if (req.event.type === "task.session.ended" && !TERMINAL_STATES.has(cur.state)) {
+            const liveness = deps.isSurfaceAlive ? await deps.isSurfaceAlive(cur) : "unknown";
+            if (liveness !== "gone")
+              return cur;
+          }
+          const next = reduce(cur, req.event, now());
+          if (next !== cur) {
+            store.put(next);
+            firePush(deps, req.project, cur.state, next, req.event, lastCaptainTurnAt.get(next.id));
+          }
+          return next;
+        }
+        case "status": {
+          const r = store.get(req.project, req.id);
+          if (!r)
+            throw new Error(`unknown task ${req.id}`);
+          return r;
+        }
+        case "list":
+          return store.list(req.project);
+        case "reply": {
+          const r = store.get(req.project, req.id);
+          if (!r)
+            throw new Error(`unknown task ${req.id}`);
+          if (r.state !== "blocked")
+            throw new Error(`task ${req.id} is not blocked (state=${r.state})`);
+          lastCaptainTurnAt.set(r.id, now());
+          const next = reduce(r, { type: "task.started", id: r.id }, now());
+          store.put(next);
+          if (deps.deliverReply)
+            await deps.deliverReply(r, req.message);
+          return next;
+        }
+        case "gate-resolve": {
+          const owning = deps.store.listAll().find((r) => r.gates?.some((g) => g.gateId === req.gateId));
+          if (!owning || !owning.gates)
+            throw new Error(`gate ${req.gateId} not found`);
+          const updatedGates = owning.gates.map((g) => g.gateId === req.gateId ? { ...g, state: "resolved", resolvedBy: req.resolvedBy, resolution: req.payload } : g);
+          deps.store.put({ ...owning, gates: updatedGates });
+          if (deps.resolveInteractiveGate)
+            await deps.resolveInteractiveGate(owning.id, req.payload);
+          return { ...owning, gates: updatedGates };
+        }
+        case "purge": {
+          const r = store.get(req.project, req.id);
+          if (!r)
+            throw new Error(`unknown task ${req.id}`);
+          if (!TERMINAL_STATES.has(r.state) && !req.force) {
+            throw new Error(`task ${req.id} is not terminal (state=${r.state}); use --force to purge anyway`);
+          }
+          store.delete(req.project, req.id);
+          return r;
+        }
+        default: {
+          const _exhaustive = req;
+          throw new Error(`unhandled request kind`);
+        }
+      }
+    },
+    async sweep() {
+      const t = now();
+      const surfaceAlive = deps.isSurfaceAlive ?? (async () => "unknown");
+      for (const r of store.listAll()) {
+        if (TERMINAL_STATES.has(r.state) && t - r.lastHeartbeat > TERMINAL_RECORD_TTL_MS) {
+          store.delete(r.project, r.id);
+          continue;
+        }
+        if (!TERMINAL_STATES.has(r.state)) {
+          const ceiling = deps.taskTimeoutMs ?? DEFAULT_TASK_TIMEOUT_MS;
+          if (t - r.createdAt > ceiling) {
+            const prevState = r.state;
+            const tag = crewTag(r);
+            const hrs = Math.round(ceiling / 36e5);
+            const msg = `CREW TIMEOUT ${tag}: wall-clock exceeded ${hrs}h (id: ${r.id}, state: ${prevState})`;
+            const synthEvent = { type: "task.timeout", id: r.id, taskTimeoutMs: ceiling };
+            store.put({ ...r, state: "cancelled", lastEvent: "sweep.task-timeout" });
+            if (deps.notify) {
+              try {
+                const p = deps.notify({ project: r.project, message: msg, record: r, event: synthEvent });
+                if (p && typeof p.catch === "function") {
+                  p.catch(() => {
+                  });
+                }
+              } catch {
+              }
+            }
+            continue;
+          }
+        }
+        if (r.mode === "interactive" && REAPABLE_SURFACE_STATES.has(r.state)) {
+          const liveness = await surfaceAlive(r);
+          if (liveness === "gone") {
+            store.put({ ...r, state: "cancelled", lastEvent: "sweep.surface-gone" });
+            continue;
+          }
+        }
+        const idle = evaluateStall(r, t);
+        if (idle) {
+          store.put(idle);
+          const synthEvent = idle.pendingTool ? { type: "task.stalled", id: r.id, heartbeatBudgetMs: r.heartbeatBudgetMs, tool: idle.pendingTool.name, elapsedMs: t - idle.pendingTool.since } : { type: "task.stalled", id: r.id, heartbeatBudgetMs: r.heartbeatBudgetMs };
+          firePush(deps, r.project, r.state, idle, synthEvent, lastCaptainTurnAt.get(r.id));
+          continue;
+        }
+        if (r.mode === "interactive" && r.state === "working" && !r.pendingTool) {
+          const liveness = r.attempts.at(-1)?.lastHeartbeatAt ?? r.lastHeartbeat;
+          const quiet = t - liveness;
+          if (quiet > r.heartbeatBudgetMs) {
+            if (deps.notify && quietNotifiedAt.get(r.id) !== liveness) {
+              quietNotifiedAt.set(r.id, liveness);
+              const tag = crewTag(r);
+              const mins = Math.max(1, Math.round(quiet / 6e4));
+              const message = `CREW QUIET ${tag}: working ~${mins}min with no tool activity \u2014 likely deep thinking (no reply expected yet).`;
+              const synthEvent = { type: "task.quiet", id: r.id, quietMs: quiet };
+              try {
+                const p = deps.notify({ project: r.project, message, record: r, event: synthEvent });
+                if (p && typeof p.catch === "function")
+                  p.catch(() => {
+                  });
+              } catch {
+              }
+            }
+            continue;
+          }
+        }
+        if (quietNotifiedAt.has(r.id))
+          quietNotifiedAt.delete(r.id);
+        const recovered = recoverStall(r, t);
+        if (recovered && t - r.lastHeartbeat <= r.heartbeatBudgetMs)
+          store.put(recovered);
+      }
+    },
+    async reconcile() {
+      const alive = deps.isPidAlive ?? (() => true);
+      const surfaceAlive = deps.isSurfaceAlive ?? (async () => "unknown");
+      for (const r of store.listAll()) {
+        if (r.state !== "working" && r.state !== "submitted")
+          continue;
+        if (r.mode === "headless") {
+          if (r.pid != null && alive(r.pid))
+            continue;
+          if (deps.isHeadlessInFlight?.(r.id))
+            continue;
+          const failed = {
+            ...r,
+            state: "failed",
+            lastEvent: "reconcile",
+            error: "orphaned by daemon restart; exit unobserved (conservative fail)"
+          };
+          store.put(failed);
+          const synthEvent = {
+            type: "task.failed",
+            id: r.id,
+            error: failed.error ?? "reconcile"
+          };
+          firePush(deps, r.project, r.state, failed, synthEvent, lastCaptainTurnAt.get(r.id));
+        } else {
+          const liveness = await surfaceAlive(r);
+          if (liveness === "gone") {
+            store.put({ ...r, state: "cancelled", lastEvent: "reconcile.surface-gone" });
+          }
+        }
+      }
+    }
+  };
+}
+
+// packages/core/dist/mailbox.js
+import { promises as fs6 } from "fs";
+import { join as join5 } from "path";
+import { randomUUID } from "crypto";
+function inboxDir(stateRoot) {
+  return join5(stateRoot, "inbox");
+}
+function logPath(stateRoot, project) {
+  return join5(inboxDir(stateRoot), `${project}.log`);
+}
+function extractPayload(event) {
+  const { type: _type, id: _id, ...payload } = event;
+  return payload;
+}
+async function listRotatedOldestFirst(stateRoot, project) {
+  const dir = inboxDir(stateRoot);
+  let entries;
+  try {
+    entries = await fs6.readdir(dir);
+  } catch {
+    return [];
+  }
+  const prefix = `${project}.log.`;
+  return entries.filter((e) => e.startsWith(prefix) && /^\d+$/.test(e.slice(prefix.length))).map((e) => ({ name: e, n: Number(e.slice(prefix.length)) })).sort((a, b) => b.n - a.n).map((e) => join5(dir, e.name));
+}
+async function readMaxSeqFromFile(file) {
+  try {
+    const buf = await fs6.readFile(file, "utf-8");
+    if (!buf.trim())
+      return 0;
+    const lines = buf.trim().split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const obj = JSON.parse(lines[i]);
+        return obj.seq;
+      } catch {
+        continue;
+      }
+    }
+    return 0;
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return 0;
+    throw e;
+  }
+}
+async function readMaxSeq(stateRoot, project) {
+  let max = 0;
+  const files = [
+    logPath(stateRoot, project),
+    ...await listRotatedOldestFirst(stateRoot, project)
+  ];
+  for (const file of files) {
+    const seq = await readMaxSeqFromFile(file);
+    if (seq > max)
+      max = seq;
+  }
+  return max;
+}
+var projectLocks = /* @__PURE__ */ new Map();
+function withProjectLock(project, fn) {
+  const prev = projectLocks.get(project) ?? Promise.resolve();
+  const next = prev.catch(() => void 0).then(fn);
+  projectLocks.set(project, next.catch(() => void 0));
+  return next;
+}
+async function appendToMailbox(opts) {
+  return withProjectLock(opts.project, async () => {
+    const dir = inboxDir(opts.stateRoot);
+    await fs6.mkdir(dir, { recursive: true });
+    const file = logPath(opts.stateRoot, opts.project);
+    const lastSeq = await readMaxSeq(opts.stateRoot, opts.project);
+    const seq = lastSeq + 1;
+    const entry = {
+      seq,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      taskId: opts.taskRecord.id,
+      ...opts.taskRecord.name !== void 0 ? { name: opts.taskRecord.name } : {},
+      kind: opts.event.type,
+      provider: opts.taskRecord.provider,
+      payload: extractPayload(opts.event),
+      message: opts.message ?? null
+    };
+    await fs6.appendFile(file, JSON.stringify(entry) + "\n", { encoding: "utf-8" });
+    return seq;
+  });
+}
+function cursorPath(stateRoot, project, subscriber) {
+  return join5(inboxDir(stateRoot), `${project}.${subscriber}.cursor`);
+}
+async function readCursor(opts) {
+  let buf;
+  try {
+    buf = await fs6.readFile(cursorPath(opts.stateRoot, opts.project, opts.subscriber), "utf-8");
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return null;
+    throw e;
+  }
+  if (!buf.trim())
+    return null;
+  try {
+    return JSON.parse(buf);
+  } catch {
+    return null;
+  }
+}
+async function writeCursor(opts) {
+  await fs6.mkdir(inboxDir(opts.stateRoot), { recursive: true });
+  const dest = cursorPath(opts.stateRoot, opts.project, opts.subscriber);
+  const tmp = `${dest}.${process.pid}.${randomUUID()}.tmp`;
+  const data = {
+    lastAckedSeq: opts.lastAckedSeq,
+    subscriber: opts.subscriber,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const handle = await fs6.open(tmp, "w");
+  try {
+    await handle.writeFile(JSON.stringify(data), { encoding: "utf-8" });
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  try {
+    await fs6.rename(tmp, dest);
+  } catch (e) {
+    await fs6.unlink(tmp).catch(() => {
+    });
+    throw e;
+  }
+}
+async function* readFromCursor(opts) {
+  const rotated = await listRotatedOldestFirst(opts.stateRoot, opts.project);
+  const files = [...rotated, logPath(opts.stateRoot, opts.project)];
+  for (const file of files) {
+    let buf;
+    try {
+      buf = await fs6.readFile(file, "utf-8");
+    } catch (e) {
+      if (e.code === "ENOENT")
+        continue;
+      throw e;
+    }
+    for (const line of buf.split("\n")) {
+      if (!line.trim())
+        continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (entry.seq >= opts.fromSeq)
+        yield entry;
+    }
+  }
+}
+async function mailboxStats(stateRoot, project) {
+  const file = logPath(stateRoot, project);
+  let sizeBytes = 0;
+  try {
+    sizeBytes = (await fs6.stat(file)).size;
+  } catch (e) {
+    if (e.code !== "ENOENT")
+      throw e;
+  }
+  const rotated = await listRotatedOldestFirst(stateRoot, project);
+  return {
+    maxSeq: await readMaxSeq(stateRoot, project),
+    sizeBytes,
+    oldestEntryAgeMs: await oldestEntryAgeMs(file),
+    rotationCount: rotated.length
+  };
+}
+async function oldestEntryAgeMs(file) {
+  try {
+    const buf = await fs6.readFile(file, "utf-8");
+    const firstLine = buf.split("\n").find((l) => l.trim());
+    if (!firstLine)
+      return 0;
+    const entry = JSON.parse(firstLine);
+    return Date.now() - new Date(entry.ts).getTime();
+  } catch {
+    return 0;
+  }
+}
+async function rotateIfNeeded(opts) {
+  return withProjectLock(opts.project, async () => {
+    const file = logPath(opts.stateRoot, opts.project);
+    let size = 0;
+    try {
+      size = (await fs6.stat(file)).size;
+    } catch (e) {
+      if (e.code === "ENOENT")
+        return { rotated: false };
+      throw e;
+    }
+    const age = await oldestEntryAgeMs(file);
+    if (size < opts.maxBytes && age < opts.maxAgeMs)
+      return { rotated: false };
+    const existing = await listRotatedOldestFirst(opts.stateRoot, opts.project);
+    const nums = existing.map((p) => Number(p.slice(p.lastIndexOf(".") + 1))).sort((a, b) => b - a);
+    for (const n of nums) {
+      const src = `${file}.${n}`;
+      const dst = `${file}.${n + 1}`;
+      if (n + 1 > opts.keepCount) {
+        try {
+          await fs6.unlink(src);
+        } catch (e) {
+          if (e.code !== "ENOENT")
+            throw e;
+        }
+      } else {
+        try {
+          await fs6.rename(src, dst);
+        } catch (e) {
+          if (e.code !== "ENOENT")
+            throw e;
+        }
+      }
+    }
+    await fs6.rename(file, `${file}.1`);
+    await fs6.writeFile(file, "", { encoding: "utf-8" });
+    return { rotated: true, from: file, to: `${file}.1` };
+  });
+}
+
+// packages/core/dist/protocol.js
+import { createServer, createConnection } from "net";
+import { existsSync as existsSync5, unlinkSync } from "fs";
+var PROTOCOL_VERSION = 1;
+function encodeMsg(obj) {
+  return JSON.stringify(obj) + "\n";
+}
+function createDecoder(onParseError) {
+  let buf = "";
+  return {
+    push(chunk) {
+      buf += chunk;
+      const out = [];
+      let idx;
+      while ((idx = buf.indexOf("\n")) >= 0) {
+        const line = buf.slice(0, idx);
+        buf = buf.slice(idx + 1);
+        if (!line.trim())
+          continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (typeof parsed === "object" && parsed !== null && parsed.type === "_keepalive")
+            continue;
+          out.push(parsed);
+        } catch {
+          onParseError?.(line);
+        }
+      }
+      return out;
+    },
+    // #87: exposes the unprocessed buffer content — bytes received but not yet
+    // terminated with a newline. The server checks this on connection end to
+    // detect newline-less input and reply with a fast structured error.
+    remainder() {
+      return buf;
+    }
+  };
+}
+function defaultListenError(e) {
+  process.stderr.write(`[squadrantd] ${(/* @__PURE__ */ new Date()).toISOString()} server error: ${e.message}
+`);
+  process.exit(1);
+}
+function startServer(sockPath, handlerOrCallbacks, onListenError = defaultListenError, deps = {}) {
+  const callbacks = typeof handlerOrCallbacks === "function" ? { handler: handlerOrCallbacks } : handlerOrCallbacks;
+  const { handler, onAttach, onAttachInbound, onAttachClose } = callbacks;
+  const setIntervalFn = deps.setInterval ?? setInterval;
+  const clearIntervalFn = deps.clearInterval ?? clearInterval;
+  if (existsSync5(sockPath)) {
+    try {
+      unlinkSync(sockPath);
+    } catch {
+    }
+  }
+  const server = createServer((conn) => {
+    conn.setEncoding("utf-8");
+    let claimType = "none";
+    let keepaliveId;
+    const dec = createDecoder((badLine) => {
+      if (claimType !== "attach") {
+        try {
+          conn.write(encodeMsg({ ok: false, error: `malformed request: invalid JSON`, _v: PROTOCOL_VERSION }));
+        } catch {
+        }
+      }
+    });
+    conn.on("data", async (chunk) => {
+      for (const msg of dec.push(chunk)) {
+        if (claimType === "attach") {
+          onAttachInbound?.(conn, msg);
+          continue;
+        }
+        if (onAttach && msg != null && typeof msg === "object" && msg.op === "attach" && typeof msg.taskId === "string") {
+          claimType = "attach";
+          onAttach(conn, msg);
+          keepaliveId = setIntervalFn(() => {
+            try {
+              conn.write(encodeFrame({ type: "_keepalive" }));
+            } catch {
+            }
+          }, 1e4);
+          continue;
+        }
+        try {
+          const reply = await handler(msg);
+          try {
+            conn.write(encodeMsg({ ok: true, reply, _v: PROTOCOL_VERSION }));
+          } catch {
+          }
+        } catch (e) {
+          const errMsg = e instanceof Error ? e.message : String(e);
+          try {
+            conn.write(encodeMsg({ ok: false, error: errMsg, _v: PROTOCOL_VERSION }));
+          } catch {
+          }
+        }
+      }
+    });
+    conn.on("error", () => {
+    });
+    conn.on("end", () => {
+      if (claimType !== "attach" && dec.remainder().trim()) {
+        try {
+          conn.write(encodeMsg({ ok: false, error: `malformed request: missing newline terminator`, _v: PROTOCOL_VERSION }));
+        } catch {
+        }
+      }
+    });
+    conn.on("close", () => {
+      if (keepaliveId !== void 0)
+        clearIntervalFn(keepaliveId);
+      if (claimType === "attach")
+        onAttachClose?.(conn);
+    });
+  });
+  server.on("error", onListenError);
+  server.listen(sockPath);
+  return server;
+}
+function isDaemonSocketLive(sockPath, timeoutMs = 500) {
+  return new Promise((resolve2) => {
+    if (!existsSync5(sockPath)) {
+      resolve2(false);
+      return;
+    }
+    const conn = createConnection(sockPath);
+    const finish = (v) => {
+      try {
+        conn.destroy();
+      } catch {
+      }
+      resolve2(v);
+    };
+    const timer = setTimeout(() => finish(false), timeoutMs);
+    conn.on("connect", () => {
+      clearTimeout(timer);
+      finish(true);
+    });
+    conn.on("error", () => {
+      clearTimeout(timer);
+      finish(false);
+    });
+  });
+}
+function encodeFrame(f) {
+  return JSON.stringify(f) + "\n";
+}
+
+// packages/core/dist/liveness.js
+var CREW_STALE_MS = 5 * 6e4;
+var CREW_GONE_MS = 30 * 6e4;
+function classifyHealth(lastSeenMs, now, staleMs, goneMs) {
+  if (lastSeenMs == null)
+    return "unknown";
+  const age = now - lastSeenMs;
+  if (age <= staleMs)
+    return "alive";
+  if (age <= goneMs)
+    return "stale";
+  return "gone";
+}
+var TERMINAL = /* @__PURE__ */ new Set(["done", "failed", "cancelled"]);
+function projectHealth(input) {
+  const { project, now, captainName, captainStopped, commandPresent, crews } = input;
+  const out = [];
+  const captainState = captainStopped === true ? "stopped" : captainStopped === false ? "alive" : "unknown";
+  out.push({
+    kind: "captain",
+    project,
+    ref: captainName,
+    state: captainState,
+    lastSeenMs: null,
+    detail: captainState === "stopped" ? "captain workspace closed \u2014 crews reaped; delivery paused" : void 0
+  });
+  if (commandPresent !== null) {
+    out.push({
+      kind: "command",
+      project,
+      ref: "command",
+      state: presence(commandPresent),
+      lastSeenMs: null
+    });
+  }
+  for (const c of crews) {
+    if (TERMINAL.has(c.state))
+      continue;
+    out.push({
+      kind: "crew",
+      project,
+      ref: c.name ?? c.id.slice(0, 8),
+      state: classifyHealth(c.lastHeartbeat, now, CREW_STALE_MS, CREW_GONE_MS),
+      lastSeenMs: c.lastHeartbeat,
+      detail: c.state
+    });
+  }
+  return out;
+}
+function presence(p) {
+  if (p === null)
+    return "unknown";
+  return p ? "alive" : "gone";
+}
+
+// packages/core/dist/store.js
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, readdirSync, renameSync, writeFileSync as writeFileSync4, existsSync as existsSync6, rmSync as rmSync3, statSync } from "fs";
+import { join as join6, resolve, sep } from "path";
+function safeSegment(kind, s) {
+  if (typeof s !== "string" || s.length === 0) {
+    throw new Error(`invalid ${kind}: must be a non-empty string`);
+  }
+  if (s.includes("\0"))
+    throw new Error(`invalid ${kind}: NUL byte not allowed`);
+  if (s === "." || s === ".." || /[/\\]/.test(s)) {
+    throw new Error(`invalid ${kind}: '${s}' \u2014 path separators/traversal not allowed`);
+  }
+  return s;
+}
+function createStore(root) {
+  const rootResolved = resolve(root);
+  const assertUnderRoot = (target) => {
+    const r = resolve(target);
+    if (r !== rootResolved && !r.startsWith(rootResolved + sep)) {
+      throw new Error(`path escapes state root: ${target}`);
+    }
+    return target;
+  };
+  const projDir = (p) => assertUnderRoot(join6(root, safeSegment("project", p)));
+  const taskFile = (p, id) => assertUnderRoot(join6(projDir(p), `${safeSegment("id", id)}.json`));
+  return {
+    put(rec) {
+      mkdirSync3(projDir(rec.project), { recursive: true });
+      const dest = taskFile(rec.project, rec.id);
+      const tmp = `${dest}.tmp`;
+      writeFileSync4(tmp, JSON.stringify(rec, null, 2));
+      renameSync(tmp, dest);
+    },
+    get(project, id) {
+      const f = taskFile(project, id);
+      if (!existsSync6(f))
+        return void 0;
+      try {
+        return JSON.parse(readFileSync5(f, "utf-8"));
+      } catch {
+        return void 0;
+      }
+    },
+    list(project) {
+      const d = projDir(project);
+      if (!existsSync6(d))
+        return [];
+      return readdirSync(d).filter((n) => n.endsWith(".json")).map((n) => {
+        try {
+          return JSON.parse(readFileSync5(join6(d, n), "utf-8"));
+        } catch {
+          return void 0;
+        }
+      }).filter((r) => r !== void 0);
+    },
+    listAll() {
+      if (!existsSync6(root))
+        return [];
+      return readdirSync(root).filter((p) => {
+        try {
+          return statSync(join6(root, p)).isDirectory();
+        } catch {
+          return false;
+        }
+      }).flatMap((p) => this.list(p));
+    },
+    quarantine(project, id) {
+      const f = taskFile(project, id);
+      if (existsSync6(f))
+        renameSync(f, `${f}.corrupt.${Date.now()}`);
+    },
+    delete(project, id) {
+      const f = taskFile(project, id);
+      if (existsSync6(f))
+        rmSync3(f);
+    }
+  };
+}
+
+// packages/core/dist/index.js
+init_snapshot();
+
+// packages/core/dist/launchd.js
+import { execFileSync as execFileSync3 } from "child_process";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync5, readFileSync as readFileSync6, existsSync as existsSync7, openSync, writeSync, closeSync, unlinkSync as unlinkSync2, constants } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname3, join as join7 } from "path";
+import { fileURLToPath } from "url";
+
+// packages/core/dist/crew-pane-reader.js
+var TAIL_LINES = 25;
+function crewPaneTitle(project, name) {
+  return `\u{1F527} ${project}:${name}`;
+}
+function surfaceVerdict(surfaceTitles, wantTitle) {
+  if (!wantTitle)
+    return "unknown";
+  if (surfaceTitles == null)
+    return "unknown";
+  return surfaceTitles.includes(wantTitle) ? "alive" : "gone";
+}
+function createDirectSurfaceLivenessProbe(cmux2, getCaptainTitle) {
+  return async (rec) => {
+    try {
+      if (rec.mode !== "interactive" || !rec.name)
+        return "unknown";
+      const wsId = await cmux2.findWorkspaceId(getCaptainTitle(rec.project));
+      if (!wsId)
+        return "unknown";
+      const surfaces = await cmux2.listSurfaces(wsId);
+      if (surfaces.length === 0)
+        return "unknown";
+      return surfaceVerdict(surfaces.map((s) => s.title ?? ""), crewPaneTitle(rec.project, rec.name));
+    } catch {
+      return "unknown";
+    }
+  };
+}
+function createDirectCrewPaneReader(cmux2, getCaptainTitle) {
+  return async (rec) => {
+    try {
+      if (!rec.name)
+        return null;
+      const wsId = await cmux2.findWorkspaceId(getCaptainTitle(rec.project));
+      if (!wsId)
+        return null;
+      const surfaces = await cmux2.listSurfaces(wsId);
+      const want = crewPaneTitle(rec.project, rec.name);
+      const pane = surfaces.find((s) => s.title === want);
+      if (!pane)
+        return null;
+      const screen = await cmux2.readPaneScreen(pane);
+      if (!screen)
+        return null;
+      return screen.split(/\r?\n/).slice(-TAIL_LINES).join("\n");
+    } catch {
+      return null;
+    }
+  };
+}
+
+// packages/core/dist/gate.js
+function makeGate(opts) {
+  return {
+    gateId: opts.mkId(),
+    taskId: opts.taskId,
+    kind: opts.kind,
+    question: opts.question,
+    state: "pending",
+    createdAt: opts.now
+  };
+}
+
+// packages/core/dist/daemon/context.js
+import { homedir as homedir5 } from "os";
+import { join as join8 } from "path";
+import { spawn as realSpawn } from "child_process";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync5 } from "fs";
+function defaultIsPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e?.code === "EPERM";
+  }
+}
+function buildContext(opts) {
+  const stateRoot = opts.stateRoot ?? join8(homedir5(), ".config", "squadrant", "state");
+  const sockPath = opts.sockPath ?? join8(homedir5(), ".config", "squadrant", "squadrant.sock");
+  const store = createStore(stateRoot);
+  const bootedAt = Date.now();
+  const taskTimeoutMs = loadConfig().defaults.taskTimeoutMs;
+  const isPidAlive = opts.isPidAlive ?? defaultIsPidAlive;
+  const spawn2 = opts.spawn ?? realSpawn;
+  const resultsDir = join8(stateRoot, "_results");
+  mkdirSync5(resultsDir, { recursive: true });
+  const writeResult = (id, payload) => {
+    const p = join8(resultsDir, `${id}.txt`);
+    writeFileSync6(p, payload);
+    return p;
+  };
+  const log = (m) => process.stderr.write(`[squadrantd] ${(/* @__PURE__ */ new Date()).toISOString()} ${m}
+`);
+  return {
+    opts,
+    stateRoot,
+    sockPath,
+    store,
+    bootedAt,
+    lastSweepAt: { value: null },
+    taskTimeoutMs,
+    isPidAlive,
+    spawn: spawn2,
+    resultsDir,
+    writeResult,
+    log,
+    attachConns: /* @__PURE__ */ new Map(),
+    inFlightHeadlessIds: /* @__PURE__ */ new Set(),
+    activeHeadlessKills: /* @__PURE__ */ new Set(),
+    captainMissingStreak: /* @__PURE__ */ new Map(),
+    stoppedProjects: /* @__PURE__ */ new Set(),
+    // Late-bound — start.ts fills these before first use:
+    d: null,
+    notify: null,
+    daemonCmux: void 0,
+    codexDriver: null,
+    opencodeBridge: null,
+    cmuxEventsBridge: null,
+    broadcast: () => {
+    },
+    schedulePromotion: () => {
+    },
+    cancelPromotionsFor: () => {
+    }
+  };
+}
+
+// packages/core/dist/daemon/attach.js
+import { randomUUID as randomUUID2 } from "crypto";
+function createAttach(ctx) {
+  const { attachConns, store, log } = ctx;
+  function broadcast(taskId, f) {
+    const conns = attachConns.get(taskId);
+    if (!conns)
+      return;
+    const wire = encodeFrame(f);
+    for (const conn of conns) {
+      try {
+        conn.write(wire);
+      } catch {
+      }
+    }
+  }
+  const pendingGateTimers = /* @__PURE__ */ new Map();
+  function schedulePromotion(taskId, requestId, kind, question) {
+    const conns = attachConns.get(taskId);
+    if (conns && conns.size > 0)
+      return;
+    const key = `${taskId}#${requestId}`;
+    const prior = pendingGateTimers.get(key);
+    if (prior)
+      clearTimeout(prior.timer);
+    const timer = setTimeout(() => {
+      pendingGateTimers.delete(key);
+      if (attachConns.get(taskId)?.size)
+        return;
+      const rec = store.listAll().find((r) => r.id === taskId);
+      if (!rec)
+        return;
+      const gate = makeGate({ taskId, kind, question, now: Date.now(), mkId: () => randomUUID2() });
+      const gates = [...rec.gates ?? [], gate];
+      store.put({ ...rec, gates });
+      broadcast(taskId, { type: "gate-promoted", taskId, gateId: gate.gateId });
+      log(`gate promoted gateId=${gate.gateId} taskId=${taskId} kind=${kind}`);
+    }, 5e3);
+    timer.unref?.();
+    pendingGateTimers.set(key, { taskId, timer });
+  }
+  function cancelPromotionsFor(taskId) {
+    for (const [key, slot] of pendingGateTimers.entries()) {
+      if (slot.taskId === taskId) {
+        clearTimeout(slot.timer);
+        pendingGateTimers.delete(key);
+      }
+    }
+  }
+  return { broadcast, schedulePromotion, cancelPromotionsFor };
+}
+
+// packages/core/dist/daemon/start.js
+import { join as join10, dirname as dirname4 } from "path";
+import { readdir } from "fs/promises";
+
+// packages/core/dist/daemon/interactive-probe.js
+var STALE_THRESHOLD_MS = 5 * 60 * 1e3;
+var PROBE_QUIET_MS = 2e4;
+function detectTrailingQuestion(text) {
+  if (!text)
+    return null;
+  let inFence = false;
+  let lastLine = null;
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line.startsWith("```")) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence || line === "")
+      continue;
+    lastLine = line;
+  }
+  if (lastLine && lastLine.endsWith("?"))
+    return lastLine;
+  return null;
+}
+var ERROR_BANNER_RE = [
+  /\bAPI Error\b/i,
+  /\bOverloaded\b/,
+  /\b(?:429|500|502|503|504|529)\b[^?]*\b(?:overloaded|unavailable|internal server error|bad gateway|gateway timeout|too many requests|service unavailable)\b/i,
+  /\bretr(?:y|ies)\s+(?:exhausted|limit\s+(?:reached|exceeded))\b/i,
+  /\bmaximum\s+retries\b/i
+];
+var OPTION_RE = /^[❯>›]?\s*(\d+)\.\s+(.*\S)\s*$/;
+var PURE_CHROME_RE = /^[\s─━│┃╭╮╰╯┌┐└┘├┤┬┴┼═║╔╗╚╝╠╣╦╩╬▁▂▃▄▅▆▇█▔▏▕]+$/;
+var STATUS_LINE_RE = /accept edits on|shift\+tab|⏵⏵|\? for shortcuts|esc to interrupt|tokens? (used|left)|context left/i;
+function stripChrome(raw) {
+  let line = raw.replace(/\[[0-9;]*m/g, "");
+  line = line.replace(/^[\s│┃▏▕|]+/, "").replace(/[\s│┃▏▕|]+$/, "");
+  const trimmed = line.trim();
+  if (trimmed === "")
+    return null;
+  if (PURE_CHROME_RE.test(trimmed))
+    return null;
+  if (/^>\s*$/.test(trimmed))
+    return null;
+  if (STATUS_LINE_RE.test(trimmed))
+    return null;
+  return trimmed;
+}
+function classifyPaneTail(tail) {
+  if (!tail)
+    return null;
+  const raw = tail.split(/\r?\n/);
+  const cleaned = raw.map(stripChrome);
+  const options = [];
+  for (let i = 0; i < cleaned.length; i++) {
+    const c = cleaned[i];
+    if (c == null)
+      continue;
+    const m = c.match(OPTION_RE);
+    if (m)
+      options.push({ label: m[2], ci: i });
+  }
+  const hasYes = options.some((o) => /\byes\b/i.test(o.label));
+  const hasNo = options.some((o) => /\bno\b/i.test(o.label));
+  if (options.length >= 2 && hasYes && hasNo) {
+    const firstOptCi = options[0].ci;
+    for (let i = firstOptCi - 1; i >= 0; i--) {
+      const c = cleaned[i];
+      if (c == null)
+        continue;
+      if (c.endsWith("?"))
+        return { kind: "approval", text: c };
+    }
+    return { kind: "approval", text: "Crew is awaiting permission approval." };
+  }
+  const region = cleaned.filter((c) => c != null).join("\n");
+  const q = detectTrailingQuestion(region);
+  if (q)
+    return { kind: "question", text: q };
+  let errLine = null;
+  for (const c of cleaned) {
+    if (c != null && ERROR_BANNER_RE.some((re) => re.test(c)))
+      errLine = c;
+  }
+  if (errLine)
+    return { kind: "error", text: errLine.slice(0, 200) };
+  return null;
+}
+function createInteractiveProbe(deps) {
+  const quietMs = deps.quietMs ?? PROBE_QUIET_MS;
+  const lastTail = /* @__PURE__ */ new Map();
+  async function tick() {
+    let tasks;
+    try {
+      tasks = await deps.listTasks();
+    } catch (e) {
+      deps.log(`probe listTasks failed: ${e.message}`);
+      return;
+    }
+    const now = deps.now();
+    for (const rec of tasks) {
+      if (rec.mode !== "interactive")
+        continue;
+      if (rec.state !== "working")
+        continue;
+      if (!rec.name)
+        continue;
+      if (now - rec.lastHeartbeat <= quietMs)
+        continue;
+      let tail;
+      try {
+        tail = await deps.readPaneTail(rec);
+      } catch (e) {
+        deps.log(`probe read failed for ${rec.id}: ${e.message}`);
+        continue;
+      }
+      if (!tail)
+        continue;
+      if (lastTail.get(rec.id) === tail)
+        continue;
+      lastTail.set(rec.id, tail);
+      const verdict = classifyPaneTail(tail);
+      if (!verdict)
+        continue;
+      const event = verdict.kind === "error" ? {
+        type: "task.failed",
+        id: rec.id,
+        error: `crew session error (pane-detected): ${verdict.text}`
+      } : {
+        type: "task.blocked",
+        id: rec.id,
+        reason: verdict.kind === "approval" ? "crew awaiting permission (pane-detected)" : "crew asked a question (pane-detected)",
+        question: verdict.text
+      };
+      try {
+        await deps.sendEvent(event);
+        const label = verdict.kind === "error" ? "CREW FAILED" : "CREW BLOCKED";
+        deps.log(`probe -> ${label} ${rec.name} (${verdict.kind})`);
+      } catch (e) {
+        deps.log(`probe sendEvent failed for ${rec.id}: ${e.message}`);
+      }
+    }
+  }
+  return { tick };
+}
+
+// packages/core/dist/daemon/probes.js
+function captainNameForProject(project) {
+  const cfg = loadConfig();
+  return cfg.projects?.[project]?.captainName ?? `${project}-captain`;
+}
+function createProbes(ctx) {
+  const { store, log } = ctx;
+  const directSurfaceProbe = (_rec) => {
+    return Promise.resolve("unknown");
+  };
+  function buildInteractiveProbe(deps) {
+    const directPaneReader = createDirectCrewPaneReader(deps.cmux, captainNameForProject);
+    const probe = createInteractiveProbe({
+      project: "_all_",
+      listTasks: async () => store.listAll(),
+      readPaneTail: directPaneReader,
+      sendEvent: async (event) => {
+        const rec = store.listAll().find((r) => r.id === event.id);
+        if (rec) {
+          await ctx.d.handle({ kind: "event", project: rec.project, event });
+        }
+      },
+      now: () => Date.now(),
+      log
+    });
+    let probing = false;
+    return async () => {
+      if (probing)
+        return;
+      probing = true;
+      try {
+        await probe.tick();
+      } finally {
+        probing = false;
+      }
+    };
+  }
+  return { buildInteractiveProbe, directSurfaceProbe };
+}
+function buildSurfaceProbe(ctx, probes, daemonCmux) {
+  if (ctx.opts.isSurfaceAlive)
+    return ctx.opts.isSurfaceAlive;
+  if (daemonCmux) {
+    return createDirectSurfaceLivenessProbe(daemonCmux, captainNameForProject);
+  }
+  return probes.directSurfaceProbe;
+}
+
+// packages/core/dist/delivery/defer-delivery.js
+var DeferDelivery = class extends Error {
+  draft;
+  constructor(draft = null) {
+    super("deferred: captain composing");
+    this.draft = draft;
+    this.name = "DeferDelivery";
+  }
+};
+
+// packages/core/dist/delivery/captain-delivery.js
+function deliverable(entry) {
+  const msg = entry.message;
+  if (msg == null)
+    return null;
+  const trimmed = msg.trim();
+  return trimmed.length > 0 ? msg : null;
+}
+var CaptainDelivery = class {
+  opts;
+  deferCounts = /* @__PURE__ */ new Map();
+  lastContent = /* @__PURE__ */ new Map();
+  stableCounts = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.opts = opts;
+  }
+  /**
+   * Attempt to deliver one mailbox entry to the captain. Calls `send(text, opts)`
+   * and, if the send throws DeferDelivery, tracks defer/stable counts for the
+   * entry's seq and returns {deferred: true} (caller should NOT advance cursor).
+   * On success or null message returns {delivered: true} (caller SHOULD advance).
+   */
+  async deliver(entry, send) {
+    const msg = deliverable(entry);
+    if (!msg)
+      return { delivered: true };
+    const seq = entry.seq;
+    const deferCount = this.deferCounts.get(seq) ?? 0;
+    const stable = (this.stableCounts.get(seq) ?? 0) >= this.opts.stableProbePolls;
+    const probe = stable || deferCount >= this.opts.maxDefers;
+    try {
+      await send(msg, probe ? { probe: true } : void 0);
+      this.deferCounts.delete(seq);
+      this.stableCounts.delete(seq);
+      this.lastContent.delete(seq);
+      return { delivered: true };
+    } catch (e) {
+      if (e instanceof DeferDelivery) {
+        this.deferCounts.set(seq, deferCount + 1);
+        const content = e.draft;
+        if (content && content === this.lastContent.get(seq)) {
+          this.stableCounts.set(seq, (this.stableCounts.get(seq) ?? 0) + 1);
+        } else {
+          this.stableCounts.set(seq, 0);
+        }
+        this.lastContent.set(seq, content);
+        return { deferred: true };
+      }
+      return { deferred: true };
+    }
+  }
+};
+
+// packages/core/dist/daemon/delivery.js
+var CURSOR_SUBSCRIBER = "captain";
+var CAPTAIN_GONE_STREAK_K = 3;
+function discoverCaptainSurface(surfaces, captainTitle) {
+  return surfaces.find((s) => s.title === captainTitle) ?? null;
+}
+function reapOrphanedCrews(store, project) {
+  let reaped = 0;
+  for (const r of store.list(project)) {
+    if (TERMINAL_STATES.has(r.state))
+      continue;
+    if (r.mode !== "interactive")
+      continue;
+    store.put({ ...r, state: "cancelled", lastEvent: "captain-stopped" });
+    reaped++;
+  }
+  return reaped;
+}
+function createDelivery(ctx, daemonCmux) {
+  const { stateRoot, store, log, captainMissingStreak, stoppedProjects, opts } = ctx;
+  const defaultNotify = async (args) => {
+    try {
+      await appendToMailbox({
+        stateRoot,
+        project: args.project,
+        taskRecord: args.record,
+        event: args.event,
+        // Persist the daemon-rendered message (#214/#210): delivered verbatim
+        // rather than re-derived from the raw event (which drifted).
+        message: args.message
+      });
+    } catch (e) {
+      log(`mailbox append failed project=${args.project}: ${e.message}`);
+    }
+  };
+  if (!daemonCmux) {
+    return { defaultNotify, deliveryTick: void 0 };
+  }
+  const cmux2 = daemonCmux;
+  const cfg = loadConfig();
+  const deliveries = /* @__PURE__ */ new Map();
+  const sessionStartMs = Date.now();
+  let delivering = false;
+  const deliveryCore = async () => {
+    const injectedSurfaces = opts.captainSurfaces ?? {};
+    const allProjects = [.../* @__PURE__ */ new Set([
+      ...Object.keys(cfg.projects ?? {}),
+      ...Object.keys(injectedSurfaces),
+      ...store.listAll().map((t) => t.project)
+    ])];
+    for (const project of allProjects) {
+      const projCfg = cfg.projects?.[project];
+      const captainTitle = projCfg?.captainName ?? `${project}-captain`;
+      const wsId = cmux2.findWorkspaceId ? await cmux2.findWorkspaceId(captainTitle) : null;
+      let surface = null;
+      let surfacesLength = 0;
+      if (wsId) {
+        const surfaces = await cmux2.listSurfaces(wsId);
+        surfacesLength = surfaces.length;
+        surface = discoverCaptainSurface(surfaces, captainTitle);
+      }
+      if (!surface)
+        surface = injectedSurfaces[project] ?? null;
+      if (surface) {
+        if (stoppedProjects.has(project)) {
+          stoppedProjects.delete(project);
+          captainMissingStreak.set(project, 0);
+        }
+        captainMissingStreak.set(project, 0);
+      } else {
+        if (surfacesLength > 0) {
+          const streak = (captainMissingStreak.get(project) ?? 0) + 1;
+          captainMissingStreak.set(project, streak);
+          if (streak >= CAPTAIN_GONE_STREAK_K) {
+            if (!stoppedProjects.has(project)) {
+              stoppedProjects.add(project);
+              const reaped = reapOrphanedCrews(store, project);
+              log(`captain ${captainTitle}: surface gone for ${CAPTAIN_GONE_STREAK_K} sweeps \u2014 stopping delivery${reaped > 0 ? `, reaped ${reaped} orphaned crew(s)` : ""}`);
+            }
+          }
+        }
+        continue;
+      }
+      const cursor = await readCursor({ stateRoot, project, subscriber: CURSOR_SUBSCRIBER });
+      const lastAcked = cursor?.lastAckedSeq ?? 0;
+      let d = deliveries.get(project);
+      if (!d) {
+        d = new CaptainDelivery({
+          maxDefers: cfg.delivery?.maxDeferDeliveries ?? 300,
+          stableProbePolls: cfg.delivery?.stableProbePolls ?? 3
+        });
+        deliveries.set(project, d);
+      }
+      for await (const entry of readFromCursor({ stateRoot, project, fromSeq: lastAcked + 1 })) {
+        if (new Date(entry.ts).getTime() < sessionStartMs - STALE_THRESHOLD_MS) {
+          await writeCursor({ stateRoot, project, subscriber: CURSOR_SUBSCRIBER, lastAckedSeq: entry.seq });
+          continue;
+        }
+        const result = await d.deliver(entry, (text, sendOpts) => cmux2.send(surface, text, sendOpts));
+        if ("delivered" in result) {
+          await writeCursor({ stateRoot, project, subscriber: CURSOR_SUBSCRIBER, lastAckedSeq: entry.seq });
+        } else {
+          break;
+        }
+      }
+    }
+  };
+  const deliveryTick = async () => {
+    if (delivering)
+      return;
+    delivering = true;
+    try {
+      await deliveryCore();
+    } finally {
+      delivering = false;
+    }
+  };
+  return { defaultNotify, deliveryTick };
+}
+
+// packages/core/dist/daemon/gates.js
+function createGateResolver(ctx) {
+  return async (taskId, payload) => {
+    const rec = ctx.store.listAll().find((r) => r.id === taskId);
+    try {
+      if (rec?.provider === "opencode") {
+        const decision = payload?.decision === "approve" ? "approve" : "deny";
+        await ctx.opencodeBridge.answer(taskId, decision);
+      } else {
+        await ctx.codexDriver.answer(taskId, payload);
+      }
+    } catch (e) {
+      ctx.log(`gate-resolve answer failed: ${e.message}`);
+    }
+  };
+}
+
+// packages/core/dist/daemon/server.js
+function createServer2(ctx, handlers) {
+  const { store, log, attachConns } = ctx;
+  const { buildHealth, gatherSnapshotInputs, cancelPromotionsFor, broadcast } = handlers;
+  return startServer(ctx.sockPath, {
+    handler: async (msg) => {
+      if (msg.kind === "seed") {
+        store.put(msg.record);
+        return { ok: true };
+      }
+      if (msg.kind === "codex-close") {
+        await ctx.codexDriver.close(msg.taskId).catch((e) => log(`codex close err: ${e}`));
+        return { ok: true };
+      }
+      if (msg.kind === "health") {
+        return buildHealth(msg.project);
+      }
+      if (msg.kind === "snapshot") {
+        const now = Date.now();
+        const { assembleDaemonSnapshot: assembleDaemonSnapshot2 } = await Promise.resolve().then(() => (init_snapshot(), snapshot_exports));
+        return assembleDaemonSnapshot2(await gatherSnapshotInputs(now), now);
+      }
+      if (msg.kind === "event") {
+        return ctx.d.handle(msg);
+      }
+      return ctx.d.handle(msg);
+    },
+    onAttach: (conn, frame) => {
+      let set = attachConns.get(frame.taskId);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        attachConns.set(frame.taskId, set);
+      }
+      set.add(conn);
+      cancelPromotionsFor(frame.taskId);
+      try {
+        conn.write(encodeFrame({ type: "reattached", taskId: frame.taskId }));
+      } catch {
+      }
+    },
+    onAttachInbound: (_conn, frame) => {
+      const f = frame;
+      if (f.op === "say")
+        void ctx.codexDriver.say(f.taskId, f.text).catch((e) => log(`say err: ${e}`));
+      else if (f.op === "steer")
+        void ctx.codexDriver.steer(f.taskId, f.text).catch((e) => log(`steer err: ${e}`));
+      else if (f.op === "interrupt")
+        void ctx.codexDriver.interrupt(f.taskId).catch((e) => log(`interrupt err: ${e}`));
+      else if (f.op === "answer")
+        void ctx.codexDriver.answer(f.taskId, f.payload).catch((e) => log(`answer err: ${e}`));
+    },
+    onAttachClose: (conn) => {
+      for (const set of attachConns.values())
+        set.delete(conn);
+    }
+  });
+}
+
+// packages/core/dist/daemon/snapshot-gather.js
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { join as join9 } from "path";
+import { statSync as statSync2, openSync as openSync2, readSync, closeSync as closeSync2, readdirSync as readdirSync2, readFileSync as readFileSync7 } from "fs";
+var SELF_PATH = fileURLToPath2(import.meta.url);
+function distBuiltAt() {
+  try {
+    return statSync2(SELF_PATH).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function gatherLogStats(path13, now, windowMs) {
+  let sizeBytes = 0;
+  try {
+    sizeBytes = statSync2(path13).size;
+  } catch {
+    return { errorCount: 0, sizeBytes: 0, windowMs };
+  }
+  if (sizeBytes === 0)
+    return { errorCount: 0, sizeBytes, windowMs };
+  const CAP = 256 * 1024;
+  const start = Math.max(0, sizeBytes - CAP);
+  const len = sizeBytes - start;
+  let text = "";
+  try {
+    const fd = openSync2(path13, "r");
+    try {
+      const buf = Buffer.alloc(len);
+      readSync(fd, buf, 0, len, start);
+      text = buf.toString("utf-8");
+    } finally {
+      closeSync2(fd);
+    }
+  } catch {
+    return { errorCount: 0, sizeBytes, windowMs };
+  }
+  const cutoff = now - windowMs;
+  let errorCount = 0;
+  for (const line of text.split("\n")) {
+    if (!/error|failed/i.test(line))
+      continue;
+    const m = line.match(/\d{4}-\d{2}-\d{2}T[\d:.]+Z/);
+    if (m) {
+      const ts = Date.parse(m[0]);
+      if (!Number.isNaN(ts) && ts < cutoff)
+        continue;
+    }
+    errorCount++;
+  }
+  return { errorCount, sizeBytes, windowMs };
+}
+function gatherStoreStats(store, stateRoot, project) {
+  const byState = {};
+  for (const r of store.list(project))
+    byState[r.state] = (byState[r.state] ?? 0) + 1;
+  let corruptCount = 0;
+  const dir = join9(stateRoot, project);
+  try {
+    for (const n of readdirSync2(dir)) {
+      if (n.includes(".corrupt.")) {
+        corruptCount++;
+        continue;
+      }
+      if (!n.endsWith(".json"))
+        continue;
+      try {
+        JSON.parse(readFileSync7(join9(dir, n), "utf-8"));
+      } catch {
+        corruptCount++;
+      }
+    }
+  } catch {
+  }
+  return { byState, corruptCount };
+}
+function gatherResults(resultsDir) {
+  let fileCount = 0;
+  let totalBytes = 0;
+  try {
+    for (const n of readdirSync2(resultsDir)) {
+      try {
+        const s = statSync2(join9(resultsDir, n));
+        if (s.isFile()) {
+          fileCount++;
+          totalBytes += s.size;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return { fileCount, totalBytes };
+}
+
+// packages/core/dist/daemon/start.js
+var CURSOR_SUBSCRIBER2 = "captain";
+var SNAPSHOT_LOG_WINDOW_MS = 60 * 60 * 1e3;
+function startDaemon(ctx, opts, pkgVersion) {
+  const { stateRoot, store, log, isPidAlive, resultsDir, taskTimeoutMs, inFlightHeadlessIds, activeHeadlessKills, broadcast, cancelPromotionsFor } = ctx;
+  const { daemonCmux } = ctx;
+  const probes = createProbes(ctx);
+  const { defaultNotify, deliveryTick: initialDeliveryTick } = createDelivery(ctx, daemonCmux);
+  const notify = opts.notify ?? defaultNotify;
+  const surfaceProbe = buildSurfaceProbe(ctx, probes, daemonCmux);
+  const ingest = (project) => (e) => void ctx.d.handle({ kind: "event", project, event: e });
+  const d = createDaemon({
+    store,
+    now: () => Date.now(),
+    isPidAlive,
+    notify,
+    taskTimeoutMs,
+    isSurfaceAlive: surfaceProbe,
+    launchHeadless: opts.launchHeadless,
+    isHeadlessInFlight: (id) => inFlightHeadlessIds.has(id),
+    launchInteractive: async (rec) => {
+      if (rec.provider === "codex") {
+        await ctx.codexDriver.dispatch(rec);
+        return;
+      }
+      if (rec.provider === "claude") {
+        ingest(rec.project)({ type: "task.started", id: rec.id });
+        return;
+      }
+      if (rec.provider === "opencode") {
+        ingest(rec.project)({ type: "task.started", id: rec.id });
+        if (rec.serverPort)
+          ctx.opencodeBridge.start({ taskId: rec.id, port: rec.serverPort });
+        return;
+      }
+      throw new Error(`interactive mode is not yet implemented for provider '${rec.provider}'; only 'codex', 'claude', and 'opencode' are supported`);
+    },
+    resolveInteractiveGate: createGateResolver(ctx)
+  });
+  ctx.d = d;
+  function buildHealth(only) {
+    const config = loadConfig();
+    const now = Date.now();
+    const known = /* @__PURE__ */ new Set([
+      ...Object.keys(config.projects),
+      ...store.listAll().map((t) => t.project)
+    ]);
+    const names = only ? [only] : [...known];
+    const out = [];
+    for (const project of names) {
+      const proj = config.projects[project];
+      const captainName = proj?.captainName ?? `${project}-captain`;
+      const stopped = ctx.stoppedProjects.has(project);
+      const streak = ctx.captainMissingStreak.get(project);
+      const captainStopped = stopped ? true : streak === 0 ? false : null;
+      out.push(...projectHealth({
+        project,
+        now,
+        captainName,
+        captainStopped,
+        commandPresent: null,
+        crews: store.list(project)
+      }));
+    }
+    return out;
+  }
+  async function gatherSnapshotInputs(now) {
+    const logPath2 = join10(dirname4(stateRoot), "squadrantd.log");
+    const tier2Projects = opts.registeredProjects ?? Object.keys(loadConfig().projects);
+    const projects = await Promise.all(tier2Projects.map(async (project) => {
+      const cursor = await readCursor({ stateRoot, project, subscriber: CURSOR_SUBSCRIBER2 });
+      const storeStats = gatherStoreStats(store, stateRoot, project);
+      return {
+        project,
+        mailbox: await mailboxStats(stateRoot, project),
+        lastAckedSeq: cursor?.lastAckedSeq ?? 0,
+        storeByState: storeStats.byState,
+        corruptCount: storeStats.corruptCount
+      };
+    }));
+    return {
+      pid: process.pid,
+      processStartedAt: ctx.bootedAt,
+      version: pkgVersion,
+      distBuiltAt: distBuiltAt(),
+      lastSweepAt: ctx.lastSweepAt.value,
+      sweepCadenceMs: opts.sweepMs ?? 3e4,
+      log: gatherLogStats(logPath2, now, SNAPSHOT_LOG_WINDOW_MS),
+      health: buildHealth(),
+      projects,
+      results: gatherResults(resultsDir)
+    };
+  }
+  void (async () => {
+    try {
+      await d.reconcile();
+    } catch (e) {
+      log(`reconcile on boot failed: ${e.message}`);
+    }
+    const bootNow = Date.now();
+    const REATTACH_STALE_MS = 10 * 6e4;
+    for (const rec of store.listAll()) {
+      if (rec.provider !== "codex" || rec.mode !== "interactive")
+        continue;
+      if (TERMINAL_STATES.has(rec.state))
+        continue;
+      const lastAttempt = rec.attempts?.at(-1);
+      const last = lastAttempt?.lastHeartbeatAt ?? rec.lastHeartbeat ?? 0;
+      if (bootNow - last > REATTACH_STALE_MS)
+        continue;
+      if (!lastAttempt?.resumeRef)
+        continue;
+      ctx.codexDriver.reattach(rec).catch((e) => {
+        log(`reattach failed for ${rec.id}: ${e.message}`);
+      });
+    }
+    for (const rec of store.listAll()) {
+      if (rec.provider !== "opencode" || rec.mode !== "interactive")
+        continue;
+      if (TERMINAL_STATES.has(rec.state))
+        continue;
+      if (!rec.serverPort)
+        continue;
+      ctx.opencodeBridge.start({ taskId: rec.id, port: rec.serverPort });
+    }
+    const enableCmuxEvents = loadConfig().defaults.cmuxEventsBridge !== false;
+    const cmuxEventsSafe = !!opts.cmuxEventsBridge || !process.env.VITEST;
+    if (enableCmuxEvents && cmuxEventsSafe) {
+      try {
+        ctx.cmuxEventsBridge.start();
+      } catch (e) {
+        log(`cmux events bridge start failed: ${e.message}`);
+      }
+    }
+    const autoConfigSafe = !!opts.runCmuxAutoConfig || !process.env.VITEST;
+    if (autoConfigSafe) {
+      try {
+        const r = await (opts.runCmuxAutoConfig ?? ensureCmuxAutoConfig)();
+        if (r.configChanged)
+          log(`cmux autoconfig: wrote automation socket mode to ${r.configPath}`);
+        if (r.needsRestart && r.promptedThisRun) {
+          log("cmux autoconfig: socket still rejects the daemon \u2014 restart cmux to enable daemon-direct delivery");
+        }
+      } catch (e) {
+        log(`cmux autoconfig failed: ${e.message}`);
+      }
+    }
+  })();
+  const server = createServer2(ctx, { buildHealth, gatherSnapshotInputs, cancelPromotionsFor, broadcast });
+  log(`started pid=${process.pid} sock=${ctx.sockPath} stateRoot=${stateRoot}`);
+  let deliveryTick = initialDeliveryTick;
+  let probeTick;
+  if (daemonCmux) {
+    probeTick = probes.buildInteractiveProbe({ cmux: daemonCmux });
+  }
+  let deliveryTimer;
+  if (daemonCmux && opts.sweepMs && opts.sweepMs > 0) {
+    deliveryTimer = setInterval(() => {
+      void deliveryTick().catch((e) => log(`delivery tick error: ${e.message}`));
+    }, 1e3);
+    deliveryTimer.unref?.();
+  }
+  let probeTimer;
+  if (daemonCmux && opts.sweepMs && opts.sweepMs > 0) {
+    probeTimer = setInterval(() => {
+      void probeTick().catch((e) => log(`probe tick error: ${e.message}`));
+    }, 1e4);
+    probeTimer.unref?.();
+  }
+  let timer;
+  if (opts.sweepMs && opts.sweepMs > 0) {
+    let sweeping = false;
+    timer = setInterval(() => {
+      if (sweeping)
+        return;
+      sweeping = true;
+      ctx.lastSweepAt.value = Date.now();
+      void d.sweep().catch((e) => log(`sweep failed: ${e.message}`)).finally(() => {
+        sweeping = false;
+      });
+    }, opts.sweepMs);
+    timer.unref?.();
+  }
+  const rotationInterval = opts.rotationIntervalMs ?? 6e4;
+  const mboxCfg = {
+    maxBytes: opts.mailboxConfig?.maxBytes ?? 5 * 1024 * 1024,
+    maxAgeMs: opts.mailboxConfig?.maxAgeMs ?? 7 * 24 * 60 * 60 * 1e3,
+    keepCount: opts.mailboxConfig?.keepCount ?? 3
+  };
+  let rotationTimer;
+  if (rotationInterval > 0) {
+    const inboxPath = join10(stateRoot, "inbox");
+    rotationTimer = setInterval(async () => {
+      try {
+        let entries;
+        try {
+          entries = await readdir(inboxPath);
+        } catch {
+          return;
+        }
+        const projects = new Set(entries.filter((e) => e.endsWith(".log")).map((e) => e.slice(0, -".log".length)));
+        for (const project of projects)
+          await rotateIfNeeded({ stateRoot, project, ...mboxCfg });
+      } catch (e) {
+        log(`rotation timer error: ${e.message}`);
+      }
+    }, rotationInterval);
+    rotationTimer.unref?.();
+  }
+  return {
+    stop() {
+      if (deliveryTimer)
+        clearInterval(deliveryTimer);
+      if (probeTimer)
+        clearInterval(probeTimer);
+      if (timer)
+        clearInterval(timer);
+      if (rotationTimer)
+        clearInterval(rotationTimer);
+      try {
+        ctx.cmuxEventsBridge.stop();
+      } catch {
+      }
+      try {
+        ctx.codexDriver.stop?.();
+      } catch {
+      }
+      for (const kill of ctx.activeHeadlessKills)
+        kill();
+      return new Promise((resolve2) => server.close(() => {
+        log("stopped");
+        resolve2();
+      }));
+    },
+    tickDelivery: deliveryTick,
+    tickProbe: probeTick
+  };
+}
+
+// packages/core/dist/session-freshness.js
+import crypto from "crypto";
+import fs7 from "fs";
+import path6 from "path";
+
+// packages/core/dist/crew-lifecycle.js
+import { exec as nodeExec } from "child_process";
+
+// packages/agents/dist/drivers/claude.js
+import { execSync as execSync2 } from "child_process";
+
+// packages/agents/dist/drivers/codex.js
+import { execSync as execSync3 } from "child_process";
+
+// packages/agents/dist/drivers/gemini.js
+import { execSync as execSync4 } from "child_process";
+
+// packages/agents/dist/drivers/opencode.js
+import { execSync as execSync5 } from "child_process";
+
+// packages/agents/dist/drivers/launch-cmd.js
+import fs8 from "fs";
+import path7 from "path";
+
+// packages/agents/dist/projection/cursor.js
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path8 from "path";
+import os2 from "os";
+
+// packages/agents/dist/projection/codex.js
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import path9 from "path";
+import os3 from "os";
+
+// packages/agents/dist/projection/gemini.js
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import path10 from "path";
+import os4 from "os";
+
+// packages/agents/dist/projection/opencode.js
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import path11 from "path";
+import os5 from "os";
+
+// packages/agents/dist/codex/app-server-client.js
+import { EventEmitter } from "events";
+import { spawn as nodeSpawn } from "child_process";
+function _parseChunk(acc, chunk) {
+  acc.buf += chunk;
+  const out = [];
+  let idx;
+  while ((idx = acc.buf.indexOf("\n")) >= 0) {
+    const line = acc.buf.slice(0, idx);
+    acc.buf = acc.buf.slice(idx + 1);
+    if (!line.trim())
+      continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return out;
+}
+var AppServerClient = class extends EventEmitter {
+  proc;
+  acc = { buf: "" };
+  opts;
+  constructor(opts = {}) {
+    super();
+    this.opts = opts;
+  }
+  start() {
+    if (this.proc)
+      throw new Error("AppServerClient already started");
+    const sp = this.opts.spawn ?? defaultSpawn;
+    this.proc = sp();
+    this.proc.stdout.on("data", (d) => this._onStdout(d.toString()));
+    this.proc.stderr.on("data", (d) => this.emit("stderr", d.toString()));
+    this.proc.on("exit", (code, signal) => {
+      this._onClosed();
+      this.emit("closed", { code, signal });
+    });
+    this.proc.on("error", (e) => this.emit("error", e));
+  }
+  kill() {
+    if (this.proc)
+      this.proc.kill();
+  }
+  async initialize() {
+    if (this._handshakeDone)
+      return;
+    if (!this.proc)
+      throw new Error("AppServerClient not started");
+    const info = this.opts.clientInfo ?? { name: "squadrant", version: "0" };
+    const id = this.nextId++;
+    const env = { jsonrpc: "2.0", id, method: "initialize", params: { clientInfo: info } };
+    const res = await new Promise((resolve2, reject) => {
+      this.pending.set(id, { resolve: resolve2, reject });
+      this.proc.stdin.write(JSON.stringify(env) + "\n");
+    });
+    this.proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", method: "initialized" }) + "\n");
+    this._handshakeDone = true;
+    return res;
+  }
+  async startThread(params) {
+    const res = await this._sendRequest("thread/start", params);
+    const id = res?.thread?.id;
+    if (typeof id !== "string")
+      throw new Error(`thread/start: unexpected response shape (no thread.id): ${JSON.stringify(res).slice(0, 200)}`);
+    return { threadId: id };
+  }
+  resumeThread(params) {
+    return this._sendRequest("thread/resume", params);
+  }
+  /** Archive a thread so the app-server tears it down (and reaps any per-thread
+   *  MCP servers it spawned). Called when a codex crew closes. */
+  archiveThread(threadId) {
+    return this._sendRequest("thread/archive", { threadId });
+  }
+  readThread(params) {
+    return this._sendRequest("thread/read", params);
+  }
+  async sendTurn(threadId, text) {
+    const ack = await this._sendRequest("turn/start", {
+      threadId,
+      input: [{ type: "text", text }]
+    });
+    const turnId = ack?.turn?.id;
+    if (typeof turnId !== "string")
+      throw new Error(`turn/start: unexpected ack shape (no turn.id): ${JSON.stringify(ack).slice(0, 200)}`);
+    return new Promise((resolve2, reject) => {
+      const onNote = (n) => {
+        if (n.params?.turn?.id !== turnId)
+          return;
+        if (n.method === "turn/completed") {
+          cleanup();
+          resolve2({ turnId });
+        }
+        if (n.method === "turn/failed") {
+          cleanup();
+          reject(new Error(n.params?.error ?? "turn failed"));
+        }
+      };
+      const onClientClosed = () => {
+        cleanup();
+        reject(new Error("AppServerClient: client closed before turn completed"));
+      };
+      const cleanup = () => {
+        this.off("notification", onNote);
+        this.off("_clientClosed", onClientClosed);
+      };
+      this.on("notification", onNote);
+      this.once("_clientClosed", onClientClosed);
+    });
+  }
+  steerTurn(threadId, text) {
+    return this._sendRequest("turn/steer", { threadId, input: [{ type: "text", text }] });
+  }
+  interruptTurn(threadId) {
+    return this._sendRequest("turn/interrupt", { threadId });
+  }
+  injectItems(threadId, items) {
+    return this._sendRequest("thread/inject_items", { threadId, items });
+  }
+  respondToServerRequest(id, result) {
+    if (!this.proc)
+      throw new Error("AppServerClient not started");
+    this.proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, result }) + "\n");
+  }
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  _handshakeDone = false;
+  _onClosed() {
+    const closedErr = new Error("AppServerClient: child closed before response");
+    for (const slot of this.pending.values())
+      slot.reject(closedErr);
+    this.pending.clear();
+    this.emit("_clientClosed");
+  }
+  _sendRequest(method, params) {
+    if (!this._handshakeDone && method !== "initialize") {
+      throw new Error(`AppServerClient: cannot call '${method}' before handshake (spec \xA73.2)`);
+    }
+    if (!this.proc)
+      throw new Error("AppServerClient not started");
+    const id = this.nextId++;
+    const env = { jsonrpc: "2.0", id, method, params: params ?? {} };
+    return new Promise((resolve2, reject) => {
+      this.pending.set(id, { resolve: resolve2, reject });
+      this.proc.stdin.write(JSON.stringify(env) + "\n");
+    });
+  }
+  _dispatchResponse(msg) {
+    if (typeof msg?.id !== "number")
+      return false;
+    const slot = this.pending.get(msg.id);
+    if (!slot)
+      return false;
+    this.pending.delete(msg.id);
+    if (msg.error)
+      slot.reject(new Error(`${msg.error.message ?? "rpc-error"} (code ${msg.error.code})`));
+    else
+      slot.resolve(msg.result);
+    return true;
+  }
+  _onStdout(s) {
+    for (const msg of _parseChunk(this.acc, s))
+      this._dispatch(msg);
+  }
+  _dispatch(msg) {
+    if (this._dispatchResponse(msg))
+      return;
+    const m = msg;
+    if (typeof m?.method === "string" && typeof m?.id === "number") {
+      this.emit("serverRequest", { id: m.id, method: m.method, params: m.params });
+      return;
+    }
+    if (typeof m?.method === "string" && m?.id === void 0) {
+      this.emit("notification", { method: m.method, params: m.params });
+    }
+  }
+};
+function defaultSpawn() {
+  return nodeSpawn("codex", ["app-server"], { stdio: ["pipe", "pipe", "pipe"] });
+}
+
+// packages/agents/dist/codex/config.js
+import { readFile as readFile5 } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { join as join11 } from "path";
+async function resolveCodexModel() {
+  const home = process.env["CODEX_HOME"] ?? join11(homedir6(), ".codex");
+  const configPath = join11(home, "config.toml");
+  let text;
+  try {
+    text = await readFile5(configPath, "utf8");
+  } catch {
+    return void 0;
+  }
+  const topLevel = text.split(/^\[/m)[0] ?? "";
+  const modelMatch = topLevel.match(/^model\s*=\s*"([^"]+)"/m);
+  if (!modelMatch)
+    return void 0;
+  let model = modelMatch[1];
+  const migSection = text.match(/^\[notice\.model_migrations\]([\s\S]*?)(?=^\[|(?![\s\S]))/m);
+  if (migSection) {
+    const migRe = /^"([^"]+)"\s*=\s*"([^"]+)"/mg;
+    let m;
+    while ((m = migRe.exec(migSection[1])) !== null) {
+      if (m[1] === model) {
+        model = m[2];
+        break;
+      }
+    }
+  }
+  return model;
+}
+
+// packages/agents/dist/codex/normalize.js
+function normalizeAppServerNotification(taskId, n) {
+  const p = n.params ?? {};
+  switch (n.method) {
+    // ── turn lifecycle ────────────────────────────────────────────────────
+    case "turn/started":
+      return {
+        type: "task.turn.started",
+        id: taskId,
+        // TurnStartedNotification carries params.turn.id, not a top-level turnId.
+        turnId: String(p["turn"]?.["id"] ?? "")
+      };
+    case "turn/completed":
+      return {
+        type: "task.turn.completed",
+        id: taskId,
+        // TurnCompletedNotification: same shape as TurnStartedNotification.
+        turnId: String(p["turn"]?.["id"] ?? "")
+      };
+    // ── streaming delta (heartbeat / content) ─────────────────────────────
+    // AgentMessageDeltaNotification: { threadId, turnId, itemId, delta }
+    case "item/agentMessage/delta":
+    // ReasoningTextDeltaNotification: { threadId, turnId, itemId, delta, contentIndex }
+    case "item/reasoning/textDelta":
+    // CommandExecutionOutputDeltaNotification: { threadId, turnId, itemId, delta }
+    case "item/commandExecution/outputDelta":
+      return {
+        type: "task.delta",
+        id: taskId,
+        turnId: String(p["turnId"] ?? ""),
+        chunk: String(p["delta"] ?? "")
+      };
+    // command/exec/outputDelta is connection-scoped (no turnId); map to delta
+    // with empty turnId so the bus can still forward it.
+    // CommandExecOutputDeltaNotification: { processId, stream, deltaBase64, capReached }
+    case "command/exec/outputDelta":
+      return {
+        type: "task.delta",
+        id: taskId,
+        turnId: "",
+        chunk: String(p["deltaBase64"] ?? "")
+      };
+    // ── error ─────────────────────────────────────────────────────────────
+    // ErrorNotification: { error: TurnError, willRetry, threadId, turnId }
+    case "error": {
+      const err = p["error"];
+      const message = String(err?.["message"] ?? p["message"] ?? "error");
+      return { type: "task.failed", id: taskId, error: message };
+    }
+    // ── status-line only — return null ────────────────────────────────────
+    // ThreadTokenUsageUpdatedNotification: { threadId, turnId, tokenUsage }
+    case "thread/tokenUsage/updated":
+    // ContextCompactedNotification (deprecated): { threadId, turnId }
+    case "thread/compacted":
+    // ThreadStatusChangedNotification
+    case "thread/status/changed":
+      return null;
+    // ── unknown / future methods ──────────────────────────────────────────
+    default:
+      return null;
+  }
+}
+
+// packages/agents/dist/codex/driver.js
+var CodexInteractiveDriver = class {
+  client;
+  handshakeP;
+  threadByTask = /* @__PURE__ */ new Map();
+  taskByThread = /* @__PURE__ */ new Map();
+  /**
+   * taskId → in-flight dispatch promise. The first-turn say() can arrive while
+   * dispatch() is still awaiting startThread (threadByTask not yet set); say()
+   * awaits this gate before reading threadByTask so the first turn isn't lost
+   * with "no thread for task" (issue #212).
+   */
+  dispatchByTask = /* @__PURE__ */ new Map();
+  /** taskId → last pending server-request {id, method} (for answer()) */
+  serverRequestByTask = /* @__PURE__ */ new Map();
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async ensureClient() {
+    if (this.client)
+      return this.client;
+    const c = (this.deps.makeClient ?? (() => new AppServerClient({ clientInfo: { name: "squadrant", version: "iv" } })))();
+    this.client = c;
+    c.start();
+    c.on("notification", (n) => this.onNotification(n));
+    c.on("serverRequest", (r) => this.onServerRequest(r));
+    c.on("closed", () => {
+      this.client = void 0;
+      this.handshakeP = void 0;
+    });
+    return c;
+  }
+  async ensureHandshake() {
+    const c = await this.ensureClient();
+    if (!this.handshakeP)
+      this.handshakeP = c.initialize().then(() => {
+      });
+    return this.handshakeP;
+  }
+  async dispatch(rec) {
+    const p = this.runDispatch(rec);
+    this.dispatchByTask.set(rec.id, p.then(() => {
+    }, () => {
+    }));
+    try {
+      await p;
+    } finally {
+      this.dispatchByTask.delete(rec.id);
+    }
+  }
+  async runDispatch(rec) {
+    try {
+      const c = await this.ensureClient();
+      await withTimeout(this.ensureHandshake(), 1e4, "handshake timed out");
+      const model = rec.model ?? await resolveCodexModel();
+      const { threadId } = await c.startThread({
+        cwd: rec.cwd ?? process.cwd(),
+        model,
+        // Parity with claude/opencode crews, which run UNSANDBOXED (no Seatbelt).
+        // Codex was the only agent under `workspace-write`, and that FS sandbox
+        // blocked `squadrant crew signal …` from reaching the daemon socket (which
+        // lives outside the workspace) — breaking the done/blocked/failed
+        // lifecycle. Codex's AF_UNIX-socket allowance has no stable config path
+        // (it's gated behind the experimental_network feature), so the surgical
+        // writable_roots escape is not viable. danger-full-access removes the FS
+        // jail so signals work; approvalPolicy still gates risky ops when set to
+        // "untrusted" (the gate axis is independent of the sandbox axis).
+        sandbox: "danger-full-access",
+        approvalPolicy: rec.approvalPolicy ?? "never",
+        developerInstructions: buildCodexDeveloperInstructions(rec)
+      });
+      this.threadByTask.set(rec.id, threadId);
+      this.taskByThread.set(threadId, rec.id);
+      this.deps.emit({ type: "task.session", id: rec.id, resumeRef: threadId });
+      this.deps.emit({ type: "task.started", id: rec.id });
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      this.deps.emit({ type: "task.failed", id: rec.id, error: `handshake/start failed: ${msg}` });
+      throw e;
+    }
+  }
+  async say(taskId, text) {
+    await this.dispatchByTask.get(taskId);
+    const c = this.client;
+    const tid = this.threadByTask.get(taskId);
+    if (!tid)
+      throw new Error(`no thread for task ${taskId}`);
+    await c.sendTurn(tid, text);
+  }
+  async steer(taskId, text) {
+    const c = this.client;
+    const tid = this.threadByTask.get(taskId);
+    if (!tid)
+      throw new Error(`no thread for task ${taskId}`);
+    await c.steerTurn(tid, text);
+  }
+  async interrupt(taskId) {
+    const c = this.client;
+    const tid = this.threadByTask.get(taskId);
+    if (!tid)
+      throw new Error(`no thread for task ${taskId}`);
+    await c.interruptTurn(tid);
+  }
+  /**
+   * Tear down a task's thread when its crew closes. Squadrant runs ONE shared
+   * app-server with a thread per crew; closing the cmux pane only kills the
+   * `crew attach` renderer, so without this the thread — and the gitnexus/pay
+   * MCP servers it spawned — leak forever (verified: ~53MB per orphaned crew).
+   * Archiving the thread lets the app-server reap it and its MCP children.
+   */
+  async close(taskId) {
+    const tid = this.threadByTask.get(taskId);
+    this.serverRequestByTask.delete(taskId);
+    if (!tid)
+      return;
+    this.threadByTask.delete(taskId);
+    this.taskByThread.delete(tid);
+    try {
+      await this.client?.archiveThread(tid);
+    } catch {
+    }
+  }
+  /** Kill the long-lived app-server child process on daemon shutdown. */
+  stop() {
+    this.client?.kill();
+  }
+  async answer(taskId, payload) {
+    const c = this.client;
+    const rec = this.serverRequestByTask.get(taskId);
+    if (rec == null)
+      throw new Error(`no pending server-request for task ${taskId}`);
+    c.respondToServerRequest(rec.id, this.mapAnswerPayload(payload, rec.method));
+    this.serverRequestByTask.delete(taskId);
+  }
+  /**
+   * Map the captain-facing payload ({text, decision}) to the response shape
+   * the codex app-server expects for the specific request method.
+   *
+   * Old protocol (applyPatchApproval / execCommandApproval):
+   *   { decision: ReviewDecision }  where ReviewDecision = "approved" | "denied" | …
+   *
+   * v2 protocol (item/commandExecution/requestApproval / item/fileChange/requestApproval):
+   *   { decision: CommandExecutionApprovalDecision }  where decision = "accept" | "decline" | …
+   *
+   * Non-approval requests (text input) pass through unchanged.
+   */
+  mapAnswerPayload(payload, method) {
+    if (typeof payload !== "object" || !payload)
+      return payload;
+    const p = payload;
+    if (typeof p.decision !== "string")
+      return payload;
+    if (method === "applyPatchApproval" || method === "execCommandApproval") {
+      const d = p.decision === "approve" ? "approved" : "denied";
+      return { decision: d };
+    }
+    if (method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval") {
+      const d = p.decision === "approve" ? "accept" : "decline";
+      return { decision: d };
+    }
+    return { decision: p.decision };
+  }
+  async reattach(rec) {
+    await this.ensureHandshake();
+    const c = this.client;
+    const resumeRef = rec.attempts.at(-1)?.resumeRef;
+    if (!resumeRef)
+      throw new Error(`reattach: no resumeRef on task ${rec.id}`);
+    await c.resumeThread({ threadId: resumeRef, cwd: rec.cwd });
+    this.threadByTask.set(rec.id, resumeRef);
+    this.taskByThread.set(resumeRef, rec.id);
+    this.deps.emit({ type: "task.reattached", id: rec.id });
+  }
+  onNotification(n) {
+    const tid = n.params?.threadId ?? n.params?.thread_id;
+    const taskId = tid ? this.taskByThread.get(tid) : void 0;
+    if (!taskId)
+      return;
+    const ev = normalizeAppServerNotification(taskId, n);
+    if (ev)
+      this.deps.emit(ev);
+  }
+  onServerRequest(r) {
+    const tid = r.params?.threadId ?? r.params?.thread_id;
+    let taskId = tid ? this.taskByThread.get(tid) : void 0;
+    if (!taskId && !tid) {
+      if (this.taskByThread.size === 1) {
+        taskId = this.taskByThread.values().next().value;
+      } else {
+        process.stderr.write(`[codex/driver] serverRequest ${r.method} dropped: no threadId and ${this.taskByThread.size} active tasks
+`);
+        return;
+      }
+    }
+    if (!taskId)
+      return;
+    this.serverRequestByTask.set(taskId, { id: r.id, method: r.method });
+    const isApproval = r.method.includes("Approval") || r.method.includes("approval");
+    if (isApproval) {
+      this.deps.emit({
+        type: "task.approval.requested",
+        id: taskId,
+        requestId: r.id,
+        question: String(r.params?.question ?? r.method),
+        kind: r.method
+      });
+    } else {
+      this.deps.emit({
+        type: "task.input.requested",
+        id: taskId,
+        requestId: r.id,
+        question: String(r.params?.question ?? r.method)
+      });
+    }
+  }
+};
+function buildCodexDeveloperInstructions(rec) {
+  const directive = `You are squadrant crew task ${rec.id} in project ${rec.project}. When you finish, run EXACTLY: squadrant crew signal done --task-id ${rec.id} --project ${rec.project} --message "<one-line summary>". If you are blocked or fail, run squadrant crew signal blocked|failed with the same --task-id ${rec.id} --project ${rec.project} flags.`;
+  return rec.roleInstructions ? `${rec.roleInstructions}
+
+${directive}` : directive;
+}
+function withTimeout(p, ms, msg) {
+  return new Promise((resolve2, reject) => {
+    const t = setTimeout(() => reject(new Error(msg)), ms);
+    p.then((v) => {
+      clearTimeout(t);
+      resolve2(v);
+    }, (e) => {
+      clearTimeout(t);
+      reject(e);
+    });
+  });
+}
+
+// packages/agents/dist/opencode/sse-bridge.js
+var OpencodeSseBridge = class {
+  controllers = /* @__PURE__ */ new Map();
+  /** taskId → the crew's opencode server port (for permission-reply POSTs). */
+  portByTask = /* @__PURE__ */ new Map();
+  /** taskId → the last unresolved permission on the bus (for answer()). */
+  pendingPermByTask = /* @__PURE__ */ new Map();
+  /** Synthetic monotonic request id. opencode has no numeric id on the bus, but
+   *  task.approval.requested carries one (codex parity) to key gate promotion. */
+  nextRequestId = 1;
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /** Begin subscribing to the crew's /event stream. Idempotent per task. */
+  start(o) {
+    if (this.controllers.has(o.taskId))
+      return;
+    this.portByTask.set(o.taskId, o.port);
+    const ac = new AbortController();
+    this.controllers.set(o.taskId, ac);
+    void this.run(o.taskId, o.port, ac);
+  }
+  /** Stop subscribing for a task (crew closed / terminal). */
+  stop(taskId) {
+    const ac = this.controllers.get(taskId);
+    if (ac) {
+      ac.abort();
+      this.controllers.delete(taskId);
+    }
+    this.portByTask.delete(taskId);
+    this.pendingPermByTask.delete(taskId);
+  }
+  /**
+   * Resolve a pending opencode permission by POSTing the captain's decision to
+   * the crew's server (live-verified, opencode 1.15.13: POST
+   * /session/{sessionID}/permissions/{permissionID} with
+   * { response: "once" | "reject" } → 200, fires permission.replied). Mirrors
+   * codex's driver.answer(). Returns true if there WAS a pending permission (so
+   * the caller knows the answer was an approval, not a reply to a plain `signal
+   * blocked` question); false if nothing was pending (already resolved on the
+   * bus, or no gate).
+   */
+  async answer(taskId, decision) {
+    const pend = this.pendingPermByTask.get(taskId);
+    const port = this.portByTask.get(taskId);
+    if (!pend || port == null)
+      return false;
+    this.pendingPermByTask.delete(taskId);
+    const fetchImpl = this.deps.fetchImpl ?? fetch;
+    const response = decision === "approve" ? "once" : "reject";
+    try {
+      await fetchImpl(`http://127.0.0.1:${port}/session/${pend.sessionID}/permissions/${pend.permID}`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ response })
+      });
+    } catch (e) {
+      this.deps.log?.(`opencode permission reply failed for ${taskId}: ${e.message}`);
+    }
+    this.deps.emit({ type: "task.started", id: taskId });
+    return true;
+  }
+  async run(taskId, port, ac) {
+    const fetchImpl = this.deps.fetchImpl ?? fetch;
+    const sleep2 = this.deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const reconnectMs = this.deps.reconnectMs ?? 500;
+    const maxBoot = this.deps.maxBootAttempts ?? 60;
+    const url = `http://127.0.0.1:${port}/event`;
+    let booted = false;
+    let bootAttempts = 0;
+    while (!ac.signal.aborted) {
+      try {
+        const res = await fetchImpl(url, {
+          signal: ac.signal,
+          headers: { accept: "text/event-stream" }
+        });
+        if (!res.ok || !res.body)
+          throw new Error(`status ${res.status}`);
+        booted = true;
+        await this.consume(taskId, res.body, ac);
+        break;
+      } catch (e) {
+        if (ac.signal.aborted)
+          return;
+        if (!booted) {
+          bootAttempts++;
+          if (bootAttempts >= maxBoot) {
+            this.deps.log?.(`opencode SSE bridge: gave up connecting to ${url} after ${bootAttempts} attempts: ${e.message}`);
+            this.controllers.delete(taskId);
+            return;
+          }
+        }
+        await sleep2(reconnectMs);
+      }
+    }
+    this.controllers.delete(taskId);
+  }
+  async consume(taskId, body, ac) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buf = "";
+    try {
+      while (!ac.signal.aborted) {
+        const { done, value } = await reader.read();
+        if (done)
+          return;
+        buf += decoder.decode(value, { stream: true });
+        let nl;
+        while ((nl = buf.indexOf("\n")) >= 0) {
+          const line = buf.slice(0, nl);
+          buf = buf.slice(nl + 1);
+          this.handleLine(taskId, line);
+        }
+      }
+    } finally {
+      try {
+        await reader.cancel();
+      } catch {
+      }
+    }
+  }
+  handleLine(taskId, rawLine) {
+    let line = rawLine.trim();
+    if (!line)
+      return;
+    if (line.startsWith("data:"))
+      line = line.slice(5).trim();
+    if (!line.startsWith("{"))
+      return;
+    let json;
+    try {
+      json = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (json?.type === "session.idle") {
+      this.deps.emit({
+        type: "task.turn.completed",
+        id: taskId,
+        turnId: json.properties?.sessionID ?? "opencode"
+      });
+    } else if (json?.type === "permission.asked") {
+      const p = json.properties;
+      if (p?.id && p?.sessionID) {
+        this.pendingPermByTask.set(taskId, { permID: p.id, sessionID: p.sessionID });
+        const tool = p.permission ?? "a tool";
+        const cmd = Array.isArray(p.patterns) && p.patterns.length ? `: ${p.patterns.join(" ")}` : "";
+        this.deps.emit({
+          type: "task.approval.requested",
+          id: taskId,
+          requestId: this.nextRequestId++,
+          question: `opencode requests permission to run ${tool}${cmd}`,
+          kind: tool
+        });
+      }
+    } else if (json?.type === "permission.replied") {
+      this.pendingPermByTask.delete(taskId);
+    }
+  }
+};
+
+// packages/agents/dist/interactive/claude.js
+import { execSync as execSync6 } from "child_process";
+import { readFileSync as readFileSync8 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join12 } from "path";
+
+// packages/agents/dist/headless/types.js
+var HEADLESS_ERROR_TAIL = 2e3;
+
+// packages/agents/dist/headless/claude.js
+var claudeHeadless = {
+  provider: "claude",
+  buildCommand(task, sessionId) {
+    const argv = ["claude", "-p", "--output-format", "json"];
+    if (sessionId)
+      argv.push("--resume", sessionId);
+    argv.push(task);
+    return argv;
+  },
+  parseResult(stdout, exitCode) {
+    if (exitCode !== 0) {
+      return { outcome: "failed", exitCode, error: stdout.slice(-HEADLESS_ERROR_TAIL) };
+    }
+    try {
+      const j = JSON.parse(stdout);
+      if (j.is_error)
+        return { outcome: "failed", error: String(j.result ?? "is_error"), sessionId: j.session_id };
+      const payload = typeof j.result === "string" ? j.result : j.result == null ? "" : JSON.stringify(j.result);
+      return { outcome: "done", sessionId: j.session_id, payload };
+    } catch {
+      return { outcome: "done", parseWarning: true, payload: stdout };
+    }
+  }
+};
+
+// packages/agents/dist/headless/opencode.js
+var opencodeHeadless = {
+  provider: "opencode",
+  buildCommand(task, sessionId) {
+    const argv = ["opencode", "run", "--format", "json"];
+    if (sessionId)
+      argv.push("--session", sessionId);
+    argv.push(task);
+    return argv;
+  },
+  parseResult(stdout, exitCode) {
+    if (exitCode !== 0)
+      return { outcome: "failed", exitCode, error: stdout.slice(-HEADLESS_ERROR_TAIL) };
+    try {
+      const j = JSON.parse(stdout);
+      const payload = typeof j.result === "string" ? j.result : JSON.stringify(j.result ?? stdout);
+      return { outcome: "done", sessionId: j.sessionID ?? j.session_id, payload };
+    } catch {
+      return { outcome: "done", parseWarning: true, payload: stdout };
+    }
+  }
+};
+
+// packages/agents/dist/headless/codex.js
+var codexHeadless = {
+  provider: "codex",
+  buildCommand(task, sessionId) {
+    const opts = ["--json", "--skip-git-repo-check", "--sandbox", "workspace-write"];
+    if (sessionId)
+      return ["codex", "exec", "resume", sessionId, ...opts, task];
+    return ["codex", "exec", ...opts, task];
+  },
+  parseResult(stdout, exitCode) {
+    if (exitCode !== 0)
+      return { outcome: "failed", exitCode, error: stdout.slice(-HEADLESS_ERROR_TAIL) };
+    return { outcome: "done", payload: stdout };
+  }
+};
+
+// packages/agents/dist/headless/registry.js
+var ADAPTERS = {
+  claude: claudeHeadless,
+  opencode: opencodeHeadless,
+  codex: codexHeadless
+};
+function getHeadlessAdapter(provider) {
+  const a = ADAPTERS[provider];
+  if (!a)
+    throw new Error(`no headless adapter for provider '${provider}'`);
+  return a;
+}
+
+// packages/agents/dist/headless-launcher.js
+var OUT_CAP = 4 * 1024 * 1024;
+var ERR_CAP = 4 * 1024 * 1024;
+var PROGRESS_INTERVAL_MS = 250;
+var PROGRESS_CHUNK_BATCH = 50;
+function runHeadless(opts) {
+  const adapter = getHeadlessAdapter(opts.provider);
+  const argv = adapter.buildCommand(opts.task, opts.sessionId);
+  const child = opts.spawn(argv[0], argv.slice(1), {
+    stdio: ["ignore", "pipe", "pipe"],
+    cwd: opts.cwd
+    // undefined → inherit daemon cwd (back-compat)
+  });
+  opts.emit({ type: "task.started", id: opts.id, pid: child.pid ?? void 0 });
+  let out = "";
+  let err = "";
+  let lastProgressAt = 0;
+  let chunksSinceProgress = 0;
+  let debounceTimer = null;
+  function flushProgress() {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+      debounceTimer = null;
+    }
+    lastProgressAt = Date.now();
+    chunksSinceProgress = 0;
+    opts.emit({ type: "task.progress", id: opts.id });
+  }
+  child.stdout?.on("data", (d) => {
+    out += String(d);
+    if (out.length > OUT_CAP)
+      out = out.slice(out.length - OUT_CAP);
+    chunksSinceProgress++;
+    const now = Date.now();
+    if (chunksSinceProgress >= PROGRESS_CHUNK_BATCH || now - lastProgressAt >= PROGRESS_INTERVAL_MS) {
+      flushProgress();
+    } else if (!debounceTimer) {
+      const delay = PROGRESS_INTERVAL_MS - (now - lastProgressAt);
+      debounceTimer = setTimeout(() => {
+        debounceTimer = null;
+        flushProgress();
+      }, delay);
+    }
+  });
+  child.stderr?.on("data", (d) => {
+    err += String(d);
+    if (err.length > ERR_CAP)
+      err = err.slice(err.length - ERR_CAP);
+  });
+  const result = new Promise((resolve2) => {
+    child.once("error", (e) => {
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+      opts.emit({ type: "task.failed", id: opts.id, error: `spawn error: ${e.message}`, exitCode: void 0 });
+      resolve2();
+    });
+    child.on("close", (code) => {
+      if (chunksSinceProgress > 0)
+        flushProgress();
+      else if (debounceTimer) {
+        clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+      const parseInput = code !== 0 && err ? err : out || err;
+      const res = adapter.parseResult(parseInput, code ?? 0);
+      if (res.outcome === "failed") {
+        opts.emit({ type: "task.failed", id: opts.id, error: res.error ?? "non-zero exit", exitCode: res.exitCode });
+      } else {
+        const ref = opts.writeResult ? opts.writeResult(opts.id, res.payload ?? "") : "";
+        opts.emit({ type: "task.done", id: opts.id, resultRef: ref, parseWarning: res.parseWarning });
+      }
+      resolve2();
+    });
+  });
+  return { result, kill: () => child.kill("SIGTERM") };
+}
+
+// packages/workspaces/dist/runtimes/cmux.js
+import { execFile, execFileSync as execFileSync4 } from "child_process";
+var CMUX_TIMEOUT = 15e3;
+var CmuxTimeoutError = class extends Error {
+  constructor(cmd) {
+    super(`cmux timeout after ${CMUX_TIMEOUT}ms on: ${cmd}`);
+    this.name = "CmuxTimeoutError";
+  }
+};
+function cmux(args) {
+  return new Promise((resolve2, reject) => {
+    execFile(
+      resolveCmuxBin(),
+      args,
+      // CMUX_QUIET=1 silences cmux 0.64's one-time deprecation hints (e.g. the
+      // "list-workspaces is now an alias for cmux workspace list" notice). Those
+      // notices print to the command's stdout and would otherwise pollute the
+      // output we parse. Inherit the rest of the environment unchanged.
+      { encoding: "utf-8", timeout: CMUX_TIMEOUT, env: { ...process.env, CMUX_QUIET: "1" } },
+      (err, stdout) => {
+        if (err) {
+          reject(err.code === "ETIMEDOUT" ? new CmuxTimeoutError(args.join(" ")) : err);
+          return;
+        }
+        resolve2(stdout.trim());
+      }
+    );
+  });
+}
+function parseList(output) {
+  let parsed;
+  try {
+    parsed = JSON.parse(output);
+  } catch {
+    return [];
+  }
+  const refs = [];
+  for (const ws of parsed.workspaces ?? []) {
+    if (!ws.ref)
+      continue;
+    refs.push({
+      id: ws.ref,
+      name: ws.has_custom_title && ws.custom_title ? ws.custom_title : ws.current_directory ?? ws.ref,
+      status: "running"
+    });
+  }
+  return refs;
+}
+function sanitizeForCmuxSend(text) {
+  return text.replace(/\\[nrt]/g, " ").replace(/[\n\r\t]+/g, " ").replace(/ {2,}/g, " ").trim();
+}
+function parseDraftFromScreen(screen) {
+  if (!screen)
+    return null;
+  const lines = screen.split(/\r?\n/);
+  const HR_RE = /^\s*─{10,}\s*$/;
+  let bottomHR = -1;
+  let topHR = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (HR_RE.test(lines[i])) {
+      if (bottomHR === -1) {
+        bottomHR = i;
+      } else {
+        topHR = i;
+        break;
+      }
+    }
+  }
+  if (topHR === -1)
+    return null;
+  const inputLines = lines.slice(topHR + 1, bottomHR);
+  for (const line of inputLines) {
+    let extracted;
+    const boxMatch = line.match(/│\s*[>❯]\s+(.*?)\s*│/);
+    if (boxMatch) {
+      extracted = boxMatch[1].trim();
+    } else {
+      const plainMatch = line.match(/^\s*[>❯]\s*(.*)$/);
+      if (plainMatch)
+        extracted = plainMatch[1].trim();
+    }
+    if (extracted !== void 0) {
+      if (/^[▌█▔▎▏▌█]/.test(extracted))
+        continue;
+      const draft = extracted.replace(/\s*[▌█▔▎▏▌█]+\s*$/, "").trim();
+      if (/^Press\s+(?:up|down|left|right|enter|escape|esc|tab|any\s+key|ctrl|shift|alt)\s+to\s+/i.test(draft))
+        continue;
+      if (draft)
+        return draft;
+    }
+  }
+  return "";
+}
+function readInputBoxRaw(screen) {
+  if (!screen)
+    return null;
+  const lines = screen.split(/\r?\n/);
+  const HR_RE = /^\s*─{10,}\s*$/;
+  let bottomHR = -1;
+  let topHR = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (HR_RE.test(lines[i])) {
+      if (bottomHR === -1)
+        bottomHR = i;
+      else {
+        topHR = i;
+        break;
+      }
+    }
+  }
+  if (topHR === -1)
+    return null;
+  const parts = [];
+  for (const line of lines.slice(topHR + 1, bottomHR)) {
+    let s = line.replace(/│/g, " ");
+    s = s.replace(/^\s*[>❯]\s?/, "");
+    s = s.replace(/\s*[▌█▔▎▏]+\s*$/, "");
+    parts.push(s);
+  }
+  return parts.join("").replace(/\s+$/, "");
+}
+function sendDebugEnabled() {
+  return !!process.env.SQUADRANT_DEBUG_SEND;
+}
+function classifySendOutcome(payload, postBox) {
+  if (postBox === null)
+    return "box-gone";
+  if (postBox === "")
+    return "submitted";
+  if (postBox === payload || postBox.includes(payload))
+    return "stuck";
+  return "unknown";
+}
+function createCmuxDriver() {
+  return {
+    name: "cmux",
+    async probe() {
+      try {
+        const version = await cmux(["--version"]);
+        const warn = checkToolCompat("cmux", version, compatManifest.tools.cmux);
+        if (warn)
+          process.stderr.write(`[squadrant] ${warn}
+`);
+        return { installed: true, version };
+      } catch {
+        return { installed: false, version: "" };
+      }
+    },
+    async list() {
+      try {
+        return parseList(await cmux(["workspace", "list", "--json", "--id-format", "refs"]));
+      } catch {
+        return [];
+      }
+    },
+    async status(nameOrId) {
+      const refs = await this.list();
+      const hit = refs.find((r) => r.name === nameOrId || r.id === nameOrId);
+      return hit ?? null;
+    },
+    async spawn(opts) {
+      const newWorkspaceArgs = ["workspace", "create", "--command", opts.command];
+      if (opts.workdir)
+        newWorkspaceArgs.push("--cwd", opts.workdir);
+      const output = await cmux(newWorkspaceArgs);
+      const id = output.match(/workspace:\d+/)?.[0] || output.split(/\s+/).pop() || "";
+      if (!id) {
+        throw new Error(`cmux spawn did not return a workspace id: ${output}`);
+      }
+      await cmux(["workspace", "rename", id, "--title", opts.name]);
+      let initialSurface;
+      try {
+        const tree = await cmux(["tree", "--workspace", id, "--id-format", "refs"]);
+        const m = tree.match(/surface\s+(surface:\d+)\s+\[\w+\]\s+"([^"]*)"/);
+        if (m) {
+          initialSurface = m[1];
+          await cmux(["rename-tab", "--workspace", id, "--surface", m[1], opts.name]);
+        }
+      } catch {
+      }
+      if (opts.pinToTop) {
+        try {
+          await cmux(["workspace-action", "--workspace", id, "--action", "pin"]);
+        } catch {
+        }
+        if (initialSurface) {
+          try {
+            await cmux(["tab-action", "--workspace", id, "--surface", initialSurface, "--action", "pin"]);
+          } catch {
+          }
+        }
+      }
+      return { id, name: opts.name, status: "running" };
+    },
+    async send(ref, message) {
+      const allRefs = await this.list();
+      const ws = allRefs.find((r) => r.id === ref);
+      if (ws) {
+        try {
+          const surfaces = await this.listSurfaces(ws.id);
+          const target = surfaces.find((s) => s.title === ws.name);
+          if (target) {
+            await cmux(["send", "--workspace", ws.id, "--surface", target.surfaceId, sanitizeForCmuxSend(message)]);
+            await cmux(["send-key", "--workspace", ws.id, "--surface", target.surfaceId, "Enter"]);
+            return;
+          }
+        } catch {
+        }
+      }
+      await cmux(["send", "--workspace", ref, sanitizeForCmuxSend(message)]);
+      await cmux(["send-key", "--workspace", ref, "Enter"]);
+    },
+    async sendKey(ref, key) {
+      await cmux(["send-key", "--workspace", ref, key]);
+    },
+    async readScreen(ref) {
+      try {
+        return await cmux(["read-screen", "--workspace", ref]);
+      } catch {
+        return "";
+      }
+    },
+    async stop(ref) {
+      try {
+        await cmux(["workspace-action", "--workspace", ref, "--action", "unpin"]);
+      } catch {
+      }
+      try {
+        await cmux(["workspace", "close", ref]);
+      } catch {
+      }
+    },
+    async newPane(opts) {
+      const cmd = opts.direction === "tab" ? ["new-surface", "--type", "terminal", "--workspace", opts.workspaceId, "--focus", "false"] : ["new-pane", "--type", "terminal", "--direction", opts.direction, "--workspace", opts.workspaceId, "--focus", "false"];
+      const output = await cmux(cmd);
+      const surfaceId = output.match(/surface:\d+/)?.[0];
+      if (!surfaceId) {
+        const verb = opts.direction === "tab" ? "new-surface" : "new-pane";
+        throw new Error(`cmux ${verb} did not return a surface id: ${output}`);
+      }
+      if (opts.title) {
+        try {
+          await cmux(["rename-tab", "--workspace", opts.workspaceId, "--surface", surfaceId, "--title", opts.title]);
+        } catch {
+        }
+      }
+      return { workspaceId: opts.workspaceId, surfaceId };
+    },
+    async closePane(pane) {
+      try {
+        await cmux(["close-surface", "--workspace", pane.workspaceId, "--surface", pane.surfaceId]);
+      } catch {
+      }
+    },
+    async sendToPane(pane, message) {
+      await cmux(["send", "--workspace", pane.workspaceId, "--surface", pane.surfaceId, sanitizeForCmuxSend(message)]);
+      await cmux(["send-key", "--workspace", pane.workspaceId, "--surface", pane.surfaceId, "Enter"]);
+    },
+    async readPaneScreen(pane) {
+      try {
+        return await cmux(["read-screen", "--workspace", pane.workspaceId, "--surface", pane.surfaceId]);
+      } catch {
+        return "";
+      }
+    },
+    async spawnInjector(opts) {
+      const wsId = opts.captainWorkspace.id;
+      const focus = opts.placement === "visible" ? "true" : "false";
+      const output = await cmux(["new-surface", "--type", "terminal", "--workspace", wsId, "--focus", focus]);
+      const surfaceId = output.match(/surface:\d+/)?.[0];
+      if (!surfaceId) {
+        throw new Error(`cmux spawnInjector did not return a surface id: ${output}`);
+      }
+      if (opts.title) {
+        try {
+          await cmux(["rename-tab", "--workspace", wsId, "--surface", surfaceId, "--title", opts.title]);
+        } catch {
+        }
+      }
+      await cmux(["send", "--workspace", wsId, "--surface", surfaceId, opts.command]);
+      await cmux(["send-key", "--workspace", wsId, "--surface", surfaceId, "Enter"]);
+      return { workspaceId: wsId, surfaceId, title: opts.title };
+    },
+    async sendToSurface(surface, text, opts) {
+      const ws = surface.workspaceId;
+      const sf = surface.surfaceId;
+      const deliver = async () => {
+        const dbg = sendDebugEnabled();
+        let preBox = null;
+        if (dbg) {
+          try {
+            preBox = readInputBoxRaw(await cmux(["read-screen", "--workspace", ws, "--surface", sf]));
+          } catch {
+          }
+        }
+        const payload = sanitizeForCmuxSend(text);
+        await cmux(["send", "--workspace", ws, "--surface", sf, payload]);
+        await cmux(["send-key", "--workspace", ws, "--surface", sf, "Enter"]);
+        if (dbg) {
+          let postBox = null;
+          try {
+            postBox = readInputBoxRaw(await cmux(["read-screen", "--workspace", ws, "--surface", sf]));
+          } catch {
+          }
+          const verdict = classifySendOutcome(payload, postBox);
+          process.stderr.write(`[squadrant] send-debug ${JSON.stringify({ surface: sf, verdict, payload, preBox, postBox })}
+`);
+        }
+      };
+      let screen = "";
+      try {
+        screen = await cmux(["read-screen", "--workspace", ws, "--surface", sf]);
+      } catch {
+      }
+      const draft = parseDraftFromScreen(screen);
+      if (draft === null)
+        throw new DeferDelivery(null);
+      if (draft === "") {
+        await deliver();
+        return;
+      }
+      if (!opts?.probe)
+        throw new DeferDelivery(draft);
+      const before = readInputBoxRaw(screen);
+      await cmux(["send-key", "--workspace", ws, "--surface", sf, "backspace"]);
+      let afterScreen = "";
+      try {
+        afterScreen = await cmux(["read-screen", "--workspace", ws, "--surface", sf]);
+      } catch {
+      }
+      const after = readInputBoxRaw(afterScreen);
+      if (before !== null && after !== null && after.length > 0 && after === before.slice(0, -1)) {
+        await cmux(["send", "--workspace", ws, "--surface", sf, before.slice(-1)]);
+        throw new DeferDelivery(draft);
+      }
+      await deliver();
+    },
+    async listSurfaces(workspaceId) {
+      let output;
+      try {
+        output = await cmux(["tree", "--workspace", workspaceId, "--json", "--id-format", "refs"]);
+      } catch {
+        return [];
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(output);
+      } catch {
+        return [];
+      }
+      const surfaces = [];
+      for (const win of parsed.windows ?? []) {
+        for (const ws of win.workspaces ?? []) {
+          if (ws.ref !== workspaceId)
+            continue;
+          for (const pane of ws.panes ?? []) {
+            for (const sf of pane.surfaces ?? []) {
+              const ref = sf.ref ?? sf.surface_ref;
+              if (ref)
+                surfaces.push({ workspaceId, surfaceId: ref, title: sf.title ?? "" });
+            }
+          }
+        }
+      }
+      return surfaces;
+    }
+  };
+}
+
+// packages/workspaces/dist/notifiers/cmux.js
+import { execFileSync as execFileSync5, execSync as execSync7 } from "child_process";
+
+// packages/workspaces/dist/workspaces/obsidian.js
+import fs9 from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import path12 from "path";
+
+// packages/workspaces/dist/cmux/events-bridge.js
+import { spawn as nodeSpawn2 } from "child_process";
+function deriveRunState(eventName) {
+  switch (eventName) {
+    case "agent.hook.PreToolUse":
+    case "agent.hook.UserPromptSubmit":
+      return "working";
+    case "agent.hook.Stop":
+      return "idle";
+    default:
+      return null;
+  }
+}
+var CmuxEventsBridge = class {
+  child = null;
+  stopped = false;
+  buf = "";
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /** Begin the subscription. Idempotent. */
+  start() {
+    if (this.child || this.stopped)
+      return;
+    void this.run();
+  }
+  /** Stop the subscription and kill the child (daemon shutdown). */
+  stop() {
+    this.stopped = true;
+    const c = this.child;
+    this.child = null;
+    if (c) {
+      try {
+        c.kill();
+      } catch {
+      }
+    }
+  }
+  async run() {
+    const spawnImpl = this.deps.spawnImpl ?? ((bin2, args2) => nodeSpawn2(bin2, args2, { stdio: ["ignore", "pipe", "ignore"] }));
+    const bin = this.deps.cmuxBin ?? resolveCmuxBin();
+    const sleep2 = this.deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const reconnectMs = this.deps.reconnectMs ?? 1e3;
+    const args = [
+      "events",
+      "--reconnect",
+      "--cursor-file",
+      this.deps.cursorFile,
+      "--category",
+      "agent",
+      "--no-heartbeat"
+    ];
+    while (!this.stopped) {
+      this.buf = "";
+      let child;
+      try {
+        child = spawnImpl(bin, args);
+      } catch (e) {
+        this.deps.log?.(`cmux events spawn failed: ${e.message}`);
+        if (this.deps.stopAfterFirstRun)
+          return;
+        await sleep2(reconnectMs);
+        continue;
+      }
+      this.child = child;
+      await new Promise((resolve2) => {
+        let settled = false;
+        const done = () => {
+          if (!settled) {
+            settled = true;
+            resolve2();
+          }
+        };
+        child.stdout?.on("data", (b) => this.onData(b));
+        child.stdout?.on("end", done);
+        child.on("exit", done);
+        child.on("error", (err) => {
+          this.deps.log?.(`cmux events child error: ${err.message}`);
+          done();
+        });
+      });
+      this.child = null;
+      if (this.stopped || this.deps.stopAfterFirstRun)
+        break;
+      await sleep2(reconnectMs);
+    }
+  }
+  onData(chunk) {
+    this.buf += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+    let nl;
+    while ((nl = this.buf.indexOf("\n")) >= 0) {
+      const line = this.buf.slice(0, nl);
+      this.buf = this.buf.slice(nl + 1);
+      this.handleLine(line);
+    }
+  }
+  handleLine(rawLine) {
+    const line = rawLine.trim();
+    if (!line || line[0] !== "{")
+      return;
+    let f;
+    try {
+      f = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (f?.type !== "event" || f.category !== "agent")
+      return;
+    const runState = f.name ? deriveRunState(f.name) : null;
+    if (!runState)
+      return;
+    const p = f.payload ?? {};
+    if (p.phase === "received")
+      return;
+    const rec = this.deps.resolve({
+      cwd: p.cwd,
+      source: p._source ?? f.source,
+      sessionId: p.session_id
+    });
+    if (!rec)
+      return;
+    if (runState === "idle") {
+      this.deps.emit({
+        type: "task.turn.completed",
+        id: rec.id,
+        turnId: p.session_id ?? "cmux"
+      });
+      return;
+    }
+    this.deps.emit({ type: "task.progress", id: rec.id, note: f.name, tool: p.tool_name });
+  }
+};
+
+// packages/workspaces/dist/cmux/daemon-cmux.js
+var DaemonCmux = class {
+  driver;
+  constructor(driver) {
+    this.driver = driver;
+  }
+  async send(surface, text, opts) {
+    try {
+      await this.driver.sendToSurface(surface, text, opts);
+    } catch (e) {
+      if (e instanceof DeferDelivery)
+        throw e;
+    }
+  }
+  async listSurfaces(workspaceId) {
+    try {
+      return await this.driver.listSurfaces(workspaceId);
+    } catch {
+      return [];
+    }
+  }
+  async readScreen(ref) {
+    try {
+      return await this.driver.readScreen(ref);
+    } catch {
+      return null;
+    }
+  }
+  async readPaneScreen(pane) {
+    try {
+      return await this.driver.readPaneScreen(pane);
+    } catch {
+      return null;
+    }
+  }
+  async findWorkspaceId(name) {
+    try {
+      const ref = await this.driver.status(name);
+      return ref?.id ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async isAvailable() {
+    try {
+      await this.driver.listSurfaces("");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// packages/workspaces/dist/crew-pane.js
+import net from "net";
+
+// packages/cli/src/control/squadrantd.ts
+var SELF_PATH2 = fileURLToPath3(import.meta.url);
+function readPkgVersion() {
+  try {
+    const pkgPath = join13(dirname5(SELF_PATH2), "..", "package.json");
+    return JSON.parse(readFileSync9(pkgPath, "utf-8")).version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+var PKG_VERSION = readPkgVersion();
+function startSquadrantd(opts = {}) {
+  const ctx = buildContext(opts);
+  const { stateRoot, store, log, spawn: spawn2, writeResult, inFlightHeadlessIds, activeHeadlessKills } = ctx;
+  const { broadcast, schedulePromotion, cancelPromotionsFor } = createAttach(ctx);
+  ctx.broadcast = broadcast;
+  ctx.schedulePromotion = schedulePromotion;
+  ctx.cancelPromotionsFor = cancelPromotionsFor;
+  const codexDriver = opts.codexDriver ?? new CodexInteractiveDriver({
+    emit: (ev) => {
+      const found = ctx.store.listAll().find((r) => r.id === ev.id);
+      if (!found) return;
+      void ctx.d.handle({ kind: "event", project: found.project, event: ev });
+      if (ev.type === "task.delta")
+        ctx.broadcast(ev.id, { type: "delta", taskId: ev.id, text: ev.chunk });
+      else if (ev.type === "task.turn.started")
+        ctx.broadcast(ev.id, { type: "turn-started", taskId: ev.id });
+      else if (ev.type === "task.turn.completed")
+        ctx.broadcast(ev.id, { type: "turn-completed", taskId: ev.id });
+      else if (ev.type === "task.input.requested") {
+        ctx.broadcast(ev.id, { type: "input-requested", taskId: ev.id, requestId: ev.requestId, question: ev.question });
+        ctx.schedulePromotion(ev.id, ev.requestId, "input", ev.question);
+      } else if (ev.type === "task.approval.requested") {
+        ctx.broadcast(ev.id, { type: "approval-requested", taskId: ev.id, requestId: ev.requestId, question: ev.question, kind: ev.kind });
+        ctx.schedulePromotion(ev.id, ev.requestId, "approval", ev.question);
+      } else if (ev.type === "task.reattached")
+        ctx.broadcast(ev.id, { type: "reattached", taskId: ev.id });
+    }
+  });
+  const opencodeBridge = opts.opencodeBridge ?? new OpencodeSseBridge({
+    emit: (ev) => {
+      const found = store.listAll().find((r) => r.id === ev.id);
+      if (!found) return;
+      void ctx.d.handle({ kind: "event", project: found.project, event: ev });
+      if (ev.type === "task.approval.requested")
+        ctx.schedulePromotion(ev.id, ev.requestId, "approval", ev.question);
+    },
+    log
+  });
+  const cmuxEventsBridge = opts.cmuxEventsBridge ?? new CmuxEventsBridge({
+    emit: (ev) => {
+      const found = store.listAll().find((r) => r.id === ev.id);
+      if (!found) return;
+      void ctx.d.handle({ kind: "event", project: found.project, event: ev });
+    },
+    resolve: (hook) => {
+      if (!hook.cwd) return void 0;
+      return store.listAll().find(
+        (r) => r.mode === "interactive" && !TERMINAL_STATES.has(r.state) && r.cwd === hook.cwd
+      );
+    },
+    cursorFile: join13(stateRoot, "cmux-events.seq"),
+    log
+  });
+  ctx.codexDriver = codexDriver;
+  ctx.opencodeBridge = opencodeBridge;
+  ctx.cmuxEventsBridge = cmuxEventsBridge;
+  ctx.daemonCmux = opts.daemonCmux ?? (opts.makeDaemonCmux ?? (() => new DaemonCmux(createCmuxDriver())))();
+  const launchHeadless = opts.launchHeadless ?? (async (rec) => {
+    const ingest = (e) => void ctx.d.handle({ kind: "event", project: rec.project, event: e });
+    const handle = runHeadless({
+      provider: rec.provider,
+      task: rec.task,
+      id: rec.id,
+      sessionId: rec.sessionId,
+      cwd: rec.cwd,
+      spawn: spawn2,
+      emit: ingest,
+      writeResult
+    });
+    inFlightHeadlessIds.add(rec.id);
+    activeHeadlessKills.add(handle.kill);
+    try {
+      await handle.result;
+    } finally {
+      inFlightHeadlessIds.delete(rec.id);
+      activeHeadlessKills.delete(handle.kill);
+    }
+  });
+  return startDaemon(ctx, { ...opts, launchHeadless }, PKG_VERSION);
+}
+if (process.argv[1] && process.argv[1].endsWith("squadrantd.js")) {
+  void (async () => {
+    const arg = process.argv[2];
+    if (arg === "--help" || arg === "-h" || arg === "--version" || arg === "-v") {
+      process.stdout.write("squadrantd: launchd-managed daemon entry (no CLI args). Use `squadrant` for commands.\n");
+      process.exit(0);
+    }
+    const sock = join13(homedir8(), ".config", "squadrant", "squadrant.sock");
+    if (await isDaemonSocketLive(sock)) {
+      process.stderr.write(`[squadrantd] refusing to start: a live daemon already owns ${sock}
+`);
+      process.exit(0);
+    }
+    const h = startSquadrantd({ sweepMs: 3e4 });
+    process.on("SIGTERM", () => {
+      h.stop();
+      process.exit(0);
+    });
+  })();
+}
+export {
+  defaultIsPidAlive,
+  discoverCaptainSurface,
+  startSquadrantd
+};
+//# sourceMappingURL=squadrantd.js.map