squadrant 0.19.4 → 0.20.0

package/dist/squadrantd.js

@@ -85,6 +85,9 @@ var init_config_io = __esm({
 import path2 from "path";
 import os from "os";
 import chalk from "chalk";
+function isBackendMode(v2) {
+  return v2 === "native" || v2 === "direct" || v2 === "proxy";
+}
 function getDefaultConfig() {
   return {
     commandName: "\u{1F3DB}\uFE0F command",
@@ -245,6 +248,20 @@ var init_effort = __esm({
   }
 });
 
+// packages/shared/dist/router-model.js
+function resolveRouterModel(model, agentName, router) {
+  if (!model)
+    return void 0;
+  const alias = router?.models?.[model];
+  if (!alias)
+    return model;
+  return alias.agents?.[agentName] ?? alias.upstream;
+}
+var init_router_model = __esm({
+  "packages/shared/dist/router-model.js"() {
+  }
+});
+
 // packages/shared/dist/types/runtime.js
 var init_runtime = __esm({
   "packages/shared/dist/types/runtime.js"() {
@@ -298,22 +315,22 @@ function defaultCmuxConfigPath() {
   return join(homedir(), ".config", "cmux", "cmux.json");
 }
 function ensureSocketAutomation(opts = {}) {
-  const path21 = opts.path ?? defaultCmuxConfigPath();
-  if (!existsSync(path21)) {
-    mkdirSync(dirname(path21), { recursive: true });
-    writeFileSync(path21, MINIMAL_TEMPLATE);
-    return { path: path21, changed: true, alreadySet: false };
+  const path23 = opts.path ?? defaultCmuxConfigPath();
+  if (!existsSync(path23)) {
+    mkdirSync(dirname(path23), { recursive: true });
+    writeFileSync(path23, MINIMAL_TEMPLATE);
+    return { path: path23, changed: true, alreadySet: false };
   }
-  const text = readFileSync(path21, "utf-8");
+  const text = readFileSync(path23, "utf-8");
   const current = parse(text)?.automation?.socketControlMode;
   if (current === AUTOMATION_MODE) {
-    return { path: path21, changed: false, alreadySet: true };
+    return { path: path23, changed: false, alreadySet: true };
   }
   const edits = modify(text, [...SOCKET_CONTROL_MODE_PATH], AUTOMATION_MODE, {
     formattingOptions: { insertSpaces: true, tabSize: 2 }
   });
-  writeFileSync(path21, applyEdits(text, edits));
-  return { path: path21, changed: true, alreadySet: false };
+  writeFileSync(path23, applyEdits(text, edits));
+  return { path: path23, changed: true, alreadySet: false };
 }
 var SOCKET_CONTROL_MODE_PATH, AUTOMATION_MODE, MINIMAL_TEMPLATE;
 var init_cmux_config = __esm({
@@ -463,9 +480,9 @@ import { join as join4 } from "path";
 function defaultStatePath() {
   return join4(homedir3(), ".config", "squadrant", "state", "cmux-autoconfig.json");
 }
-function readState(path21) {
+function readState(path23) {
   try {
-    return JSON.parse(readConfigFileSync(path21));
+    return JSON.parse(readConfigFileSync(path23));
   } catch {
     return {};
   }
@@ -511,7 +528,7 @@ var init_compat_manifest = __esm({
   "packages/shared/dist/lib/compat-manifest.js"() {
     compatManifest = {
       tools: {
-        cmux: { min: "0.64.0", lastVerified: "0.64.17" },
+        cmux: { min: "0.64.0", lastVerified: "0.64.22" },
         claude: { min: "2.1.32" },
         node: { min: "18.0.0", lastVerified: "24.6.0" },
         // presence-checked; no floor enforced yet
@@ -526,6 +543,7 @@ var init_compat_manifest = __esm({
 // packages/shared/dist/lib/config-drift.js
 var init_config_drift = __esm({
   "packages/shared/dist/lib/config-drift.js"() {
+    init_config();
   }
 });
 
@@ -762,6 +780,7 @@ var init_dist = __esm({
     init_config();
     init_project_config();
     init_effort();
+    init_router_model();
     init_runtime();
     init_liveness();
     init_control();
@@ -887,6 +906,11 @@ function reduce(rec, ev, now) {
       return stampAttempt(base, { resumeRef: ev.resumeRef }, now);
     case "task.turn.started":
       return { ...stampAttempt(base, {}, now), state: "working", pendingTool: void 0, pendingMonitor: void 0 };
+    case "task.turn.failed":
+    // #763: a crew's turn died on an API error (StopFailure hook). Anti-#2576:
+    // NOT task.failed — a hook may never terminalize a task. Falls through to
+    // the exact same turn-boundary transition as task.turn.completed below;
+    // only the notify message (reduce.ts formatMessage) differs.
     case "task.turn.completed":
       if (isStickyAttention(rec.state))
         return { ...rec, lastHeartbeat: now, lastEvent: ev.type };
@@ -1002,6 +1026,9 @@ function formatMessage(rec, event) {
       return `CREW STALLED ${tag}: no heartbeat in ${rec.heartbeatBudgetMs}ms`;
     }
     case "awaiting-input":
+      if (event?.type === "task.turn.failed") {
+        return `CREW TURN FAILED ${tag}: API error ended the turn (not a stall) \u2014 ${event.error}`;
+      }
       return `CREW IDLE ${tag}: turn ended, awaiting your reply.`;
     default:
       return null;
@@ -1226,7 +1253,7 @@ function createDaemon(deps) {
     async sweep() {
       const t = now();
       const surfaceAlive = deps.isSurfaceAlive ?? (async () => "unknown");
-      const projects = new Set(store.listAll().map((r) => r.project));
+      const projects = new Set(store.listAll().map((r) => r.project).filter((p) => Boolean(p)));
       for (const project of projects) {
         const terminal = store.list(project).filter((r) => TERMINAL_STATES.has(r.state)).sort((a, b) => b.lastHeartbeat - a.lastHeartbeat);
         for (const r of terminal.slice(TERMINAL_RECORD_KEEP_PER_PROJECT)) {
@@ -1411,6 +1438,7 @@ var init_reduce = __esm({
       "task.session",
       "task.turn.started",
       "task.turn.completed",
+      "task.turn.failed",
       "task.delta",
       "task.input.requested",
       "task.approval.requested",
@@ -2020,6 +2048,12 @@ function safeSegment(kind, s) {
   }
   return s;
 }
+function isTaskRecord(r) {
+  if (typeof r !== "object" || r === null)
+    return false;
+  const rec = r;
+  return typeof rec.id === "string" && rec.id.length > 0 && typeof rec.project === "string" && rec.project.length > 0;
+}
 function createStore(root) {
   const rootResolved = resolve(root);
   const assertUnderRoot = (target) => {
@@ -2067,7 +2101,7 @@ function createStore(root) {
         } catch {
           return void 0;
         }
-      }).filter((r) => r !== void 0);
+      }).filter(isTaskRecord);
     },
     listAll() {
       if (!existsSync6(root))
@@ -2355,10 +2389,10 @@ function detectForeignInstall(parsed, thisEntry, registeredEntryExists) {
     isUpgrade: isVersionUpgrade(parsed.daemonEntry, thisEntry)
   };
 }
-function sanitizePathForPlist(path21) {
+function sanitizePathForPlist(path23) {
   const seen = /* @__PURE__ */ new Set();
   const stable = [];
-  for (const p of path21.split(":")) {
+  for (const p of path23.split(":")) {
     if (!p)
       continue;
     if (p.includes("/.claude/plugins/"))
@@ -2560,6 +2594,9 @@ function isOperatorInitiatedCommand(topLevelArg) {
 function isReadOnlyCrewCommand(argv) {
   return argv[2] === "crew" && argv[3] !== void 0 && READ_ONLY_CREW_SUBCOMMANDS.has(argv[3]);
 }
+function isReadOnlyTopLevelCommand(argv) {
+  return argv[2] !== void 0 && READ_ONLY_TOP_LEVEL_COMMANDS.has(argv[2]);
+}
 function ensureDaemon(nodeBin = process.execPath, opts = {}) {
   if (restartInFlight)
     return;
@@ -2627,7 +2664,7 @@ function reregisterDaemon(nodeBin = process.execPath, kickstartOpts = {}) {
     releaseDaemonLock();
   }
 }
-var LABEL, AGENT_BINS, restartInFlight, OPERATOR_INITIATED_COMMANDS, READ_ONLY_CREW_SUBCOMMANDS;
+var LABEL, AGENT_BINS, restartInFlight, OPERATOR_INITIATED_COMMANDS, READ_ONLY_CREW_SUBCOMMANDS, READ_ONLY_TOP_LEVEL_COMMANDS;
 var init_launchd = __esm({
   "packages/core/dist/launchd.js"() {
     LABEL = "com.squadrant.daemon";
@@ -2635,6 +2672,7 @@ var init_launchd = __esm({
     restartInFlight = false;
     OPERATOR_INITIATED_COMMANDS = /* @__PURE__ */ new Set(["launch", "init"]);
     READ_ONLY_CREW_SUBCOMMANDS = /* @__PURE__ */ new Set(["list", "read", "tasks"]);
+    READ_ONLY_TOP_LEVEL_COMMANDS = /* @__PURE__ */ new Set(["sessions", "whoami"]);
   }
 });
 
@@ -2914,6 +2952,7 @@ function buildContext(opts) {
     opencodeBridge: null,
     cmuxEventsBridge: null,
     telegramBridge: void 0,
+    routerService: void 0,
     notifyFault: opts.notifyFault ?? (() => {
     }),
     lifecycleSources: opts.lifecycleSources ?? [],
@@ -3399,6 +3438,72 @@ var init_control_channel = __esm({
   }
 });
 
+// packages/core/dist/router-resolution.js
+function resolveBackend(explicit, routeBackend, roleBackend) {
+  return explicit ?? routeBackend ?? roleBackend ?? "native";
+}
+function assertBackendUsable(o) {
+  if (!isBackendMode(o.backend)) {
+    throw new Error(`unknown backend '${o.backend}'; expected native|direct|proxy`);
+  }
+  if (o.backend === "native")
+    return;
+  if (o.agent !== "claude") {
+    throw new Error(`backend '${o.backend}' is claude-only; agent '${o.agent}' must use backend 'native'`);
+  }
+  if (!o.router) {
+    throw new Error(`backend '${o.backend}' selected for agent 'claude' but defaults.router is not configured`);
+  }
+}
+function shouldBuildRouterService(router, isVitest) {
+  return !!router && !isVitest;
+}
+var init_router_resolution = __esm({
+  "packages/core/dist/router-resolution.js"() {
+    init_dist();
+  }
+});
+
+// packages/core/dist/router/env.js
+function buildRouterEnv(creds, model) {
+  const env = {
+    ANTHROPIC_BASE_URL: creds.baseUrl,
+    // Empty string, never unset: an unset key lets Claude Code fall back to
+    // authenticating against Anthropic directly (U1 §Env contract).
+    ANTHROPIC_API_KEY: creds.backend === "direct" ? creds.apiKey ?? "" : "",
+    [CMUX_PRESERVE_CLAUDE_AUTH_ENV]: "1"
+  };
+  if (creds.backend === "proxy") {
+    env.ANTHROPIC_AUTH_TOKEN = creds.token ?? "";
+  } else {
+    const headers = formatCustomHeaders(creds.extraHeaders);
+    if (headers)
+      env.ANTHROPIC_CUSTOM_HEADERS = headers;
+  }
+  if (model)
+    env.ANTHROPIC_MODEL = model;
+  return env;
+}
+function formatCustomHeaders(headers) {
+  const entries = Object.entries(headers ?? {});
+  if (entries.length === 0)
+    return void 0;
+  return entries.map(([name, value]) => `${name}: ${value}`).join("\n");
+}
+function renderEnvAssignments(env) {
+  return Object.keys(env).sort().map((key) => `${key}=${ansiCQuote(env[key] ?? "")}`).join(" ");
+}
+function ansiCQuote(value) {
+  const escaped = value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\x0a");
+  return `$'${escaped}'`;
+}
+var CMUX_PRESERVE_CLAUDE_AUTH_ENV;
+var init_env = __esm({
+  "packages/core/dist/router/env.js"() {
+    CMUX_PRESERVE_CLAUDE_AUTH_ENV = "CMUX_PRESERVE_CLAUDE_AUTH_SELECTION_ENV";
+  }
+});
+
 // packages/core/dist/crew-routing.js
 function resolveCrewRoute(taskText, config) {
   const rules = config.defaults.crewRouting?.rules;
@@ -3410,6 +3515,7 @@ function resolveCrewRoute(taskText, config) {
       return {
         agent: rule.agent,
         ...rule.model !== void 0 ? { model: rule.model } : {},
+        ...rule.backend !== void 0 ? { backend: rule.backend } : {},
         tier: rule.tier,
         matchedRule: rule.match
       };
@@ -3547,17 +3653,28 @@ async function pollFirstTurnConfirmedAt(getTaskRecord, project, id, scrapeSettle
     await new Promise((r) => setTimeout(r, FIRST_TURN_HOOK_POLL_INTERVAL_MS));
   }
 }
-function firstTrueOrBothFalse(a, b) {
+function firstTrueOrBothFalse(a, b, deadlineMs) {
   return new Promise((resolve4) => {
+    let done = false;
+    const finish = (ok2) => {
+      if (done)
+        return;
+      done = true;
+      clearTimeout(timer);
+      resolve4(ok2);
+    };
+    const timer = setTimeout(() => finish(false), deadlineMs);
     let settledFalseCount = 0;
     const onSettle = (ok2) => {
+      if (done)
+        return;
       if (ok2) {
-        resolve4(true);
+        finish(true);
         return;
       }
       settledFalseCount++;
       if (settledFalseCount === 2)
-        resolve4(false);
+        finish(false);
     };
     a.then(onSettle, () => onSettle(false));
     b.then(onSettle, () => onSettle(false));
@@ -3645,6 +3762,11 @@ async function runCrewSpawn(input, config, deps) {
   if (!agent) {
     throw new Error(`Unknown agent '${agentName}'. Known: claude, codex, gemini, opencode.`);
   }
+  const crewRoleCfg = config.defaults.roles?.crew;
+  const roleBackend = crewRoleCfg && crewRoleCfg.agent === agent.name ? crewRoleCfg.backend : void 0;
+  const backend = resolveBackend(input.backend, route?.backend, roleBackend);
+  assertBackendUsable({ backend, agent: agent.name, router: config.defaults.router });
+  deps.onBackendResolved?.({ backend });
   if (agentName === "codex") {
     const codexRoleFile = path9.join(TEMPLATES_DIR, `crew.${agent.templateSuffix}.md`);
     const roleInstructions = fs9.existsSync(codexRoleFile) ? fs9.readFileSync(codexRoleFile, "utf8") : void 0;
@@ -3667,12 +3789,19 @@ async function runCrewSpawn(input, config, deps) {
   const interactive = agent.name === "claude" || agent.name === "opencode";
   const crewRole = config.defaults.roles?.crew;
   const configModel = crewRole && crewRole.agent === agent.name ? crewRole.model : void 0;
-  const crewModel = input.model ?? route?.model ?? configModel;
+  const crewModel = resolveRouterModel(input.model ?? route?.model ?? configModel, agent.name, config.defaults.router);
   const crewThinking = input.thinking ?? config.defaults.roles?.crew?.thinking;
   if (agentName !== "claude") {
     deps.onModelResolved?.({ agentName, model: crewModel });
   }
   if (agentName === "claude") {
+    let routerEnv = {};
+    if (backend !== "native") {
+      if (!deps.routerCredentials) {
+        throw new Error(`backend '${backend}' requires router credentials, but the spawn path has no daemon credentials provider`);
+      }
+      routerEnv = buildRouterEnv(await deps.routerCredentials({ project: input.project, backend }), crewModel);
+    }
     ensureSocksDir();
     const messagingSocketPath = path9.join(CC_SOCKS_DIR, `squadrant-${randomUUID3()}.sock`);
     const rec = await deps.dispatchCrew({
@@ -3711,7 +3840,8 @@ async function runCrewSpawn(input, config, deps) {
     const title2 = titleFor(input.project, name);
     const pane2 = await deps.runtime.newPane({ workspaceId: captain.id, direction: direction2, title: title2 });
     const envPrefix = `SQUADRANT_CREW_TASK_ID=${rec.id} SQUADRANT_CREW_PROJECT=${input.project}`;
-    await deps.runtime.sendToPane(pane2, `cd ${shellQuote(spawnCwd)} && ${envPrefix} ${niceCrewCommand(cliCommand2)}`);
+    const routerPrefix = Object.keys(routerEnv).length > 0 ? ` ${renderEnvAssignments(routerEnv)}` : "";
+    await deps.runtime.sendToPane(pane2, `cd ${shellQuote(spawnCwd)} && ${envPrefix}${routerPrefix} ${niceCrewCommand(cliCommand2)}`);
     const preLaunchScreen = await deps.runtime.readPaneScreen(pane2) ?? "";
     let claudeFirstTurn = firstTurnTask;
     if (Buffer.byteLength(claudeFirstTurn, "utf8") > FIRST_TURN_INLINE_MAX_BYTES) {
@@ -3724,7 +3854,7 @@ async function runCrewSpawn(input, config, deps) {
 ${buildCompletionProtocol(rec.id, input.project)}`, preLaunchScreen);
     const scrapeDelivered = sendPromise.then((r) => r.delivered).catch(() => false);
     const cancelHookPoll = { stopped: false };
-    const delivered = hooksInstalled && deps.getTaskRecord ? await firstTrueOrBothFalse(scrapeDelivered, pollFirstTurnConfirmedAt(deps.getTaskRecord, input.project, rec.id, scrapeDelivered, cancelHookPoll)) : await scrapeDelivered;
+    const delivered = hooksInstalled && deps.getTaskRecord ? await firstTrueOrBothFalse(scrapeDelivered, pollFirstTurnConfirmedAt(deps.getTaskRecord, input.project, rec.id, scrapeDelivered, cancelHookPoll), FIRST_TURN_HOOK_CONFIRM_MAX_MS) : await scrapeDelivered;
     cancelHookPoll.stopped = true;
     if (!delivered) {
       process.stderr.write(`\u26A0\uFE0F  First turn not delivered for crew '${name}' \u2014 use 'squadrant crew send ${input.project} ${name}' to re-send the task.
@@ -4012,6 +4142,8 @@ var init_crew_spawn = __esm({
   "packages/core/dist/crew-spawn.js"() {
     init_control_channel();
     init_dist();
+    init_router_resolution();
+    init_env();
     init_crew_routing();
     init_crew_protocol();
     init_crew_lifecycle();
@@ -4062,6 +4194,164 @@ var init_captain_channel = __esm({
   }
 });
 
+// packages/core/dist/captain-record.js
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync8, realpathSync, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname3, join as join11 } from "path";
+function captainRecordPath(stateRoot, project) {
+  return join11(stateRoot, project, "captain.json");
+}
+function readCaptainAddress(stateRoot, project) {
+  try {
+    const parsed = JSON.parse(readFileSync8(captainRecordPath(stateRoot, project), "utf-8"));
+    return parsed && typeof parsed.agent === "string" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function writeCaptainAddress(stateRoot, project, addr) {
+  const p = captainRecordPath(stateRoot, project);
+  mkdirSync6(dirname3(p), { recursive: true });
+  writeFileSync8(p, JSON.stringify(addr, null, 2) + "\n");
+}
+function realpathOrSelf(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function sameDirectory(a, b) {
+  if (!a)
+    return false;
+  const strip = (s) => realpathOrSelf(s).replace(/\/+$/, "");
+  return strip(a) === strip(b);
+}
+var init_captain_record = __esm({
+  "packages/core/dist/captain-record.js"() {
+  }
+});
+
+// packages/core/dist/opencode-session.js
+import { execFileSync as execFileSync4 } from "child_process";
+async function listSessions(port, fetchImpl = fetch, timeoutMs = 5e3) {
+  for (const path23 of ["/session", "/api/session"]) {
+    const ac = new AbortController();
+    const t = setTimeout(() => ac.abort(), timeoutMs);
+    try {
+      const res = await fetchImpl(`http://127.0.0.1:${port}${path23}`, { signal: ac.signal });
+      if (!res.ok)
+        continue;
+      const rows = await res.json();
+      if (Array.isArray(rows))
+        return rows;
+    } catch {
+    } finally {
+      clearTimeout(t);
+    }
+  }
+  return [];
+}
+function parseLiveOpencodeServers(psOutput) {
+  const out = [];
+  for (const line of psOutput.split("\n")) {
+    const m = line.match(/^\s*(\d+)\s+(.+)$/);
+    if (!m)
+      continue;
+    const pid = Number(m[1]);
+    const command = m[2].trim();
+    const exe = command.split(/\s+/)[0] ?? "";
+    if (!/(^|\/)opencode$/.test(exe))
+      continue;
+    const portRaw = command.match(/--port[= ](\d+)/)?.[1];
+    if (!portRaw)
+      continue;
+    const sessionId = command.match(/--session[= ](\S+)/)?.[1];
+    out.push({ pid, port: Number(portRaw), ...sessionId ? { sessionId } : {} });
+  }
+  return out;
+}
+function defaultPsOutput() {
+  try {
+    return execFileSync4("ps", ["-axo", "pid=,command="], { encoding: "utf-8", timeout: 2e3 });
+  } catch {
+    return "";
+  }
+}
+function defaultCwdOf(pid) {
+  try {
+    const out = execFileSync4("lsof", ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], { encoding: "utf-8", timeout: 2e3 });
+    const line = out.split("\n").find((l) => l.startsWith("n"));
+    return line ? line.slice(1) : null;
+  } catch {
+    return null;
+  }
+}
+function discoverLiveOpencodeServer(opts) {
+  const servers = parseLiveOpencodeServers((opts.psOutput ?? defaultPsOutput)());
+  if (opts.sessionId) {
+    const bySession = servers.find((s) => s.sessionId === opts.sessionId);
+    if (bySession)
+      return bySession;
+  }
+  const cwdOf = opts.cwdOf ?? defaultCwdOf;
+  return servers.find((s) => sameDirectory(cwdOf(s.pid) ?? void 0, opts.directory)) ?? null;
+}
+function newestSessionInDirectory(rows, directory, createdAfterMs) {
+  const hits = rows.filter((r) => sameDirectory(r.directory, directory) && (createdAfterMs === void 0 || (r.time?.created ?? 0) >= createdAfterMs));
+  if (hits.length === 0)
+    return null;
+  return hits.reduce((a, b) => (b.time?.updated ?? 0) > (a.time?.updated ?? 0) ? b : a).id;
+}
+async function pollNewestSessionInDirectory(opts) {
+  const timeoutMs = opts.timeoutMs ?? 6e4;
+  const intervalMs = opts.intervalMs ?? 2e3;
+  const sleep3 = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    const id = newestSessionInDirectory(await listSessions(opts.port, opts.fetchImpl), opts.directory, opts.createdAfterMs);
+    if (id)
+      return id;
+    if (Date.now() >= deadline)
+      return null;
+    await sleep3(intervalMs);
+  }
+}
+async function resolveAndPersistOpencodeCaptain(opts) {
+  if (opts.sessionId) {
+    writeCaptainAddress(opts.stateRoot, opts.project, {
+      agent: "opencode",
+      port: opts.port,
+      sessionId: opts.sessionId,
+      directory: opts.directory,
+      launchedAt: opts.launchedAt
+    });
+    return opts.sessionId;
+  }
+  const sessionId = await pollNewestSessionInDirectory({
+    port: opts.port,
+    directory: opts.directory,
+    createdAfterMs: Date.parse(opts.launchedAt),
+    timeoutMs: opts.timeoutMs,
+    sleep: opts.sleep,
+    fetchImpl: opts.fetchImpl
+  });
+  if (!sessionId)
+    return null;
+  writeCaptainAddress(opts.stateRoot, opts.project, {
+    agent: "opencode",
+    port: opts.port,
+    sessionId,
+    directory: opts.directory,
+    launchedAt: opts.launchedAt
+  });
+  return sessionId;
+}
+var init_opencode_session = __esm({
+  "packages/core/dist/opencode-session.js"() {
+    init_captain_record();
+  }
+});
+
 // packages/core/dist/daemon/delivery-loop.js
 function discoverCaptainSurface(surfaces, captainTitle) {
   return surfaces.find((s) => s.title === captainTitle) ?? null;
@@ -4187,7 +4477,12 @@ function createDelivery(ctx, daemonCmux, isSurfaceAlive) {
   const cmux2 = daemonCmux;
   const cfg = loadConfig();
   const deliveries = /* @__PURE__ */ new Map();
-  const deliveryStats = (project) => deliveries.get(project)?.stats();
+  const deliveryStats = (project) => {
+    const s = deliveries.get(project)?.stats();
+    if (!s)
+      return s;
+    return s.reason === "no-channel" ? { ...s, stuck: true } : s;
+  };
   const lastDeferred = /* @__PURE__ */ new Map();
   const inFlightDelivery = () => {
     let worst = null;
@@ -4273,20 +4568,55 @@ function createDelivery(ctx, daemonCmux, isSurfaceAlive) {
               deliverEntry = { ...entry, message: `${prefix}${entry.message}` };
           }
           const result = await d.deliver(deliverEntry, async (text, sendOpts) => {
-            let handledByChannel = false;
-            try {
-              const mode = ctx.captainChannelMode?.() ?? "off";
-              const r = await deliverToCaptain(project, text, {
-                channel: ctx.captainChannel,
-                mode,
-                log
-              });
-              handledByChannel = r.handled;
-            } catch (e) {
-              log(`captain-channel ${project}: threw, falling back to pane \u2014 ${e.message}`);
-            }
-            if (handledByChannel) {
-              return;
+            const agent = ctx.captainAgentFor?.(project);
+            const picked = ctx.captainAgentFor ? agent ? ctx.captainChannels?.[agent] : void 0 : ctx.captainChannel;
+            const mode = ctx.captainChannelMode?.() ?? "off";
+            if (picked) {
+              try {
+                const r = await deliverToCaptain(project, text, { channel: picked, mode, log });
+                if (r.handled)
+                  return;
+              } catch (e) {
+                log(`captain-channel ${project}: threw, falling back to pane \u2014 ${e.message}`);
+              }
+              if (agent === "opencode" && mode !== "off") {
+                const rec = readCaptainAddress(stateRoot, project);
+                let healed = false;
+                if (rec?.port) {
+                  const fresh = newestSessionInDirectory(await listSessions(rec.port), rec.directory, Date.parse(rec.launchedAt));
+                  if (fresh && fresh !== rec.sessionId) {
+                    writeCaptainAddress(stateRoot, project, { ...rec, sessionId: fresh });
+                    healed = true;
+                  }
+                }
+                if (!healed && rec) {
+                  const live = discoverLiveOpencodeServer({ directory: rec.directory, sessionId: rec.sessionId });
+                  if (live && (live.port !== rec.port || live.sessionId && live.sessionId !== rec.sessionId)) {
+                    writeCaptainAddress(stateRoot, project, {
+                      ...rec,
+                      port: live.port,
+                      sessionId: live.sessionId ?? rec.sessionId
+                    });
+                    log(`captain-channel ${project}: re-resolved opencode address \u2192 port ${live.port}`);
+                    healed = true;
+                  }
+                }
+                if (healed) {
+                  try {
+                    const retry = await deliverToCaptain(project, text, { channel: picked, mode, log });
+                    if (retry.handled)
+                      return;
+                  } catch (e) {
+                    log(`captain-channel ${project}: retry after re-resolve threw \u2014 ${e.message}`);
+                  }
+                  log(`captain-channel ${project}: re-resolved address still unreachable \u2014 falling back to pane`);
+                } else {
+                  log(`captain-channel ${project}: no live opencode server \u2014 falling back to pane`);
+                }
+              }
+            } else if (ctx.captainAgentFor && (agent === "claude" || agent === "opencode")) {
+              if (mode !== "off")
+                throw new DeferDelivery(null, "no-channel");
             }
             try {
               return await cmux2.send(surface, text, sendOpts);
@@ -4310,20 +4640,23 @@ function createDelivery(ctx, daemonCmux, isSurfaceAlive) {
             lastDeferred.delete(project);
             projectBackoff.delete(project);
           } else {
-            const { maxDeferCount, stuck: stuck2 } = d.stats();
+            const { maxDeferCount } = d.stats();
+            const stuckNow = deliveryStats(project)?.stuck ?? false;
             if (maxDeferCount === 1 || maxDeferCount % 30 === 0) {
               log(`delivery seq=${entry.seq} kind=${entry.kind} outcome=deferred project=${project} reason=${result.reason}`);
             }
             lastDeferred.set(project, { seq: entry.seq, deferCount: maxDeferCount });
-            if (stuck2) {
+            if (stuckNow) {
               const streak = (projectBackoff.get(project)?.streak ?? 0) + 1;
-              const backoffMs = Math.min(6e4, 1e3 * 2 ** streak);
+              const cap = d.stats().reason === "no-channel" ? 3e5 : 6e4;
+              const backoffMs = Math.min(cap, 1e3 * 2 ** streak);
               projectBackoff.set(project, { nextAttemptAt: Date.now() + backoffMs, streak });
             }
             break;
           }
         }
-        const stuck = d.stats().stuck;
+        const stats = d.stats();
+        const stuck = stats.stuck || stats.reason === "no-channel";
         if (stuck && !stuckNotified.has(project)) {
           stuckNotified.add(project);
           const { maxDeferCount, reason } = d.stats();
@@ -4367,6 +4700,8 @@ var init_delivery_loop = __esm({
     init_down_alert();
     init_liveness2();
     init_captain_channel();
+    init_captain_record();
+    init_opencode_session();
     CURSOR_SUBSCRIBER = "captain";
     TERMINAL_KINDS = /* @__PURE__ */ new Set(["task.done", "task.failed", "task.cancelled", "task.blocked"]);
     STUCK_ALERT_TEXT = {
@@ -4374,6 +4709,7 @@ var init_delivery_loop = __esm({
       modal: (n) => `\u26A0\uFE0F DELIVERY STUCK: a modal question is open in your captain pane and has blocked pending notification(s) for ${n}+ retries. This keeps retrying safely and will deliver automatically once you answer or dismiss it.`,
       draft: (n) => `\u26A0\uFE0F DELIVERY STUCK: an in-progress draft (or ghost text) in your input box has blocked pending notification(s) for ${n}+ retries. Your input is never touched \u2014 this keeps retrying safely and will deliver automatically once you submit or clear it.`,
       "probe-failed": (n) => `\u26A0\uFE0F DELIVERY STUCK: reading your captain pane failed (stale/dead surface reference or cmux unavailable) and has blocked pending notification(s) for ${n}+ retries. Delivery re-resolves the pane automatically; if this persists after a captain restart, bounce the daemon to refresh its surface references.`,
+      "no-channel": (n) => `\u26A0\uFE0F CAPTAIN NOT DELIVERABLE: this project's captain has no control channel (missing launch record, or a manually opened session). Crew notifications are queued and not lost, but cannot be delivered until the captain is launched by squadrant. Run \`squadrant launch <project>\` \u2014 a manually opened \`opencode -c\` cannot receive lifecycle notifications. (blocked for ${n}+ retries)`,
       stable: (n) => `\u26A0\uFE0F DELIVERY STUCK: pending notification(s) have been blocked for ${n}+ retries. This keeps retrying safely and will deliver automatically once the blocker clears.`,
       unknown: (n) => `\u26A0\uFE0F DELIVERY STUCK: pending notification(s) have been blocked for ${n}+ retries. This keeps retrying safely and will deliver automatically once the blocker clears.`
     };
@@ -4401,6 +4737,32 @@ var init_gates = __esm({
   }
 });
 
+// packages/core/dist/router/credentials.js
+function buildRouterCredentialsRequest(project, backend) {
+  return { kind: "router-credentials", project, backend };
+}
+async function resolveRouterCredentials(service, project, backend, deps = {}) {
+  if (backend === "proxy") {
+    const sleep3 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const attempts = deps.attempts ?? ROUTER_READY_ATTEMPTS;
+    const delayMs = deps.delayMs ?? ROUTER_READY_DELAY_MS;
+    for (let i = 0; i < attempts; i++) {
+      const health = await service.health();
+      if (health.ready)
+        break;
+      await sleep3(delayMs);
+    }
+  }
+  return service.credentialsFor(project, backend);
+}
+var ROUTER_READY_ATTEMPTS, ROUTER_READY_DELAY_MS;
+var init_credentials = __esm({
+  "packages/core/dist/router/credentials.js"() {
+    ROUTER_READY_ATTEMPTS = 10;
+    ROUTER_READY_DELAY_MS = 200;
+  }
+});
+
 // packages/core/dist/daemon/server.js
 function createServer2(ctx, handlers) {
   const { store, log, attachConns } = ctx;
@@ -4426,6 +4788,13 @@ function createServer2(ctx, handlers) {
       if (msg.kind === "event") {
         return ctx.d.handle(msg);
       }
+      if (msg.kind === "router-credentials") {
+        const service = ctx.routerService;
+        if (!service) {
+          throw new Error("router backend selected but squadrantd has no router service \u2014 configure defaults.router and restart the daemon");
+        }
+        return resolveRouterCredentials(service, msg.project, msg.backend);
+      }
       return ctx.d.handle(msg);
     },
     onAttach: (conn, frame) => {
@@ -4461,18 +4830,19 @@ function createServer2(ctx, handlers) {
 var init_server = __esm({
   "packages/core/dist/daemon/server.js"() {
     init_protocol();
+    init_credentials();
   }
 });
 
 // packages/core/dist/daemon/exit-marker.js
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync8, unlinkSync as unlinkSync3, existsSync as existsSync9 } from "fs";
-import { join as join11 } from "path";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3, existsSync as existsSync9 } from "fs";
+import { join as join12 } from "path";
 function exitMarkerPath(stateRoot) {
-  return join11(stateRoot, "exit-marker.json");
+  return join12(stateRoot, "exit-marker.json");
 }
 function writeExitMarker(stateRoot, marker, log) {
   try {
-    writeFileSync8(exitMarkerPath(stateRoot), JSON.stringify(marker));
+    writeFileSync9(exitMarkerPath(stateRoot), JSON.stringify(marker));
   } catch (e) {
     log(`exit marker write failed: ${e.message}`);
   }
@@ -4483,7 +4853,7 @@ function consumeExitMarker(stateRoot, now = Date.now) {
     return { marker: null };
   let marker = null;
   try {
-    marker = JSON.parse(readFileSync8(p, "utf-8"));
+    marker = JSON.parse(readFileSync9(p, "utf-8"));
   } catch {
     marker = null;
   }
@@ -4497,18 +4867,18 @@ function consumeExitMarker(stateRoot, now = Date.now) {
   return { marker, gapMs };
 }
 function runningMarkerPath(stateRoot) {
-  return join11(stateRoot, "running-marker.json");
+  return join12(stateRoot, "running-marker.json");
 }
 function writeRunningMarker(stateRoot, marker, log) {
   try {
-    writeFileSync8(runningMarkerPath(stateRoot), JSON.stringify(marker));
+    writeFileSync9(runningMarkerPath(stateRoot), JSON.stringify(marker));
   } catch (e) {
     log(`running marker write failed: ${e.message}`);
   }
 }
 function readRunningMarker(stateRoot) {
   try {
-    return JSON.parse(readFileSync8(runningMarkerPath(stateRoot), "utf-8"));
+    return JSON.parse(readFileSync9(runningMarkerPath(stateRoot), "utf-8"));
   } catch {
     return null;
   }
@@ -4528,8 +4898,8 @@ var init_exit_marker = __esm({
 
 // packages/core/dist/daemon/snapshot-gather.js
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { join as join12 } from "path";
-import { statSync as statSync3, openSync as openSync2, readSync, closeSync as closeSync2, readdirSync as readdirSync3, readFileSync as readFileSync9 } from "fs";
+import { join as join13 } from "path";
+import { statSync as statSync3, openSync as openSync2, readSync, closeSync as closeSync2, readdirSync as readdirSync3, readFileSync as readFileSync10 } from "fs";
 function distBuiltAt() {
   try {
     return statSync3(SELF_PATH).mtimeMs;
@@ -4537,10 +4907,10 @@ function distBuiltAt() {
     return 0;
   }
 }
-function gatherLogStats(path21, now, windowMs) {
+function gatherLogStats(path23, now, windowMs) {
   let sizeBytes = 0;
   try {
-    sizeBytes = statSync3(path21).size;
+    sizeBytes = statSync3(path23).size;
   } catch {
     return { errorCount: 0, sizeBytes: 0, windowMs };
   }
@@ -4551,7 +4921,7 @@ function gatherLogStats(path21, now, windowMs) {
   const len = sizeBytes - start;
   let text = "";
   try {
-    const fd = openSync2(path21, "r");
+    const fd = openSync2(path23, "r");
     try {
       const buf = Buffer.alloc(len);
       readSync(fd, buf, 0, len, start);
@@ -4582,7 +4952,7 @@ function gatherStoreStats(store, stateRoot, project) {
   for (const r of store.list(project))
     byState[r.state] = (byState[r.state] ?? 0) + 1;
   let corruptCount = 0;
-  const dir = join12(stateRoot, project);
+  const dir = join13(stateRoot, project);
   try {
     for (const n of readdirSync3(dir)) {
       if (n.includes(".corrupt.")) {
@@ -4592,7 +4962,7 @@ function gatherStoreStats(store, stateRoot, project) {
       if (!n.endsWith(".json"))
         continue;
       try {
-        JSON.parse(readFileSync9(join12(dir, n), "utf-8"));
+        JSON.parse(readFileSync10(join13(dir, n), "utf-8"));
       } catch {
         corruptCount++;
       }
@@ -4607,7 +4977,7 @@ function gatherResults(resultsDir) {
   try {
     for (const n of readdirSync3(resultsDir)) {
       try {
-        const s = statSync3(join12(resultsDir, n));
+        const s = statSync3(join13(resultsDir, n));
         if (s.isFile()) {
           fileCount++;
           totalBytes += s.size;
@@ -4627,7 +4997,7 @@ var init_snapshot_gather = __esm({
 });
 
 // packages/core/dist/daemon/start.js
-import { join as join13, dirname as dirname3 } from "path";
+import { join as join14, dirname as dirname4 } from "path";
 import { readdir } from "fs/promises";
 function startDaemon(ctx, opts, pkgVersion) {
   const { stateRoot, store, log, isPidAlive, resultsDir, taskTimeoutMs, inFlightHeadlessIds, activeHeadlessKills, broadcast, cancelPromotionsFor } = ctx;
@@ -4704,7 +5074,7 @@ function startDaemon(ctx, opts, pkgVersion) {
     return out;
   }
   async function gatherSnapshotInputs(now) {
-    const logPath2 = join13(dirname3(stateRoot), "squadrantd.log");
+    const logPath2 = join14(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 });
@@ -4781,6 +5151,9 @@ function startDaemon(ctx, opts, pkgVersion) {
         log(`telegram bridge start failed: ${e.message}`);
       }
     }
+    if (ctx.routerService) {
+      void ctx.routerService.start().then(() => log(`router: listening ${ctx.routerService.url()}`)).catch((e) => log(`router service start failed: ${e.message}`));
+    }
     const autoConfigSafe = !!opts.runCmuxAutoConfig || !process.env.VITEST;
     if (autoConfigSafe) {
       try {
@@ -4866,7 +5239,7 @@ function startDaemon(ctx, opts, pkgVersion) {
   let rotationTimer;
   let rotationTick;
   if (rotationInterval > 0) {
-    const inboxPath = join13(stateRoot, "inbox");
+    const inboxPath = join14(stateRoot, "inbox");
     rotationTick = async () => {
       try {
         let entries;
@@ -4890,7 +5263,7 @@ function startDaemon(ctx, opts, pkgVersion) {
     rotationTimer.unref?.();
   }
   return {
-    stop(reason = "requested") {
+    async stop(reason = "requested") {
       const ppid = process.ppid;
       const uptimeMs = Math.round(process.uptime() * 1e3);
       const inFlight = inFlightDelivery();
@@ -4919,6 +5292,10 @@ function startDaemon(ctx, opts, pkgVersion) {
       }
       for (const kill of ctx.activeHeadlessKills)
         kill();
+      try {
+        await ctx.routerService?.stop();
+      } catch {
+      }
       return new Promise((resolve4) => server.close(() => {
         log(`exit-complete pid=${process.pid}`);
         resolve4();
@@ -5933,7 +6310,7 @@ var init_bridge = __esm({
 });
 
 // packages/core/dist/restart-daemon.js
-import { execFileSync as execFileSync4 } from "child_process";
+import { execFileSync as execFileSync5 } from "child_process";
 import { existsSync as existsSync10 } from "fs";
 function defaultIsRunning() {
   return existsSync10(DAEMON_SOCK_PATH);
@@ -5943,7 +6320,7 @@ function defaultRunKickstart() {
   const target = `gui/${uid}/${LABEL}`;
   if (tryAcquireDaemonLock()) {
     try {
-      execFileSync4("launchctl", kickstartArgv(target, true), { stdio: "ignore" });
+      execFileSync5("launchctl", kickstartArgv(target, true), { stdio: "ignore" });
     } finally {
       releaseDaemonLock();
     }
@@ -6165,128 +6542,674 @@ var init_telegram = __esm({
   }
 });
 
-// packages/core/dist/group-dispatch.js
-import { randomUUID as randomUUID4 } from "crypto";
-function resolveCurrentProject(config) {
-  const cwd = process.cwd();
-  for (const [name, proj] of Object.entries(config.projects)) {
-    const resolvedPath = resolveHome(proj.path);
-    if (cwd.startsWith(resolvedPath))
-      return name;
+// packages/core/dist/router/types.js
+var init_types = __esm({
+  "packages/core/dist/router/types.js"() {
   }
-  return null;
+});
+
+// packages/core/dist/router/auth.js
+import { randomBytes as randomBytes2 } from "crypto";
+function mintToken() {
+  return randomBytes2(32).toString("base64url");
 }
-async function isCaptainAlive(project, sockPath = DAEMON_SOCK_PATH) {
-  try {
-    const health = await sendRequest(sockPath, { kind: "health", project }, 5e3);
-    const captain = health?.find((h) => h.kind === "captain" && h.project === project);
-    return captain?.state === "alive";
-  } catch {
-    return false;
-  }
+function parseBearer(header) {
+  if (!header)
+    return null;
+  const m = /^Bearer\s+(.+)$/i.exec(header.trim());
+  return m ? m[1].trim() : null;
 }
-async function waitForWarmup(project, sockPath = DAEMON_SOCK_PATH, timeoutMs = GROUP_DISPATCH_WARMUP_TIMEOUT_MS, pollMs = GROUP_DISPATCH_WARMUP_POLL_MS) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (await isCaptainAlive(project, sockPath))
-      return true;
-    await new Promise((r) => setTimeout(r, pollMs));
-  }
-  return false;
+function resolveProject(tokens, header) {
+  const token = parseBearer(header);
+  if (!token)
+    return null;
+  return tokens.get(token) ?? null;
 }
-async function dispatchToSibling(opts) {
-  const config = loadConfig();
-  const fromCfg = config.projects[opts.fromProject];
-  const toCfg = config.projects[opts.toProject];
-  if (!toCfg) {
-    throw new Error(`target project '${opts.toProject}' not found in config`);
+var init_auth2 = __esm({
+  "packages/core/dist/router/auth.js"() {
   }
-  const sameGroup = !!fromCfg?.group && !!toCfg.group && fromCfg.group === toCfg.group;
-  if (toCfg.acceptDelegations === false) {
-    throw new Error(`cannot dispatch to '${opts.toProject}': project has acceptDelegations set to false`);
+});
+
+// packages/core/dist/router/errors.js
+function anthropicError(status, type, message) {
+  return { status, body: { type: "error", error: { type, message } } };
+}
+var init_errors = __esm({
+  "packages/core/dist/router/errors.js"() {
   }
-  const sockPath = opts.sockPath ?? DAEMON_SOCK_PATH;
-  const alive = await isCaptainAlive(opts.toProject, sockPath);
-  if (!alive) {
-    if (!sameGroup) {
-      throw new Error(`cannot dispatch to '${opts.toProject}': captain is not running and cross-group dispatch does not auto-boot it. Use 'squadrant ping ${opts.toProject} "<msg>"' or start it manually with 'squadrant launch ${opts.toProject}', then retry.`);
-    }
-    if (opts.bootCaptain) {
-      await opts.bootCaptain(opts.toProject);
-    }
-    const warmed = await waitForWarmup(opts.toProject, sockPath, opts.warmupTimeoutMs, opts.warmupPollMs);
-    if (!warmed) {
-      throw new Error(`dispatch to '${opts.toProject}' timed out waiting for captain warmup (>${(opts.warmupTimeoutMs ?? GROUP_DISPATCH_WARMUP_TIMEOUT_MS) / 1e3}s)`);
+});
+
+// packages/core/dist/router/sanitize.js
+function isObj(v2) {
+  return typeof v2 === "object" && v2 !== null && !Array.isArray(v2);
+}
+function sanitizeRequest(body, upstream) {
+  const out = { ...body };
+  if (!upstream.isAnthropic) {
+    for (const f of ANTHROPIC_ONLY_REQUEST_FIELDS)
+      delete out[f];
+    if (Array.isArray(out.tools)) {
+      out.tools = out.tools.filter((t) => !(isObj(t) && typeof t.type === "string" && SERVER_TOOL_TYPE_RE.test(t.type)));
     }
   }
-  const now = Date.now();
-  const attemptId = randomUUID4();
-  const record = {
-    id: randomUUID4(),
-    project: opts.toProject,
-    originProject: opts.fromProject,
-    provider: opts.provider ?? "claude",
-    mode: opts.mode ?? "headless",
-    state: "submitted",
-    task: opts.task,
-    createdAt: now,
-    lastHeartbeat: now,
-    lastEvent: "dispatch",
-    heartbeatBudgetMs: 3e5,
-    attempts: [{ attemptId, startedAt: now, lastHeartbeatAt: now }]
-  };
-  const result = await sendRequest(sockPath, { kind: "dispatch", record });
-  return result;
+  return out;
 }
-var GROUP_DISPATCH_WARMUP_TIMEOUT_MS, GROUP_DISPATCH_WARMUP_POLL_MS;
-var init_group_dispatch = __esm({
-  "packages/core/dist/group-dispatch.js"() {
-    init_dist();
-    init_protocol();
-    GROUP_DISPATCH_WARMUP_TIMEOUT_MS = 12e4;
-    GROUP_DISPATCH_WARMUP_POLL_MS = 1e3;
+var SERVER_TOOL_TYPE_RE, ANTHROPIC_ONLY_REQUEST_FIELDS;
+var init_sanitize = __esm({
+  "packages/core/dist/router/sanitize.js"() {
+    SERVER_TOOL_TYPE_RE = /^(bash|text_editor|str_replace_editor|computer|web_search|code_execution|memory)_\d+/;
+    ANTHROPIC_ONLY_REQUEST_FIELDS = ["container", "context_management", "mcp_servers"];
   }
 });
 
-// packages/core/dist/launch-workspace.js
-async function deliverStartupPrompt(runtime, refId, prompt, opts = {}) {
-  const classify = opts.classifyScreen ?? (() => "idle");
-  const readyTimeoutMs = opts.readyTimeoutMs ?? 3e4;
-  const settleMs = opts.settleMs ?? 2500;
-  const pollMs = opts.pollMs ?? 1e3;
-  const maxAttempts = opts.maxAttempts ?? 3;
-  const sleep3 = (ms) => new Promise((r) => setTimeout(r, ms));
-  const read = async () => runtime.readScreen(refId).catch(() => "");
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const deadline = Date.now() + readyTimeoutMs;
-    let preSend = await read();
-    let state = classify(preSend);
-    while (state === "loading" && Date.now() < deadline) {
-      await sleep3(pollMs);
-      preSend = await read();
-      state = classify(preSend);
+// packages/core/dist/router/stream.js
+import { Transform } from "stream";
+import { StringDecoder } from "string_decoder";
+function num(v2) {
+  if (typeof v2 === "number")
+    return Number.isFinite(v2) ? v2 : void 0;
+  if (typeof v2 === "string" && v2.trim() !== "") {
+    const n = Number(v2);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return void 0;
+}
+function absorb(evt, acc) {
+  if (typeof evt !== "object" || evt === null)
+    return false;
+  const e = evt;
+  const message = typeof e.message === "object" && e.message !== null ? e.message : void 0;
+  const usage2 = e.usage ?? message?.usage;
+  let saw = false;
+  if (usage2) {
+    const input = num(usage2.input_tokens);
+    if (input !== void 0) {
+      acc.inputTokens = input;
+      saw = true;
+    }
+    const output = num(usage2.output_tokens);
+    if (output !== void 0) {
+      acc.outputTokens = output;
+      saw = true;
+    }
+    const read = num(usage2.cache_read_input_tokens);
+    if (read !== void 0) {
+      acc.cacheReadTokens = read;
+      saw = true;
+    }
+    const write = num(usage2.cache_creation_input_tokens);
+    if (write !== void 0) {
+      acc.cacheWriteTokens = write;
+      saw = true;
+    }
+    if (usage2.cost !== void 0) {
+      const cost = num(usage2.cost);
+      if (cost !== void 0) {
+        acc.costUsd = cost;
+        saw = true;
+      }
+    }
+  }
+  if (e.cost !== void 0) {
+    const cost = num(e.cost);
+    if (cost !== void 0) {
+      acc.costUsd = cost;
+      saw = true;
+    }
+  }
+  return saw;
+}
+function scan(bufRef, acc) {
+  let saw = false;
+  let idx;
+  while ((idx = bufRef.value.indexOf("\n")) !== -1) {
+    const line = bufRef.value.slice(0, idx).trim();
+    bufRef.value = bufRef.value.slice(idx + 1);
+    if (line.startsWith("data:")) {
+      const payload = line.slice(5).trim();
+      if (payload && payload !== "[DONE]") {
+        try {
+          if (absorb(JSON.parse(payload), acc))
+            saw = true;
+        } catch {
+        }
+      }
     }
-    if (state === "working")
-      return;
-    await runtime.send(refId, prompt).catch(() => {
-    });
-    if (state === "loading")
-      return;
-    await sleep3(settleMs);
-    const after = await read();
-    if (after !== preSend)
-      return;
   }
+  return saw;
 }
-async function bootWorkspace(opts) {
-  const { runtime, workspaceName, agentCmd, cwd, navigate = false, forceFresh = false, pinToTop = false, initialPrompt } = opts;
-  const existing = await runtime.status(workspaceName);
-  if (existing && forceFresh) {
-    opts.onStoppingStale?.(workspaceName);
-    await runtime.stop(existing.id);
-  } else if (existing) {
-    opts.onAlreadyExists?.(workspaceName);
-    opts.selectWorkspace?.(existing.id);
+function createUsageTee(project, onUsage) {
+  const buf = { value: "" };
+  const acc = { project };
+  const decoder = new StringDecoder("utf8");
+  let sawUsage = false;
+  return new Transform({
+    transform(chunk, _enc, cb) {
+      buf.value += decoder.write(chunk);
+      sawUsage = scan(buf, acc) || sawUsage;
+      cb(null, chunk);
+    },
+    flush(cb) {
+      buf.value += decoder.end();
+      if (buf.value.trim() !== "") {
+        buf.value += "\n";
+        sawUsage = scan(buf, acc) || sawUsage;
+      }
+      if (sawUsage) {
+        try {
+          onUsage(acc);
+        } catch {
+        }
+      }
+      cb();
+    }
+  });
+}
+function usageFromJson(project, body) {
+  const acc = { project };
+  return absorb({ usage: body.usage, cost: body.cost }, acc) ? acc : void 0;
+}
+var init_stream = __esm({
+  "packages/core/dist/router/stream.js"() {
+  }
+});
+
+// packages/core/dist/router/shim.js
+import { createServer as createServer3 } from "http";
+import { Readable } from "stream";
+function joinUrl(base, path23) {
+  return base.replace(/\/+$/, "") + path23;
+}
+async function readBody(req) {
+  const chunks = [];
+  for await (const c of req)
+    chunks.push(c);
+  return Buffer.concat(chunks).toString("utf8");
+}
+function writeJson(res, status, body) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+function buildUpstreamHeaders(req, upstream, stream) {
+  const headers = {
+    "content-type": "application/json",
+    accept: stream ? "text/event-stream" : "application/json"
+  };
+  for (const [k, v2] of Object.entries(req.headers)) {
+    const key = k.toLowerCase();
+    if (key.startsWith("anthropic-") && typeof v2 === "string")
+      headers[key] = v2;
+  }
+  for (const [k, v2] of Object.entries(upstream.extraHeaders ?? {}))
+    headers[k.toLowerCase()] = v2;
+  const authName = (upstream.authHeader ?? DEFAULT_AUTH_HEADER).toLowerCase();
+  headers[authName] = authName === "authorization" ? `Bearer ${upstream.apiKey}` : upstream.apiKey;
+  if (!headers["anthropic-version"])
+    headers["anthropic-version"] = "2023-06-01";
+  return headers;
+}
+function createRouterShim(opts) {
+  const fetchImpl = opts.fetch ?? fetch;
+  const log = opts.log ?? (() => {
+  });
+  let server;
+  let starting;
+  let boundPort = 0;
+  let lastError;
+  let upstreamReachable = true;
+  const upstreamUrl = joinUrl(opts.upstream.baseUrl, "/v1/messages");
+  function emitUsage(u) {
+    try {
+      opts.onUsage?.(u);
+    } catch {
+    }
+  }
+  async function handleMessages(req, res) {
+    const project = resolveProject(opts.projectTokens, req.headers.authorization);
+    if (!project) {
+      const e = anthropicError(401, "authentication_error", "invalid squadrant router token");
+      writeJson(res, e.status, e.body);
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(await readBody(req));
+    } catch {
+      const e = anthropicError(400, "invalid_request_error", "malformed JSON body");
+      writeJson(res, e.status, e.body);
+      return;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      const e = anthropicError(400, "invalid_request_error", "request body must be a JSON object");
+      writeJson(res, e.status, e.body);
+      return;
+    }
+    const body = parsed;
+    const wantsStream = body.stream === true;
+    const sanitized = sanitizeRequest(body, opts.upstream);
+    let upstreamRes;
+    try {
+      upstreamRes = await fetchImpl(upstreamUrl, {
+        method: "POST",
+        headers: buildUpstreamHeaders(req, opts.upstream, wantsStream),
+        body: JSON.stringify(sanitized)
+      });
+    } catch (err) {
+      upstreamReachable = false;
+      lastError = err instanceof Error ? err.message : String(err);
+      const e = anthropicError(502, "api_error", `router upstream unreachable: ${lastError}`);
+      writeJson(res, e.status, e.body);
+      return;
+    }
+    upstreamReachable = true;
+    if (!upstreamRes.ok) {
+      const text2 = await upstreamRes.text();
+      log(`router upstream ${upstreamRes.status}: ${text2.slice(0, 500)}`);
+      let message = text2.slice(0, 500);
+      try {
+        const parsedErr = JSON.parse(text2);
+        message = parsedErr.error?.message ?? message;
+      } catch {
+      }
+      if (upstreamRes.status >= 500) {
+        upstreamReachable = false;
+        lastError = message || "upstream error";
+        const e2 = anthropicError(502, "api_error", lastError);
+        writeJson(res, e2.status, e2.body);
+        return;
+      }
+      const e = anthropicError(upstreamRes.status, "api_error", message || "upstream error");
+      writeJson(res, e.status, e.body);
+      return;
+    }
+    if (wantsStream && upstreamRes.body) {
+      res.writeHead(upstreamRes.status, {
+        "content-type": upstreamRes.headers.get("content-type") || "text/event-stream",
+        "cache-control": "no-cache",
+        connection: "keep-alive"
+      });
+      const nodeStream = Readable.fromWeb(upstreamRes.body);
+      nodeStream.on("error", (err) => {
+        log(`router upstream stream error: ${err instanceof Error ? err.message : String(err)}`);
+        try {
+          res.end();
+        } catch {
+        }
+      });
+      const tee = createUsageTee(project, emitUsage);
+      tee.on("error", (err) => {
+        log(`router usage tee error: ${err instanceof Error ? err.message : String(err)}`);
+      });
+      nodeStream.pipe(tee).pipe(res);
+      res.on("close", () => nodeStream.destroy());
+      return;
+    }
+    const text = await upstreamRes.text();
+    let upstreamBody;
+    try {
+      upstreamBody = JSON.parse(text);
+    } catch {
+      const e = anthropicError(502, "api_error", "upstream returned non-JSON");
+      writeJson(res, e.status, e.body);
+      return;
+    }
+    const usage2 = usageFromJson(project, upstreamBody);
+    if (usage2)
+      emitUsage(usage2);
+    writeJson(res, upstreamRes.status, upstreamBody);
+  }
+  function handler(req, res) {
+    if (req.method === "POST" && req.url === "/v1/messages") {
+      void handleMessages(req, res).catch((err) => {
+        log(`router internal error: ${err instanceof Error ? err.message : String(err)}`);
+        if (!res.headersSent) {
+          const e = anthropicError(502, "api_error", "router internal error");
+          writeJson(res, e.status, e.body);
+        } else {
+          res.end();
+        }
+      });
+      return;
+    }
+    if (req.method === "GET" && req.url === "/healthz") {
+      writeJson(res, 200, { ready: server?.listening === true, upstreamReachable, lastError });
+      return;
+    }
+    writeJson(res, 404, anthropicError(404, "not_found_error", "not found").body);
+  }
+  return {
+    async start() {
+      if (server)
+        return;
+      if (starting)
+        return starting;
+      starting = new Promise((resolve4, reject) => {
+        const s = createServer3(handler);
+        const onStartupError = (err) => {
+          s.off("error", onStartupError);
+          reject(err);
+        };
+        s.once("error", onStartupError);
+        s.listen(opts.port ?? 0, opts.host ?? "127.0.0.1", () => {
+          s.off("error", onStartupError);
+          s.on("error", (err) => {
+            lastError = err instanceof Error ? err.message : String(err);
+            log(`router server error: ${lastError}`);
+          });
+          server = s;
+          const addr = s.address();
+          boundPort = typeof addr === "object" && addr ? addr.port : 0;
+          resolve4();
+        });
+      });
+      try {
+        await starting;
+      } finally {
+        starting = void 0;
+      }
+    },
+    async stop() {
+      try {
+        await starting;
+      } catch {
+      }
+      const s = server;
+      if (!s)
+        return;
+      server = void 0;
+      boundPort = 0;
+      s.closeAllConnections?.();
+      await new Promise((resolve4) => s.close(() => resolve4()));
+    },
+    url() {
+      return `http://${opts.host ?? "127.0.0.1"}:${boundPort}`;
+    },
+    async health() {
+      return { ready: server?.listening === true, upstreamReachable, lastError };
+    }
+  };
+}
+var DEFAULT_AUTH_HEADER;
+var init_shim = __esm({
+  "packages/core/dist/router/shim.js"() {
+    init_auth2();
+    init_errors();
+    init_sanitize();
+    init_stream();
+    DEFAULT_AUTH_HEADER = "Authorization";
+  }
+});
+
+// packages/core/dist/router/service.js
+function resolveRouterUpstream(router, env = process.env) {
+  const credential = router.apiKey ?? (router.apiKeyEnv ? env[router.apiKeyEnv] : void 0) ?? "";
+  const authHeader = router.authHeader ?? (router.kind === "opencode-go" ? "x-api-key" : "Authorization");
+  return {
+    baseUrl: router.baseUrl,
+    apiKey: credential,
+    authHeader,
+    extraHeaders: router.extraHeaders,
+    isAnthropic: router.isAnthropic ?? false
+  };
+}
+function createRouterService(router, projects, deps = {}) {
+  const log = deps.log ?? (() => {
+  });
+  const upstream = resolveRouterUpstream(router);
+  if (!upstream.apiKey) {
+    log("router: no credential configured (set defaults.router.apiKey or apiKeyEnv) \u2014 routed spawns will fail");
+  }
+  const tokenByProject = /* @__PURE__ */ new Map();
+  const projectTokens = /* @__PURE__ */ new Map();
+  for (const p of projects) {
+    const t = mintToken();
+    tokenByProject.set(p, t);
+    projectTokens.set(t, p);
+  }
+  const shim = createRouterShim({
+    upstream,
+    projectTokens,
+    port: router.port ?? 0,
+    log,
+    ...deps.fetch ? { fetch: deps.fetch } : {}
+  });
+  let started = false;
+  return {
+    async start() {
+      await shim.start();
+      started = true;
+    },
+    async stop() {
+      await shim.stop();
+      started = false;
+    },
+    url: () => {
+      if (!started)
+        throw new Error("router service not started");
+      return shim.url();
+    },
+    health: () => shim.health(),
+    credentialsFor(project, backend) {
+      if (!upstream.apiKey) {
+        throw new Error("defaults.router credential is missing (set apiKey or apiKeyEnv)");
+      }
+      if (backend === "direct") {
+        return { backend, baseUrl: router.baseUrl, apiKey: upstream.apiKey, extraHeaders: upstream.extraHeaders };
+      }
+      if (!started) {
+        throw new Error("router service not started");
+      }
+      const token = tokenByProject.get(project);
+      if (!token) {
+        throw new Error(`router service has no token for project '${project}'`);
+      }
+      return { backend, baseUrl: shim.url(), token };
+    }
+  };
+}
+var init_service = __esm({
+  "packages/core/dist/router/service.js"() {
+    init_auth2();
+    init_shim();
+  }
+});
+
+// packages/core/dist/router/index.js
+var init_router = __esm({
+  "packages/core/dist/router/index.js"() {
+    init_types();
+    init_auth2();
+    init_errors();
+    init_sanitize();
+    init_stream();
+    init_shim();
+    init_service();
+    init_env();
+    init_credentials();
+  }
+});
+
+// packages/core/dist/group-dispatch.js
+import { randomUUID as randomUUID4 } from "crypto";
+import { createConnection as createConnection2 } from "net";
+import { join as join15 } from "path";
+function resolveCurrentProject(config) {
+  const cwd = process.cwd();
+  for (const [name, proj] of Object.entries(config.projects)) {
+    const resolvedPath = resolveHome(proj.path);
+    if (cwd.startsWith(resolvedPath))
+      return name;
+  }
+  return null;
+}
+async function probeCaptainChannel(project, opts = {}) {
+  const stateRoot = opts.stateRoot ?? join15(CONFIG_DIR, "state");
+  const addr = readCaptainAddress(stateRoot, project);
+  if (!addr)
+    return false;
+  if (addr.agent === "opencode") {
+    if (addr.port == null)
+      return false;
+    return httpReachable(addr.port, opts.fetchImpl ?? fetch, opts.timeoutMs ?? 5e3);
+  }
+  try {
+    return await (opts.socketAccepts ?? socketAccepts)(captainSocketPath(project));
+  } catch {
+    return false;
+  }
+}
+async function httpReachable(port, fetchImpl, timeoutMs) {
+  for (const path23 of ["/session", "/api/session"]) {
+    const ac = new AbortController();
+    const t = setTimeout(() => ac.abort(), timeoutMs);
+    try {
+      const res = await fetchImpl(`http://127.0.0.1:${port}${path23}`, { signal: ac.signal });
+      if (res.ok)
+        return true;
+    } catch {
+    } finally {
+      clearTimeout(t);
+    }
+  }
+  return false;
+}
+function socketAccepts(socketPath, timeoutMs = 2e3) {
+  return new Promise((resolve4) => {
+    let settled = false;
+    const sock = createConnection2(socketPath);
+    const done = (v2) => {
+      if (settled)
+        return;
+      settled = true;
+      sock.destroy();
+      resolve4(v2);
+    };
+    sock.setTimeout(timeoutMs, () => done(false));
+    sock.once("connect", () => done(true));
+    sock.once("error", () => done(false));
+  });
+}
+async function isCaptainAlive(project, sockPath = DAEMON_SOCK_PATH, channelAlive = probeCaptainChannel) {
+  try {
+    const health = await sendRequest(sockPath, { kind: "health", project }, 5e3);
+    const captain = health?.find((h) => h.kind === "captain" && h.project === project);
+    if (captain?.state === "alive")
+      return true;
+  } catch {
+  }
+  try {
+    return await channelAlive(project);
+  } catch {
+    return false;
+  }
+}
+async function waitForWarmup(project, sockPath = DAEMON_SOCK_PATH, timeoutMs = GROUP_DISPATCH_WARMUP_TIMEOUT_MS, pollMs = GROUP_DISPATCH_WARMUP_POLL_MS, channelAlive) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await isCaptainAlive(project, sockPath, channelAlive))
+      return true;
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+  return false;
+}
+async function dispatchToSibling(opts) {
+  const config = loadConfig();
+  const fromCfg = config.projects[opts.fromProject];
+  const toCfg = config.projects[opts.toProject];
+  if (!toCfg) {
+    throw new Error(`target project '${opts.toProject}' not found in config`);
+  }
+  const sameGroup = !!fromCfg?.group && !!toCfg.group && fromCfg.group === toCfg.group;
+  if (toCfg.acceptDelegations === false) {
+    throw new Error(`cannot dispatch to '${opts.toProject}': project has acceptDelegations set to false`);
+  }
+  const sockPath = opts.sockPath ?? DAEMON_SOCK_PATH;
+  const alive = await isCaptainAlive(opts.toProject, sockPath, opts.channelAlive);
+  if (!alive) {
+    if (!sameGroup) {
+      throw new Error(`cannot dispatch to '${opts.toProject}': captain is not running and cross-group dispatch does not auto-boot it. Use 'squadrant ping ${opts.toProject} "<msg>"' or start it manually with 'squadrant launch ${opts.toProject}', then retry.`);
+    }
+    if (opts.bootCaptain) {
+      await opts.bootCaptain(opts.toProject);
+    }
+    const warmed = await waitForWarmup(opts.toProject, sockPath, opts.warmupTimeoutMs, opts.warmupPollMs, opts.channelAlive);
+    if (!warmed) {
+      throw new Error(`dispatch to '${opts.toProject}' timed out waiting for captain warmup (>${(opts.warmupTimeoutMs ?? GROUP_DISPATCH_WARMUP_TIMEOUT_MS) / 1e3}s)`);
+    }
+  }
+  const now = Date.now();
+  const attemptId = randomUUID4();
+  const record = {
+    id: randomUUID4(),
+    project: opts.toProject,
+    originProject: opts.fromProject,
+    provider: opts.provider ?? "claude",
+    mode: opts.mode ?? "headless",
+    state: "submitted",
+    task: opts.task,
+    createdAt: now,
+    lastHeartbeat: now,
+    lastEvent: "dispatch",
+    heartbeatBudgetMs: 3e5,
+    attempts: [{ attemptId, startedAt: now, lastHeartbeatAt: now }]
+  };
+  const result = await sendRequest(sockPath, { kind: "dispatch", record });
+  return result;
+}
+var GROUP_DISPATCH_WARMUP_TIMEOUT_MS, GROUP_DISPATCH_WARMUP_POLL_MS;
+var init_group_dispatch = __esm({
+  "packages/core/dist/group-dispatch.js"() {
+    init_dist();
+    init_protocol();
+    init_captain_record();
+    init_captain_channel();
+    GROUP_DISPATCH_WARMUP_TIMEOUT_MS = 12e4;
+    GROUP_DISPATCH_WARMUP_POLL_MS = 1e3;
+  }
+});
+
+// packages/core/dist/launch-workspace.js
+async function deliverStartupPrompt(runtime, refId, prompt, opts = {}) {
+  const classify = opts.classifyScreen ?? (() => "idle");
+  const readyTimeoutMs = opts.readyTimeoutMs ?? 3e4;
+  const settleMs = opts.settleMs ?? 2500;
+  const pollMs = opts.pollMs ?? 1e3;
+  const maxAttempts = opts.maxAttempts ?? 3;
+  const sleep3 = (ms) => new Promise((r) => setTimeout(r, ms));
+  const read = async () => runtime.readScreen(refId).catch(() => "");
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const deadline = Date.now() + readyTimeoutMs;
+    let preSend = await read();
+    let state = classify(preSend);
+    while (state === "loading" && Date.now() < deadline) {
+      await sleep3(pollMs);
+      preSend = await read();
+      state = classify(preSend);
+    }
+    if (state === "working")
+      return true;
+    await runtime.send(refId, prompt).catch(() => {
+    });
+    await sleep3(settleMs);
+    const after = await read();
+    if (after !== preSend)
+      return true;
+    if (state === "loading")
+      break;
+  }
+  process.stderr.write(`\u26A0\uFE0F  Startup prompt not confirmed on ${refId} after ${maxAttempts} attempt(s) \u2014 the agent may be idle with no startup prompt. Re-run launch, or send it manually.
+`);
+  return false;
+}
+async function bootWorkspace(opts) {
+  const { runtime, workspaceName, agentCmd, cwd, navigate = false, forceFresh = false, pinToTop = false, initialPrompt } = opts;
+  const existing = await runtime.status(workspaceName);
+  if (existing && forceFresh) {
+    opts.onStoppingStale?.(workspaceName);
+    await runtime.stop(existing.id);
+  } else if (existing) {
+    opts.onAlreadyExists?.(workspaceName);
+    opts.selectWorkspace?.(existing.id);
     return;
   }
   const rawCurrent = opts.getCurrentWorkspace?.() ?? null;
@@ -6889,8 +7812,10 @@ var init_source = __esm({
 var dist_exports = {};
 __export(dist_exports, {
   AGENT_BINS: () => AGENT_BINS,
+  ANTHROPIC_ONLY_REQUEST_FIELDS: () => ANTHROPIC_ONLY_REQUEST_FIELDS,
   BOT_COMMANDS: () => BOT_COMMANDS,
   CC_SOCKS_DIR: () => CC_SOCKS_DIR,
+  CMUX_PRESERVE_CLAUDE_AUTH_ENV: () => CMUX_PRESERVE_CLAUDE_AUTH_ENV,
   CREW_GONE_MS: () => CREW_GONE_MS,
   CREW_STALE_MS: () => CREW_STALE_MS,
   CaptainDelivery: () => CaptainDelivery,
@@ -6910,6 +7835,10 @@ __export(dist_exports, {
   PROBE_QUIET_MS: () => PROBE_QUIET_MS,
   PROTOCOL_VERSION: () => PROTOCOL_VERSION,
   READ_ONLY_CREW_SUBCOMMANDS: () => READ_ONLY_CREW_SUBCOMMANDS,
+  READ_ONLY_TOP_LEVEL_COMMANDS: () => READ_ONLY_TOP_LEVEL_COMMANDS,
+  ROUTER_READY_ATTEMPTS: () => ROUTER_READY_ATTEMPTS,
+  ROUTER_READY_DELAY_MS: () => ROUTER_READY_DELAY_MS,
+  SERVER_TOOL_TYPE_RE: () => SERVER_TOOL_TYPE_RE,
   STALE_THRESHOLD_MS: () => STALE_THRESHOLD_MS,
   TERMINAL_RECORD_KEEP_PER_PROJECT: () => TERMINAL_RECORD_KEEP_PER_PROJECT,
   TERMINAL_RECORD_TTL_MS: () => TERMINAL_RECORD_TTL_MS,
@@ -6918,17 +7847,22 @@ __export(dist_exports, {
   WRITABLE_CONFIG_KEYS: () => WRITABLE_CONFIG_KEYS,
   _resetRestartInFlightForTest: () => _resetRestartInFlightForTest,
   ageText: () => ageText,
+  anthropicError: () => anthropicError,
   appendCaptainMessage: () => appendCaptainMessage,
   appendToMailbox: () => appendToMailbox,
   assembleDaemonSnapshot: () => assembleDaemonSnapshot,
+  assertBackendUsable: () => assertBackendUsable,
   bootWorkspace: () => bootWorkspace,
   buildCompletionProtocol: () => buildCompletionProtocol,
   buildContext: () => buildContext,
   buildDaemonPath: () => buildDaemonPath,
   buildFreshness: () => buildFreshness,
+  buildRouterCredentialsRequest: () => buildRouterCredentialsRequest,
+  buildRouterEnv: () => buildRouterEnv,
   buildSideFirstTurn: () => buildSideFirstTurn,
   capAllowed: () => capAllowed,
   capOutput: () => capOutput,
+  captainRecordPath: () => captainRecordPath,
   captainSocketPath: () => captainSocketPath,
   checkFact: () => checkFact,
   classifyHealth: () => classifyHealth,
@@ -6947,11 +7881,14 @@ __export(dist_exports, {
   createInteractiveProbe: () => createInteractiveProbe,
   createIsCaptainAlive: () => createIsCaptainAlive,
   createLaunch: () => createLaunch,
+  createRouterService: () => createRouterService,
+  createRouterShim: () => createRouterShim,
   createRunCommand: () => createRunCommand,
   createStore: () => createStore,
   createSurfaceLivenessProbe: () => createSurfaceLivenessProbe,
   createTelegramBridge: () => createTelegramBridge,
   createTelegramClient: () => createTelegramClient,
+  createUsageTee: () => createUsageTee,
   createWorkItem: () => createWorkItem,
   createWorkStore: () => createWorkStore,
   crewPaneTitle: () => crewPaneTitle,
@@ -6972,6 +7909,7 @@ __export(dist_exports, {
   detectGroupAndUser: () => detectGroupAndUser,
   detectGroupId: () => detectGroupId,
   discoverCaptainSurface: () => discoverCaptainSurface,
+  discoverLiveOpencodeServer: () => discoverLiveOpencodeServer,
   dispatchToSibling: () => dispatchToSibling,
   encodeFrame: () => encodeFrame,
   encodeMsg: () => encodeMsg,
@@ -6985,6 +7923,7 @@ __export(dist_exports, {
   findProjectByThread: () => findProjectByThread,
   findWorkItemById: () => findWorkItemById,
   forceKickstartAndVerify: () => forceKickstartAndVerify,
+  formatCustomHeaders: () => formatCustomHeaders,
   formatInbound: () => formatInbound,
   formatInboundReceipt: () => formatInboundReceipt,
   formatLifecycle: () => formatLifecycle,
@@ -7001,33 +7940,44 @@ __export(dist_exports, {
   isNotifyActive: () => isNotifyActive,
   isOperatorInitiatedCommand: () => isOperatorInitiatedCommand,
   isReadOnlyCrewCommand: () => isReadOnlyCrewCommand,
+  isReadOnlyTopLevelCommand: () => isReadOnlyTopLevelCommand,
   isSideTitle: () => isSideTitle,
   isStickyAttention: () => isStickyAttention,
   isTurnAccepted: () => isTurnAccepted,
   isVersionUpgrade: () => isVersionUpgrade,
+  joinUrl: () => joinUrl,
   kickstartArgv: () => kickstartArgv,
   launchOneWorkspace: () => launchOneWorkspace,
+  listSessions: () => listSessions,
   loadSessions: () => loadSessions,
   loadState: () => loadState,
   mailboxStats: () => mailboxStats,
   makeGate: () => makeGate,
   maskToken: () => maskToken,
+  mintToken: () => mintToken,
   nameFromTitle: () => nameFromTitle,
+  newestSessionInDirectory: () => newestSessionInDirectory,
   nextAutoName: () => nextAutoName,
   niceCrewCommand: () => niceCrewCommand,
   notifyToggle: () => notifyToggle,
+  parseBearer: () => parseBearer,
   parseCommand: () => parseCommand,
+  parseLiveOpencodeServers: () => parseLiveOpencodeServers,
   parseNotifyPref: () => parseNotifyPref,
   parseProgramArgs: () => parseProgramArgs,
   plistPath: () => plistPath,
+  pollNewestSessionInDirectory: () => pollNewestSessionInDirectory,
   printForeignInstallError: () => printForeignInstallError,
   printVersionUpgradeNotice: () => printVersionUpgradeNotice,
+  probeCaptainChannel: () => probeCaptainChannel,
   programArgsBlock: () => programArgsBlock,
   projectHealth: () => projectHealth,
   purgeExpiredWorkItems: () => purgeExpiredWorkItems,
+  readCaptainAddress: () => readCaptainAddress,
   readCursor: () => readCursor,
   readFromCursor: () => readFromCursor,
   readRunningMarker: () => readRunningMarker,
+  realpathOrSelf: () => realpathOrSelf,
   reapCrewChildren: () => reapCrewChildren,
   reapOrphanedCrews: () => reapOrphanedCrews,
   reconcileLiveness: () => reconcileLiveness,
@@ -7037,12 +7987,18 @@ __export(dist_exports, {
   reduceLifecycle: () => reduceLifecycle,
   releaseDaemonLock: () => releaseDaemonLock,
   removeRunningMarker: () => removeRunningMarker,
+  renderEnvAssignments: () => renderEnvAssignments,
   renderPlist: () => renderPlist,
   reregisterDaemon: () => reregisterDaemon,
   resolveAgentBinDirs: () => resolveAgentBinDirs,
+  resolveAndPersistOpencodeCaptain: () => resolveAndPersistOpencodeCaptain,
+  resolveBackend: () => resolveBackend,
   resolveCrewRoute: () => resolveCrewRoute,
   resolveCurrentProject: () => resolveCurrentProject,
   resolveGate: () => resolveGate,
+  resolveProject: () => resolveProject,
+  resolveRouterCredentials: () => resolveRouterCredentials,
+  resolveRouterUpstream: () => resolveRouterUpstream,
   resolveSetupGroup: () => resolveSetupGroup,
   resolveSetupToken: () => resolveSetupToken,
   resolveSetupUserId: () => resolveSetupUserId,
@@ -7070,7 +8026,9 @@ __export(dist_exports, {
   runTelegramSend: () => runTelegramSend,
   runTelegramStatus: () => runTelegramStatus,
   runningMarkerPath: () => runningMarkerPath,
+  sameDirectory: () => sameDirectory,
   sanitizePathForPlist: () => sanitizePathForPlist,
+  sanitizeRequest: () => sanitizeRequest,
   saveSessions: () => saveSessions,
   saveState: () => saveState,
   screenHasSplashMarker: () => screenHasSplashMarker,
@@ -7079,6 +8037,7 @@ __export(dist_exports, {
   setNotify: () => setNotify,
   setTopic: () => setTopic,
   shellQuote: () => shellQuote,
+  shouldBuildRouterService: () => shouldBuildRouterService,
   shouldStartFresh: () => shouldStartFresh,
   sideNameFromTitle: () => sideNameFromTitle,
   sideNextAutoName: () => sideNextAutoName,
@@ -7094,8 +8053,10 @@ __export(dist_exports, {
   topicKey: () => topicKey,
   topicName: () => topicName,
   tryAcquireDaemonLock: () => tryAcquireDaemonLock,
+  usageFromJson: () => usageFromJson,
   waitForCaptainDelivery: () => waitForCaptainDelivery,
   waitForWarmup: () => waitForWarmup,
+  writeCaptainAddress: () => writeCaptainAddress,
   writeCursor: () => writeCursor,
   writeExitMarker: () => writeExitMarker,
   writeRunningMarker: () => writeRunningMarker,
@@ -7129,7 +8090,9 @@ var init_dist2 = __esm({
     init_crew_protocol();
     init_crew_lifecycle();
     init_telegram();
+    init_router();
     init_crew_routing();
+    init_router_resolution();
     init_restart_daemon();
     init_group_dispatch();
     init_launch_workspace();
@@ -7145,6 +8108,8 @@ var init_dist2 = __esm({
     init_source();
     init_control_channel();
     init_captain_channel();
+    init_captain_record();
+    init_opencode_session();
   }
 });
 
@@ -7160,14 +8125,75 @@ init_dist2();
 init_dist2();
 init_dist2();
 init_dist2();
-import { join as join22, dirname as dirname4, resolve as resolve3 } from "path";
-import { homedir as homedir13 } from "os";
+import { join as join26, dirname as dirname5, resolve as resolve3 } from "path";
+import { homedir as homedir14 } from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { readFileSync as readFileSync15, statSync as statSync4, existsSync as existsSync13 } from "fs";
+import { readFileSync as readFileSync18, statSync as statSync4, existsSync as existsSync13 } from "fs";
 
 // packages/agents/dist/drivers/claude.js
 import { execSync as execSync2 } from "child_process";
 
+// packages/agents/dist/sessions/claude-sessions.js
+import { readdirSync as readdirSync4, readFileSync as readFileSync11 } from "fs";
+import { join as join17 } from "path";
+
+// packages/agents/dist/claude/registry.js
+import fs13 from "fs";
+import { join as join16 } from "path";
+import { homedir as homedir7 } from "os";
+var CLAUDE_SESSIONS_DIR = join16(homedir7(), ".claude", "sessions");
+var PID_JSON = /^(\d+)\.json$/;
+function parseRegistryDir(files, readFile7) {
+  const out = [];
+  for (const name of files) {
+    const m = PID_JSON.exec(name);
+    if (!m)
+      continue;
+    let json;
+    try {
+      json = JSON.parse(readFile7(name));
+    } catch {
+      continue;
+    }
+    out.push({ ...json, pid: parseInt(m[1], 10) });
+  }
+  return out;
+}
+function toLifecycleSnapshot(entry, taskId, alive, now) {
+  const at = entry.statusUpdatedAt ?? now;
+  const base = { taskId, alive, origin: "agent", at, pid: entry.pid };
+  if (!alive)
+    return { ...base, state: "unknown" };
+  switch (entry.status) {
+    case "busy":
+    case "shell":
+      return { ...base, state: "running" };
+    case "idle":
+      return { ...base, state: "idle" };
+    case "waiting":
+      return {
+        ...base,
+        state: "needsInput",
+        detail: { reason: entry.waitingFor, note: entry.waitingFor }
+      };
+    default:
+      return { ...base, state: "unknown" };
+  }
+}
+function readClaudeStatusBySocketPath(socketPath) {
+  let files;
+  try {
+    files = fs13.readdirSync(CLAUDE_SESSIONS_DIR);
+  } catch {
+    return void 0;
+  }
+  const entries = parseRegistryDir(files, (name) => fs13.readFileSync(join16(CLAUDE_SESSIONS_DIR, name), "utf8"));
+  const entry = entries.find((e) => e.messagingSocketPath === socketPath);
+  if (!entry)
+    return void 0;
+  return { status: entry.status, statusUpdatedAt: entry.statusUpdatedAt, sessionId: entry.sessionId };
+}
+
 // packages/agents/dist/drivers/codex.js
 import { execSync as execSync3 } from "child_process";
 
@@ -7177,8 +8203,14 @@ import { execSync as execSync4 } from "child_process";
 // packages/agents/dist/drivers/opencode.js
 import { execSync as execSync5 } from "child_process";
 
+// packages/agents/dist/sessions/opencode-sessions.js
+import { readdirSync as readdirSync5, readFileSync as readFileSync12 } from "fs";
+import { join as join18 } from "path";
+import { homedir as homedir8 } from "os";
+var SQUADRANT_STATE_DIR = join18(homedir8(), ".config", "squadrant", "state");
+
 // packages/agents/dist/drivers/launch-cmd.js
-import fs13 from "fs";
+import fs14 from "fs";
 import path13 from "path";
 
 // packages/agents/dist/projection/cursor.js
@@ -7201,10 +8233,102 @@ import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from
 import path17 from "path";
 import os9 from "os";
 
+// packages/agents/dist/projection/opencode-skills.js
+import fs15 from "fs";
+import os10 from "os";
+import path18 from "path";
+var OPENCODE_SKILL_MARKER = ".squadrant-managed";
+var MARKER_BODY = "squadrant\n";
+function defaultOpencodeSkillsRoot(env = process.env) {
+  const configHome = env.XDG_CONFIG_HOME || path18.join(os10.homedir(), ".config");
+  return path18.join(configHome, "opencode", "skills");
+}
+var SAFE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function parseSkillName(raw) {
+  const fm = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!fm)
+    return null;
+  const name = fm[1].match(/^name:\s*(.+)$/m)?.[1]?.trim();
+  const description = fm[1].match(/^description:\s*(.+)$/m)?.[1]?.trim();
+  if (!name || !description)
+    return null;
+  return name;
+}
+function listSourceSkills(sourceSkillsDir) {
+  const out = /* @__PURE__ */ new Map();
+  if (!fs15.existsSync(sourceSkillsDir))
+    return out;
+  for (const entry of fs15.readdirSync(sourceSkillsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory())
+      continue;
+    const skillPath = path18.join(sourceSkillsDir, entry.name, "SKILL.md");
+    if (!fs15.existsSync(skillPath))
+      continue;
+    const name = parseSkillName(fs15.readFileSync(skillPath, "utf-8"));
+    if (name && SAFE_NAME.test(name))
+      out.set(name, skillPath);
+  }
+  return out;
+}
+function hasMarker(dir) {
+  return fs15.existsSync(path18.join(dir, OPENCODE_SKILL_MARKER));
+}
+function syncOpencodeSkills(opts) {
+  const result = { written: [], unchanged: [], removed: [], skipped: [] };
+  const wanted = listSourceSkills(opts.sourceSkillsDir);
+  if (wanted.size === 0 && !fs15.existsSync(opts.sourceSkillsDir))
+    return result;
+  if (!opts.dryRun)
+    fs15.mkdirSync(opts.skillsRoot, { recursive: true });
+  for (const [name, srcPath] of wanted) {
+    const targetDir = path18.join(opts.skillsRoot, name);
+    const targetSkill = path18.join(targetDir, "SKILL.md");
+    const managed = hasMarker(targetDir);
+    if (fs15.existsSync(targetSkill) && !managed) {
+      result.skipped.push({ name, reason: "foreign-collision" });
+      continue;
+    }
+    const current = fs15.existsSync(targetSkill) ? fs15.readFileSync(targetSkill) : null;
+    if (current && current.equals(fs15.readFileSync(srcPath))) {
+      if (!managed && !opts.dryRun) {
+        fs15.writeFileSync(path18.join(targetDir, OPENCODE_SKILL_MARKER), MARKER_BODY);
+      }
+      result.unchanged.push(name);
+      continue;
+    }
+    if (!opts.dryRun) {
+      fs15.mkdirSync(targetDir, { recursive: true });
+      fs15.copyFileSync(srcPath, targetSkill);
+      fs15.writeFileSync(path18.join(targetDir, OPENCODE_SKILL_MARKER), MARKER_BODY);
+    }
+    result.written.push(name);
+  }
+  if (fs15.existsSync(opts.skillsRoot)) {
+    for (const entry of fs15.readdirSync(opts.skillsRoot, { withFileTypes: true })) {
+      if (!entry.isDirectory() || wanted.has(entry.name))
+        continue;
+      const dir = path18.join(opts.skillsRoot, entry.name);
+      if (!hasMarker(dir))
+        continue;
+      if (!opts.dryRun)
+        fs15.rmSync(dir, { recursive: true, force: true });
+      result.removed.push(entry.name);
+    }
+  }
+  return result;
+}
+function syncShippedOpencodeSkills(opts) {
+  return syncOpencodeSkills({
+    sourceSkillsDir: path18.join(opts.pkgRoot, "plugin", "skills"),
+    skillsRoot: opts.skillsRoot ?? defaultOpencodeSkillsRoot(),
+    dryRun: opts.dryRun
+  });
+}
+
 // packages/agents/dist/projection/claude.js
 import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import path18 from "path";
-import os10 from "os";
+import path19 from "path";
+import os11 from "os";
 
 // packages/agents/dist/codex/app-server-client.js
 import { EventEmitter } from "events";
@@ -7478,11 +8602,11 @@ function toSnapshot(ev) {
 
 // packages/agents/dist/codex/config.js
 import { readFile as readFile6 } from "fs/promises";
-import { homedir as homedir7 } from "os";
-import { join as join14 } from "path";
+import { homedir as homedir9 } from "os";
+import { join as join19 } from "path";
 async function resolveCodexModel() {
-  const home = process.env["CODEX_HOME"] ?? join14(homedir7(), ".codex");
-  const configPath = join14(home, "config.toml");
+  const home = process.env["CODEX_HOME"] ?? join19(homedir9(), ".codex");
+  const configPath = join19(home, "config.toml");
   let text;
   try {
     text = await readFile6(configPath, "utf8");
@@ -7994,10 +9118,10 @@ var OpencodeSseBridge = class {
 
 // packages/agents/dist/interactive/claude.js
 import { execSync as execSync6 } from "child_process";
-import { readFileSync as readFileSync10 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join15 } from "path";
-var nextAskUserQuestionRequestId = Date.now();
+import { readFileSync as readFileSync13 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join20 } from "path";
+var nextHookRequestId = Date.now();
 
 // packages/agents/dist/headless/types.js
 var HEADLESS_ERROR_TAIL = 2e3;
@@ -8160,67 +9284,8 @@ function runHeadless(opts) {
 }
 
 // packages/agents/dist/claude/peer-registry-source.js
-import { readdirSync as readdirSync4, readFileSync as readFileSync11 } from "fs";
-import { join as join17 } from "path";
-
-// packages/agents/dist/claude/registry.js
-import fs14 from "fs";
-import { join as join16 } from "path";
-import { homedir as homedir9 } from "os";
-var CLAUDE_SESSIONS_DIR = join16(homedir9(), ".claude", "sessions");
-var PID_JSON = /^(\d+)\.json$/;
-function parseRegistryDir(files, readFile7) {
-  const out = [];
-  for (const name of files) {
-    const m = PID_JSON.exec(name);
-    if (!m)
-      continue;
-    let json;
-    try {
-      json = JSON.parse(readFile7(name));
-    } catch {
-      continue;
-    }
-    out.push({ ...json, pid: parseInt(m[1], 10) });
-  }
-  return out;
-}
-function toLifecycleSnapshot(entry, taskId, alive, now) {
-  const at = entry.statusUpdatedAt ?? now;
-  const base = { taskId, alive, origin: "agent", at, pid: entry.pid };
-  if (!alive)
-    return { ...base, state: "unknown" };
-  switch (entry.status) {
-    case "busy":
-    case "shell":
-      return { ...base, state: "running" };
-    case "idle":
-      return { ...base, state: "idle" };
-    case "waiting":
-      return {
-        ...base,
-        state: "needsInput",
-        detail: { reason: entry.waitingFor, note: entry.waitingFor }
-      };
-    default:
-      return { ...base, state: "unknown" };
-  }
-}
-function readClaudeStatusBySocketPath(socketPath) {
-  let files;
-  try {
-    files = fs14.readdirSync(CLAUDE_SESSIONS_DIR);
-  } catch {
-    return void 0;
-  }
-  const entries = parseRegistryDir(files, (name) => fs14.readFileSync(join16(CLAUDE_SESSIONS_DIR, name), "utf8"));
-  const entry = entries.find((e) => e.messagingSocketPath === socketPath);
-  if (!entry)
-    return void 0;
-  return { status: entry.status, statusUpdatedAt: entry.statusUpdatedAt, sessionId: entry.sessionId };
-}
-
-// packages/agents/dist/claude/peer-registry-source.js
+import { readdirSync as readdirSync6, readFileSync as readFileSync14 } from "fs";
+import { join as join21 } from "path";
 function defaultIsAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -8244,8 +9309,8 @@ var ClaudePeerRegistrySource = class {
   pollMs;
   log;
   constructor(o = {}) {
-    this.readdir = o.readdir ?? (() => readdirSync4(CLAUDE_SESSIONS_DIR));
-    this.readFile = o.readFile ?? ((n) => readFileSync11(join17(CLAUDE_SESSIONS_DIR, n), "utf8"));
+    this.readdir = o.readdir ?? (() => readdirSync6(CLAUDE_SESSIONS_DIR));
+    this.readFile = o.readFile ?? ((n) => readFileSync14(join21(CLAUDE_SESSIONS_DIR, n), "utf8"));
     this.isAlive = o.isAlive ?? defaultIsAlive;
     this.now = o.now ?? Date.now;
     this.pollMs = o.pollMs ?? 2e3;
@@ -8557,6 +9622,119 @@ var ClaudeReceiptListener = class {
   }
 };
 
+// packages/agents/dist/claude/api-key-approval.js
+import fs16 from "fs";
+import os12 from "os";
+import path20 from "path";
+
+// packages/agents/dist/opencode/http-channel.js
+var OpencodeHttpChannel = class {
+  name = "opencode-http";
+  agent = "opencode";
+  /** taskId → resolved session id. Invalidated on 404 (see send()). */
+  sessionByTask = /* @__PURE__ */ new Map();
+  fetchImpl;
+  portFor;
+  sessionFor;
+  timeoutMs;
+  log;
+  constructor(deps) {
+    this.fetchImpl = deps.fetchImpl ?? fetch;
+    this.portFor = deps.portFor;
+    this.sessionFor = deps.sessionFor;
+    this.timeoutMs = deps.timeoutMs ?? 5e3;
+    this.log = deps.log;
+  }
+  async send(taskId, message) {
+    const port = this.portFor(taskId);
+    if (port == null)
+      return { status: "unsupported" };
+    const sessionId = this.sessionFor?.(taskId) ?? await this.resolveSession(taskId, port);
+    if (!sessionId)
+      return { status: "gone" };
+    let res;
+    try {
+      res = await this.request(`http://127.0.0.1:${port}/session/${sessionId}/prompt_async`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ parts: [{ type: "text", text: message }] })
+      });
+    } catch (e) {
+      this.log?.(`opencode-http send transport error for ${taskId}: ${e.message}`);
+      return { status: "gone" };
+    }
+    if (res.status === 204 || res.status === 200) {
+      return { status: "accepted", via: this.name };
+    }
+    if (res.status === 404) {
+      this.sessionByTask.delete(taskId);
+      this.log?.(`opencode-http: session ${sessionId} for ${taskId} is gone (404)`);
+      return { status: "gone" };
+    }
+    this.log?.(`opencode-http: unexpected status ${res.status} for ${taskId}`);
+    return { status: "gone" };
+  }
+  /**
+   * Non-mutating reachability check. MUST NOT deliver anything — shadow mode
+   * calls this alongside a real pane send, and a POST here would deliver the
+   * message twice.
+   */
+  async probe(taskId) {
+    const port = this.portFor(taskId);
+    if (port == null)
+      return { status: "unsupported" };
+    const sessionId = this.sessionFor?.(taskId) ?? await this.resolveSession(taskId, port);
+    return sessionId ? { status: "reachable", via: this.name } : { status: "gone" };
+  }
+  // ── private ───────────────────────────────────────────────────────────────
+  /**
+   * Resolve (and cache) the crew's session id.
+   *
+   * opencode 1.18.18 is mid-migration from /session/* to /api/session/*, so both
+   * are tried. This is a capability probe, NOT a version comparison — the honest
+   * check is "does this route answer", and neither path is a promised-stable
+   * contract. Re-run the smoke suite when opencode is upgraded.
+   */
+  async resolveSession(taskId, port) {
+    const cached = this.sessionByTask.get(taskId);
+    if (cached)
+      return cached;
+    for (const path23 of ["/session?", "/api/session?"]) {
+      let res;
+      try {
+        res = await this.request(`http://127.0.0.1:${port}${path23}`, { method: "GET" });
+      } catch {
+        return void 0;
+      }
+      if (!res.ok)
+        continue;
+      let sessions;
+      try {
+        sessions = await res.json();
+      } catch {
+        continue;
+      }
+      if (!Array.isArray(sessions) || sessions.length === 0)
+        continue;
+      const newest = sessions.reduce((a, b) => (b.time?.updated ?? 0) > (a.time?.updated ?? 0) ? b : a);
+      if (!newest?.id)
+        continue;
+      this.sessionByTask.set(taskId, newest.id);
+      return newest.id;
+    }
+    return void 0;
+  }
+  async request(url, init) {
+    const ac = new AbortController();
+    const t = setTimeout(() => ac.abort(), this.timeoutMs);
+    try {
+      return await this.fetchImpl(url, { ...init, signal: ac.signal });
+    } finally {
+      clearTimeout(t);
+    }
+  }
+};
+
 // packages/agents/dist/opencode/fact-adapter.js
 function createOpencodeFactAdapter(deps) {
   return {
@@ -8589,6 +9767,9 @@ function createOpencodeFactAdapter(deps) {
       }
       if (type === "permission.replied")
         return [{ kind: "activity" }];
+      if (type === "server.connected" || type === "server.heartbeat") {
+        return [{ kind: "activity" }];
+      }
       return [{ kind: "unknown", name: type }];
     }
   };
@@ -8599,7 +9780,8 @@ init_dist();
 init_dist();
 init_dist();
 init_dist2();
-import { execFile as execFile2, execFileSync as execFileSync5 } from "child_process";
+init_dist2();
+import { execFile as execFile2, execFileSync as execFileSync6 } from "child_process";
 var CMUX_TIMEOUT = 15e3;
 var CmuxTimeoutError = class extends Error {
   constructor(cmd) {
@@ -9195,9 +10377,9 @@ var NotifierRegistry = class {
 };
 
 // packages/workspaces/dist/workspaces/obsidian.js
-import fs15 from "fs/promises";
+import fs17 from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
-import path19 from "path";
+import path21 from "path";
 
 // packages/workspaces/dist/workspaces/registry.js
 init_dist();
@@ -9350,16 +10532,16 @@ var CmuxEventsBridge = class {
 // packages/workspaces/dist/cmux-daemon/daemon-cmux.js
 init_dist2();
 init_dist();
-import { readdirSync as readdirSync5, readFileSync as readFileSync12 } from "fs";
-import { join as join18 } from "path";
-import { homedir as homedir10 } from "os";
+import { readdirSync as readdirSync7, readFileSync as readFileSync15 } from "fs";
+import { join as join22 } from "path";
+import { homedir as homedir11 } from "os";
 
 // packages/workspaces/dist/cmux-daemon/store-fingerprint.js
 init_dist();
 init_dist2();
-import { execFileSync as execFileSync6 } from "child_process";
+import { execFileSync as execFileSync7 } from "child_process";
 function defaultExecPs(pid) {
-  return execFileSync6("ps", ["-o", "command=", "-p", String(pid)], {
+  return execFileSync7("ps", ["-o", "command=", "-p", String(pid)], {
     encoding: "utf-8",
     stdio: ["ignore", "pipe", "ignore"]
   });
@@ -9449,15 +10631,15 @@ function readLivenessSnapshot(files, readFile7, projects, argvRecovery = {}) {
 
 // packages/workspaces/dist/cmux-daemon/daemon-cmux.js
 async function readCmuxLiveness() {
-  const dir = process.env.CMUX_AGENT_HOOK_STATE_DIR ?? join18(homedir10(), ".cmuxterm");
+  const dir = process.env.CMUX_AGENT_HOOK_STATE_DIR ?? join22(homedir11(), ".cmuxterm");
   const projects = loadConfig().projects;
   let files;
   try {
-    files = readdirSync5(dir).filter((f) => f.endsWith("-hook-sessions.json") && !f.endsWith(".lock"));
+    files = readdirSync7(dir).filter((f) => f.endsWith("-hook-sessions.json") && !f.endsWith(".lock"));
   } catch (e) {
     throw new Error(`liveness: could not read cmux state dir ${dir}: ${e.message}`);
   }
-  return readLivenessSnapshot(files, (f) => readFileSync12(join18(dir, f), "utf-8"), projects);
+  return readLivenessSnapshot(files, (f) => readFileSync15(join22(dir, f), "utf-8"), projects);
 }
 var DaemonCmux = class {
   driver;
@@ -9520,13 +10702,15 @@ var DaemonCmux = class {
 };
 
 // packages/workspaces/dist/cmux-daemon/cmux-store-source.js
-import { join as join19 } from "path";
-import { homedir as homedir11 } from "os";
-import { watch, readdirSync as readdirSync6, readFileSync as readFileSync13, existsSync as existsSync12 } from "fs";
+import { join as join23 } from "path";
+import { homedir as homedir12 } from "os";
+import { watch, readdirSync as readdirSync8, readFileSync as readFileSync16, existsSync as existsSync12 } from "fs";
 var CmuxStoreSource = class {
   name = "cmux-store";
   stateDir;
   debounceMs;
+  lockRetryMs;
+  maxLockRetries;
   isPidAlive;
   listFiles;
   readFile;
@@ -9538,13 +10722,19 @@ var CmuxStoreSource = class {
   deps;
   stopWatcher;
   debounceTimer;
+  /** filename → pending lock-retry timer (one per locked file). */
+  lockRetryTimers = /* @__PURE__ */ new Map();
+  /** filename → re-scan attempts used in the current lock episode. */
+  lockRetryCounts = /* @__PURE__ */ new Map();
   /** taskId → last reported snapshot (for snapshot() liveness floor). */
   cache = /* @__PURE__ */ new Map();
   active = false;
   lastError = null;
   constructor(opts = {}) {
-    this.stateDir = opts.stateDir ?? process.env.CMUX_AGENT_HOOK_STATE_DIR ?? join19(homedir11(), ".cmuxterm");
+    this.stateDir = opts.stateDir ?? process.env.CMUX_AGENT_HOOK_STATE_DIR ?? join23(homedir12(), ".cmuxterm");
     this.debounceMs = opts.debounceMs ?? 50;
+    this.lockRetryMs = opts.lockRetryMs ?? 50;
+    this.maxLockRetries = opts.maxLockRetries ?? 3;
     this.isPidAlive = opts.isPidAlive ?? defaultIsPidAlive2;
     this.listFiles = opts.listFiles ?? defaultListFiles;
     this.readFile = opts.readFile ?? defaultReadFile;
@@ -9572,6 +10762,11 @@ var CmuxStoreSource = class {
       this.cancelTimer(this.debounceTimer);
       this.debounceTimer = void 0;
     }
+    for (const timer of this.lockRetryTimers.values()) {
+      this.cancelTimer(timer);
+    }
+    this.lockRetryTimers.clear();
+    this.lockRetryCounts.clear();
     this.stopWatcher?.();
     this.stopWatcher = void 0;
     this.deps = void 0;
@@ -9605,12 +10800,13 @@ var CmuxStoreSource = class {
   }
   scanFile(filename) {
     const deps = this.deps;
-    const filePath = join19(this.stateDir, filename);
+    const filePath = join23(this.stateDir, filename);
     const lockPath = `${filePath}.lock`;
     if (this.fileExists(lockPath)) {
-      this.log(`cmux-store: skipping ${filename} (locked)`);
+      this.scheduleLockRetry(filename);
       return;
     }
+    this.clearLockRetry(filename);
     const raw = this.readFile(filePath);
     if (!raw)
       return;
@@ -9625,6 +10821,31 @@ var CmuxStoreSource = class {
       this.processSession(session, deps);
     }
   }
+  /** Bounded, one-timer-per-file retry for a file cmux currently has locked. */
+  scheduleLockRetry(filename) {
+    if (this.lockRetryTimers.has(filename))
+      return;
+    const attempts = this.lockRetryCounts.get(filename) ?? 0;
+    if (attempts >= this.maxLockRetries)
+      return;
+    if (attempts === 0)
+      this.log(`cmux-store: skipping ${filename} (locked)`);
+    this.lockRetryCounts.set(filename, attempts + 1);
+    const timer = this.scheduleTimer(() => {
+      this.lockRetryTimers.delete(filename);
+      this.scanFile(filename);
+    }, this.lockRetryMs);
+    this.lockRetryTimers.set(filename, timer);
+  }
+  /** A successful (unlocked) scan ends the lock episode. */
+  clearLockRetry(filename) {
+    const timer = this.lockRetryTimers.get(filename);
+    if (timer !== void 0) {
+      this.cancelTimer(timer);
+      this.lockRetryTimers.delete(filename);
+    }
+    this.lockRetryCounts.delete(filename);
+  }
   processSession(session, deps) {
     if (!session.sessionId || !session.cwd || typeof session.pid !== "number")
       return;
@@ -9671,14 +10892,14 @@ function defaultIsPidAlive2(pid) {
 }
 function defaultListFiles(dir) {
   try {
-    return readdirSync6(dir).filter((f) => f.endsWith("-hook-sessions.json") && !f.endsWith(".lock"));
+    return readdirSync8(dir).filter((f) => f.endsWith("-hook-sessions.json") && !f.endsWith(".lock"));
   } catch {
     return [];
   }
 }
-function defaultReadFile(path21) {
+function defaultReadFile(path23) {
   try {
-    return readFileSync13(path21, "utf-8");
+    return readFileSync16(path23, "utf-8");
   } catch {
     return void 0;
   }
@@ -9693,9 +10914,9 @@ function defaultWatchDir(dir, cb) {
 }
 
 // packages/workspaces/dist/native-hooks/native-hook-source.js
-import { join as join20 } from "path";
-import { homedir as homedir12 } from "os";
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync14, writeFileSync as writeFileSync9 } from "fs";
+import { join as join24 } from "path";
+import { homedir as homedir13 } from "os";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync17, writeFileSync as writeFileSync10 } from "fs";
 var CLAUDE_HOOK_EVENTS = [
   ["SessionStart", "session-start"],
   ["UserPromptSubmit", "prompt-submit"],
@@ -9703,11 +10924,17 @@ var CLAUDE_HOOK_EVENTS = [
   ["Stop", "stop"],
   ["Notification", "notification"],
   ["PreToolUse", "ask-question", "AskUserQuestion"],
-  ["SessionEnd", "session-end"]
+  ["SessionEnd", "session-end"],
+  // #760: fires ~6s before the matching Notification, carrying tool_name +
+  // tool_input directly — a strictly better task.blocked source.
+  ["PermissionRequest", "permission-request"],
+  // #763: the turn died on an API error — today squadrant has no source for
+  // this at all; without it the watchdog reports a plain stall (wrong story).
+  ["StopFailure", "stop-failure"]
 ];
 var DEFAULT_HOOK_CMD = "squadrant hooks";
 function installClaudeHooks(opts = {}) {
-  const settingsPath = opts.settingsPath ?? join20(homedir12(), ".claude", "settings.json");
+  const settingsPath = opts.settingsPath ?? join24(homedir13(), ".claude", "settings.json");
   const hookCmd = opts.hookCmd ?? DEFAULT_HOOK_CMD;
   const readFile7 = opts.readFile ?? defaultReadFile2;
   const writeFile6 = opts.writeFile ?? defaultWriteFile;
@@ -9781,6 +11008,10 @@ function mapSubToLifecycle(sub) {
       return "needsInput";
     case "ask-question":
       return "needsInput";
+    case "permission-request":
+      return "needsInput";
+    case "stop-failure":
+      return "idle";
     case "session-end":
       return "session-end";
     default:
@@ -9875,16 +11106,16 @@ function extractDetail(sub, payload) {
   }
   return void 0;
 }
-function defaultReadFile2(path21) {
+function defaultReadFile2(path23) {
   try {
-    return readFileSync14(path21, "utf-8");
+    return readFileSync17(path23, "utf-8");
   } catch {
     return void 0;
   }
 }
-function defaultWriteFile(path21, content) {
-  mkdirSync6(path21.replace(/\/[^/]+$/, ""), { recursive: true });
-  writeFileSync9(path21, content, "utf-8");
+function defaultWriteFile(path23, content) {
+  mkdirSync7(path23.replace(/\/[^/]+$/, ""), { recursive: true });
+  writeFileSync10(path23, content, "utf-8");
 }
 
 // packages/workspaces/dist/crew-pane.js
@@ -9964,9 +11195,9 @@ init_dist();
 
 // packages/cli/src/lib/daemon-restart-broadcast.ts
 init_dist();
-import path20 from "path";
+import path22 from "path";
 function statePath2(stateRoot) {
-  return path20.join(stateRoot, "daemon-restart-state.json");
+  return path22.join(stateRoot, "daemon-restart-state.json");
 }
 function computeRestartSignature(version, buildMtimeMs) {
   return `${version}::${buildMtimeMs}`;
@@ -10014,25 +11245,25 @@ async function maybeBroadcastDaemonRestart(opts) {
 }
 
 // packages/cli/src/lib/captain-channel-factory.ts
-import { createServer as createServer3, connect as netConnect } from "net";
-import fs16 from "fs";
-import { join as join21 } from "path";
+import { createServer as createServer4, connect as netConnect } from "net";
+import fs18 from "fs";
+import { join as join25 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 import chalk2 from "chalk";
 init_dist2();
 var shared;
-var registryEntryPath = () => join21(CLAUDE_SESSIONS_DIR, `${process.pid}.json`);
+var registryEntryPath = () => join25(CLAUDE_SESSIONS_DIR, `${process.pid}.json`);
 function unregisterSenderIdentity() {
   try {
-    fs16.unlinkSync(registryEntryPath());
+    fs18.unlinkSync(registryEntryPath());
   } catch {
   }
 }
 function registerSenderIdentity(socketPath) {
   try {
     unregisterSenderIdentity();
-    fs16.mkdirSync(CLAUDE_SESSIONS_DIR, { recursive: true });
-    fs16.writeFileSync(
+    fs18.mkdirSync(CLAUDE_SESSIONS_DIR, { recursive: true });
+    fs18.writeFileSync(
       registryEntryPath(),
       JSON.stringify({
         pid: process.pid,
@@ -10053,12 +11284,12 @@ async function sharedReceiptListener() {
   const socketPath = `${CC_SOCKS_DIR}/squadrantd-${process.pid}.sock`;
   const listener = new ClaudeReceiptListener({
     socketPath,
-    createServer: (h) => createServer3(h),
+    createServer: (h) => createServer4(h),
     // A UDS path is not cleaned up when a process is killed, so our own leftover
     // must never be the reason we refuse to start.
     unlinkStale: (p) => {
       try {
-        fs16.unlinkSync(p);
+        fs18.unlinkSync(p);
       } catch {
       }
     },
@@ -10083,15 +11314,28 @@ async function buildCaptainChannel() {
     // in /tmp/x registers cwd "/private/tmp/x" on macOS, so cwd matching silently
     // missed and every captain ping reported accepted-unconfirmed.
     statusFor: (taskId) => readClaudeStatusBySocketPath(captainSocketPath(taskId)),
-    wire: (p, e) => writeLine(p, e, { connect: (path21) => netConnect(path21) }),
+    wire: (p, e) => writeLine(p, e, { connect: (path23) => netConnect(path23) }),
     receipts,
     newMsgId: () => randomUUID5(),
     sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
     log: (m) => console.error(chalk2.dim(m))
   });
 }
-async function buildCaptainChannelWithRetry(opts = {}) {
-  const build = opts.build ?? buildCaptainChannel;
+async function buildCaptainChannels(opts) {
+  const claude = await buildCaptainChannel();
+  const opencode = new OpencodeHttpChannel({
+    portFor: (project) => readCaptainAddress(opts.stateRoot, project)?.port,
+    sessionFor: (project) => readCaptainAddress(opts.stateRoot, project)?.sessionId
+  });
+  return {
+    channels: { claude, opencode },
+    agentFor: (project) => resolveCaptainAgent(opts.stateRoot, project, opts.configAgent)
+  };
+}
+function resolveCaptainAgent(stateRoot, project, configAgent) {
+  return readCaptainAddress(stateRoot, project)?.agent ?? configAgent;
+}
+async function retryForever(build, opts = {}) {
   const sleep3 = opts.sleep ?? ((ms) => new Promise((r) => {
     const t = setTimeout(r, ms);
     t.unref?.();
@@ -10110,14 +11354,20 @@ async function buildCaptainChannelWithRetry(opts = {}) {
     }
   }
 }
+function buildCaptainChannelsWithRetry(opts) {
+  return retryForever(
+    () => buildCaptainChannels({ stateRoot: opts.stateRoot, configAgent: opts.configAgent }),
+    opts
+  );
+}
 
 // packages/cli/src/squadrantd.ts
 var SELF_PATH2 = fileURLToPath3(import.meta.url);
-var CLI_BIN = join22(dirname4(SELF_PATH2), "index.js");
+var CLI_BIN = join26(dirname5(SELF_PATH2), "index.js");
 function readPkgVersion() {
   try {
-    const pkgPath = join22(dirname4(SELF_PATH2), "..", "package.json");
-    return JSON.parse(readFileSync15(pkgPath, "utf-8")).version ?? "unknown";
+    const pkgPath = join26(dirname5(SELF_PATH2), "..", "package.json");
+    return JSON.parse(readFileSync18(pkgPath, "utf-8")).version ?? "unknown";
   } catch {
     return "unknown";
   }
@@ -10139,7 +11389,7 @@ function buildTelegramBridge(cfg, stateRoot, log, deliverInbound) {
   return createTelegramBridge({
     cfg,
     stateRoot,
-    configRoot: dirname4(stateRoot),
+    configRoot: dirname5(stateRoot),
     client,
     appendCaptainMessage,
     log,
@@ -10264,7 +11514,7 @@ function startSquadrantd(opts = {}) {
         (r) => r.mode === "interactive" && !TERMINAL_STATES.has(r.state) && r.cwd === hook.cwd
       );
     },
-    cursorFile: join22(stateRoot, "cmux-events.seq"),
+    cursorFile: join26(stateRoot, "cmux-events.seq"),
     log
   });
   const cmuxStoreSource = new CmuxStoreSource({ log });
@@ -10291,14 +11541,23 @@ function startSquadrantd(opts = {}) {
       log
     }))
   ) : void 0);
+  const cfg = loadConfig();
+  const routerCfg = cfg.defaults.router;
+  ctx.routerService = opts.routerService ?? (shouldBuildRouterService(routerCfg, !!process.env.VITEST) && routerCfg ? createRouterService(routerCfg, Object.keys(cfg.projects), { log }) : void 0);
   if (opts.notifyFault) ctx.notifyFault = opts.notifyFault;
   else if (!process.env.VITEST) ctx.notifyFault = buildNotifyFault(log);
   ctx.daemonCmux = opts.daemonCmux ?? (opts.makeDaemonCmux ?? (() => new DaemonCmux(createCmuxDriver())))();
   if (!process.env.VITEST) {
     ctx.captainChannelMode = () => loadConfig().defaults.captainChannel ?? "off";
     if (ctx.captainChannelMode() !== "off") {
-      void buildCaptainChannelWithRetry({ log }).then((ch) => {
-        ctx.captainChannel = ch;
+      void buildCaptainChannelsWithRetry({
+        stateRoot: join26(homedir14(), ".config", "squadrant", "state"),
+        configAgent: loadConfig().defaults.roles?.captain?.agent,
+        log
+      }).then(({ channels, agentFor }) => {
+        ctx.captainChannels = channels;
+        ctx.captainAgentFor = agentFor;
+        ctx.captainChannel = channels.claude;
       }).catch((e) => log(`captain-channel: unexpected retry-loop error: ${e.message}`));
     }
   }
@@ -10407,6 +11666,11 @@ ${buildCompletionProtocol(rec.id, rec.project)}`;
     } catch (e) {
       log(`native hook install failed: ${e.message}`);
     }
+    try {
+      syncShippedOpencodeSkills({ pkgRoot: join26(dirname5(SELF_PATH2), "..") });
+    } catch (e) {
+      log(`opencode skills sync failed: ${e.message}`);
+    }
     const hookPrevSnaps = /* @__PURE__ */ new Map();
     const hookDeps = {
       resolve: (hint) => {
@@ -10541,7 +11805,7 @@ function logCrashMarker(kind, err) {
   const message = err instanceof Error ? err.stack ?? err.message : String(err);
   process.stderr.write(`[squadrantd] ${(/* @__PURE__ */ new Date()).toISOString()} ${kind} pid=${process.pid} error=${message}
 `);
-  const stateRoot = join22(homedir13(), ".config", "squadrant", "state");
+  const stateRoot = join26(homedir14(), ".config", "squadrant", "state");
   writeExitMarker(stateRoot, {
     ts: (/* @__PURE__ */ new Date()).toISOString(),
     pid: process.pid,
@@ -10554,7 +11818,7 @@ function logCrashMarker(kind, err) {
 `));
 }
 function isMonorepoCheckout(scriptPath, dirExists = existsSync13) {
-  return dirExists(join22(dirname4(resolve3(scriptPath)), "..", "packages"));
+  return dirExists(join26(dirname5(resolve3(scriptPath)), "..", "packages"));
 }
 function isLinkedWorktree(scriptPath, statFile = (p) => {
   try {
@@ -10563,7 +11827,7 @@ function isLinkedWorktree(scriptPath, statFile = (p) => {
     return void 0;
   }
 }) {
-  const dotGit = join22(dirname4(resolve3(scriptPath)), "..", ".git");
+  const dotGit = join26(dirname5(resolve3(scriptPath)), "..", ".git");
   return statFile(dotGit)?.isFile === true;
 }
 if (process.argv[1] && process.argv[1].endsWith("squadrantd.js")) {