squadrant 0.21.0 → 0.22.0

package/dist/index.js

@@ -156,12 +156,7 @@ function getDefaultConfig() {
       // resolver fallback is the safety net).
       controlChannel: { claude: "on", opencode: "on" },
       crewRouting: {
-        rules: [
-          { tier: "extreme", match: "redesign|architect|rewrite|from scratch|deep reasoning", agent: "claude", model: "opus" },
-          { tier: "hard", match: "refactor|migrate|implement|feature|daemon|control-plane", agent: "claude", model: "sonnet" },
-          { tier: "mobile", match: "mobile|ios|swift|android|kotlin|react native", agent: "codex" },
-          { tier: "daily", match: "typo|rename|bump|docs|comment|lint|format", agent: "opencode" }
-        ]
+        rules: DEFAULT_CREW_ROUTING_RULES.map((r) => ({ ...r }))
       }
     },
     metrics: {
@@ -203,7 +198,7 @@ function saveConfig(config, configPath = DEFAULT_CONFIG_PATH) {
 function resolveHome(p) {
   return p.startsWith("~") ? p.replace("~", os.homedir()) : p;
 }
-var ROUTER_KINDS, GATE_MODES, GATE_POLICIES, THINKING_LEVELS, CONTROL_CHANNEL_MODES, DEFAULT_CONFIG_PATH, CONFIG_DIR, DAEMON_SOCK_PATH;
+var ROUTER_KINDS, GATE_MODES, GATE_POLICIES, THINKING_LEVELS, CONTROL_CHANNEL_MODES, DEFAULT_CONFIG_PATH, CONFIG_DIR, DAEMON_SOCK_PATH, DEFAULT_CREW_ROUTING_RULES;
 var init_config = __esm({
   "packages/shared/dist/config.js"() {
     init_config_io();
@@ -215,6 +210,201 @@ var init_config = __esm({
     DEFAULT_CONFIG_PATH = process.env.SQUADRANT_CONFIG || path2.join(os.homedir(), ".config", "squadrant", "config.json");
     CONFIG_DIR = path2.dirname(DEFAULT_CONFIG_PATH);
     DAEMON_SOCK_PATH = path2.join(CONFIG_DIR, "squadrant.sock");
+    DEFAULT_CREW_ROUTING_RULES = [
+      { tier: "extreme", match: "redesign|architect|rewrite|from scratch|deep reasoning", agent: "claude", model: "opus" },
+      { tier: "hard", match: "refactor|migrate|implement|feature|daemon|control-plane", agent: "claude", model: "sonnet" },
+      { tier: "mobile", match: "mobile|ios|swift|android|kotlin|react native", agent: "codex" },
+      { tier: "daily", match: "typo|rename|bump|docs|comment|lint|format", agent: "opencode" }
+    ];
+  }
+});
+
+// packages/shared/dist/provider-preset.js
+function isProviderPresetId(v2) {
+  return v2 === "a" || v2 === "b" || v2 === "c" || v2 === "d";
+}
+function presetCrewRouting(id) {
+  const base = (tier) => {
+    const found = DEFAULT_CREW_ROUTING_RULES.find((r) => r.tier === tier);
+    return found ? { ...found } : { tier, match: "", agent: "claude" };
+  };
+  const codex = (tier) => ({
+    tier: base(tier).tier,
+    match: base(tier).match,
+    agent: "codex"
+  });
+  switch (id) {
+    case "a":
+      return DEFAULT_CREW_ROUTING_RULES.map((r) => ({ ...r }));
+    case "b":
+      return [
+        { ...base("extreme"), agent: "opencode", model: OPENCODE_MODEL },
+        { ...base("hard"), agent: "opencode", model: OPENCODE_MODEL },
+        codex("mobile"),
+        { ...base("daily"), agent: "opencode", model: OPENCODE_MODEL }
+      ];
+    case "c":
+      return [
+        { ...base("extreme"), agent: "claude", backend: "proxy", model: ROUTER_PRESET_MODEL },
+        { ...base("hard"), agent: "claude", backend: "proxy", model: ROUTER_PRESET_MODEL },
+        codex("mobile"),
+        { ...base("daily"), agent: "opencode", model: OPENCODE_MODEL }
+      ];
+    case "d":
+      return ["extreme", "hard", "mobile", "daily"].map(codex);
+  }
+}
+function providerPresetDefaults(id, router) {
+  switch (id) {
+    case "a":
+      return {
+        roles: {
+          command: { agent: "claude", model: "opus" },
+          captain: { agent: "claude", model: "opus" },
+          crew: { agent: "claude", model: "sonnet" },
+          exploration: { agent: "claude", model: "haiku" },
+          side: { agent: "claude", model: "opus" }
+        },
+        permissions: { command: "auto", captain: "auto", crew: "auto" },
+        crewRouting: { rules: presetCrewRouting("a") }
+      };
+    case "b": {
+      const opencode = { agent: "opencode", model: OPENCODE_MODEL };
+      return {
+        roles: {
+          command: { ...opencode },
+          captain: { ...opencode },
+          crew: { ...opencode },
+          exploration: { ...opencode },
+          side: { ...opencode }
+        },
+        permissions: { command: "auto", captain: "auto", crew: "auto" },
+        crewRouting: { rules: presetCrewRouting("b") }
+      };
+    }
+    case "c": {
+      if (!router) {
+        throw new Error("preset C (claude harness + router backend) requires a router config \u2014 set defaults.router first");
+      }
+      const routed = { agent: "claude", backend: "proxy", model: ROUTER_PRESET_MODEL };
+      return {
+        roles: {
+          command: { ...routed },
+          captain: { ...routed },
+          crew: { ...routed },
+          exploration: { ...routed },
+          side: { ...routed }
+        },
+        // Auto mode's classifier is hardcoded to Sonnet 5 and fails closed on a
+        // router upstream — every claude session must use a manual mode so the
+        // U7 gate owns the prompt.
+        permissions: { command: "default", captain: "default", crew: "default" },
+        crewRouting: { rules: presetCrewRouting("c") },
+        router,
+        gate: { mode: "on" }
+      };
+    }
+    case "d": {
+      const codex = { agent: "codex" };
+      return {
+        roles: {
+          command: { ...codex },
+          captain: { ...codex },
+          crew: { ...codex },
+          exploration: { ...codex },
+          side: { ...codex }
+        },
+        permissions: {},
+        crewRouting: { rules: presetCrewRouting("d") }
+      };
+    }
+  }
+}
+function detectProviderPresetId(config) {
+  const crew = config.defaults?.roles?.crew;
+  if (crew?.agent === "opencode")
+    return "b";
+  if (crew?.agent === "codex")
+    return "d";
+  if (crew?.backend && crew.backend !== "native")
+    return "c";
+  return "a";
+}
+function applyProviderPreset(config, id, opts) {
+  const preset = providerPresetDefaults(id, opts.router);
+  const next = structuredClone(config);
+  const changes = [];
+  if (opts.overwrite) {
+    next.defaults.roles = { ...preset.roles };
+    changes.push("defaults.roles");
+  } else if (next.defaults.roles === void 0) {
+    next.defaults.roles = { ...preset.roles };
+    changes.push("defaults.roles");
+  }
+  if (opts.overwrite) {
+    next.defaults.crewRouting = { rules: preset.crewRouting.rules.map((r) => ({ ...r })) };
+    changes.push("defaults.crewRouting");
+  } else if (next.defaults.crewRouting === void 0) {
+    next.defaults.crewRouting = { rules: preset.crewRouting.rules.map((r) => ({ ...r })) };
+    changes.push("defaults.crewRouting");
+  }
+  const existingPerms = next.defaults.permissions ?? {};
+  if (opts.overwrite) {
+    next.defaults.permissions = { ...existingPerms, ...preset.permissions };
+    if (Object.keys(preset.permissions).length > 0)
+      changes.push("defaults.permissions");
+  } else if (next.defaults.permissions === void 0 && Object.keys(preset.permissions).length > 0) {
+    next.defaults.permissions = { ...preset.permissions };
+    changes.push("defaults.permissions");
+  }
+  if (preset.router) {
+    if (opts.overwrite || next.defaults.router === void 0) {
+      next.defaults.router = structuredClone(preset.router);
+      changes.push("defaults.router");
+    }
+  }
+  if (preset.gate) {
+    if (opts.overwrite || next.defaults.gate === void 0) {
+      next.defaults.gate = { ...preset.gate };
+      changes.push("defaults.gate");
+    }
+  }
+  return { config: next, changes };
+}
+var PROVIDER_PRESETS, ROUTER_PRESET_MODEL, DEFAULT_ROUTER_KIND, DEFAULT_ROUTER_BASE_URL, OPENCODE_MODEL;
+var init_provider_preset = __esm({
+  "packages/shared/dist/provider-preset.js"() {
+    init_config();
+    PROVIDER_PRESETS = [
+      {
+        id: "a",
+        label: "Claude Code (Pro/Max)",
+        summary: "Claude harness on your subscription/API key. Real auto mode.",
+        requiresAnthropic: true
+      },
+      {
+        id: "b",
+        label: "opencode (no Anthropic subscription)",
+        summary: "All roles run on the opencode harness. Auto mode is model-agnostic.",
+        requiresAnthropic: false
+      },
+      {
+        id: "c",
+        label: "Claude harness + router backend (advanced)",
+        summary: "Claude harness against a router upstream. The U7 gate replaces auto mode.",
+        requiresAnthropic: false
+      },
+      {
+        id: "d",
+        label: "Codex (ChatGPT Pro)",
+        summary: "All roles run on the codex harness.",
+        requiresAnthropic: false
+      }
+    ];
+    ROUTER_PRESET_MODEL = "deepseek-v4.1-flash";
+    DEFAULT_ROUTER_KIND = "opencode-go";
+    DEFAULT_ROUTER_BASE_URL = "https://opencode.ai/zen/go";
+    OPENCODE_MODEL = "opencode-go/deepseek-v4.1-flash";
   }
 });
 
@@ -1465,11 +1655,16 @@ __export(dist_exports, {
   CREW_SKILLS: () => CREW_SKILLS,
   DAEMON_SOCK_PATH: () => DAEMON_SOCK_PATH,
   DEFAULT_CONFIG_PATH: () => DEFAULT_CONFIG_PATH,
+  DEFAULT_CREW_ROUTING_RULES: () => DEFAULT_CREW_ROUTING_RULES,
   DEFAULT_NOTIFY: () => DEFAULT_NOTIFY,
+  DEFAULT_ROUTER_BASE_URL: () => DEFAULT_ROUTER_BASE_URL,
+  DEFAULT_ROUTER_KIND: () => DEFAULT_ROUTER_KIND,
   GATE_MODES: () => GATE_MODES,
   GATE_POLICIES: () => GATE_POLICIES,
   MANAGED_TARGETS: () => MANAGED_TARGETS,
+  PROVIDER_PRESETS: () => PROVIDER_PRESETS,
   ROUTER_KINDS: () => ROUTER_KINDS,
+  ROUTER_PRESET_MODEL: () => ROUTER_PRESET_MODEL,
   SAFE_KINDS: () => SAFE_KINDS,
   SOCKET_CONTROL_MODE_PATH: () => SOCKET_CONTROL_MODE_PATH,
   SPOKE_SUBDIRS: () => SPOKE_SUBDIRS,
@@ -1478,6 +1673,7 @@ __export(dist_exports, {
   THINKING_LEVELS: () => THINKING_LEVELS,
   UPDATE_CHECK_STATE_PATH: () => UPDATE_CHECK_STATE_PATH,
   addWorktree: () => addWorktree,
+  applyProviderPreset: () => applyProviderPreset,
   applySafeFixes: () => applySafeFixes,
   captainSessionName: () => captainSessionName,
   checkForUpdate: () => checkForUpdate,
@@ -1493,6 +1689,7 @@ __export(dist_exports, {
   defaultStatePath: () => defaultStatePath,
   detectDrift: () => detectDrift,
   detectInstallManager: () => detectInstallManager,
+  detectProviderPresetId: () => detectProviderPresetId,
   ensureCmuxAutoConfig: () => ensureCmuxAutoConfig,
   ensureDirSync: () => ensureDirSync,
   ensureRuntimeSynced: () => ensureRuntimeSynced,
@@ -1511,6 +1708,7 @@ __export(dist_exports, {
   isGateMode: () => isGateMode,
   isGatePolicy: () => isGatePolicy,
   isNewerVersion: () => isNewerVersion,
+  isProviderPresetId: () => isProviderPresetId,
   isQuieter: () => isQuieter,
   isRouterKind: () => isRouterKind,
   isThinkingLevel: () => isThinkingLevel,
@@ -1527,6 +1725,7 @@ __export(dist_exports, {
   parseThinkingLevel: () => parseThinkingLevel,
   probeCmuxDaemonDirect: () => probeCmuxDaemonDirect,
   projectConfigPath: () => projectConfigPath,
+  providerPresetDefaults: () => providerPresetDefaults,
   readConfigFileSync: () => readConfigFileSync,
   readDailyLog: () => readDailyLog,
   readProjectLevelSource: () => readProjectLevelSource,
@@ -1556,6 +1755,7 @@ __export(dist_exports, {
 var init_dist = __esm({
   "packages/shared/dist/index.js"() {
     init_config();
+    init_provider_preset();
     init_project_config();
     init_effort();
     init_router_model();
@@ -2793,8 +2993,8 @@ function reconcileLiveness(prev, next) {
   if (!prev)
     return next;
   if (next.source === "scan") {
-    const pidAlive = next.lastSeenAt >= prev.lastSeenAt ? next.pidAlive : prev.pidAlive;
-    return { ...prev, pidAlive, lastSeenAt: Math.max(prev.lastSeenAt, next.lastSeenAt) };
+    const pidAlive2 = next.lastSeenAt >= prev.lastSeenAt ? next.pidAlive : prev.pidAlive;
+    return { ...prev, pidAlive: pidAlive2, lastSeenAt: Math.max(prev.lastSeenAt, next.lastSeenAt) };
   }
   if (next.startedAt >= prev.startedAt || next.lastState === "end")
     return next;
@@ -3540,6 +3740,68 @@ function createDirectSurfaceLivenessProbe(cmux2, getCaptainTitle) {
     }
   };
 }
+function hasModalOptionList(screen) {
+  if (!screen)
+    return false;
+  const lines = screen.split(/\r?\n/);
+  let bottomHR = -1;
+  let topHR = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (HR_RE.test(lines[i])) {
+      if (bottomHR === -1)
+        bottomHR = i;
+      else {
+        topHR = i;
+        break;
+      }
+    }
+  }
+  if (topHR === -1)
+    return false;
+  return lines.slice(topHR + 1, bottomHR).some((l) => /^\s*\d+\.\s/.test(l));
+}
+function classifyCaptainPane(screen, opts = {}) {
+  if (screen == null || screen.trim() === "")
+    return { status: "unreadable" };
+  if (hasModalOptionList(screen))
+    return { status: "locked" };
+  if (WORKING_RE.test(screen))
+    return { status: "mid-turn" };
+  const idleAfterMs = opts.idleAfterMs ?? 0;
+  const stale = opts.outputAgoMs !== void 0 && opts.outputAgoMs >= idleAfterMs;
+  return stale ? { status: "no-session" } : { status: "mid-turn" };
+}
+function screenHash(screen) {
+  let h = 2166136261;
+  for (let i = 0; i < screen.length; i++) {
+    h ^= screen.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
+function createCaptainPaneReader(cmux2, getCaptainTitle, opts = {}) {
+  const idleAfterMs = opts.idleAfterMs ?? PANE_IDLE_AFTER_MS;
+  return async (project) => {
+    try {
+      const wsId = await cmux2.findWorkspaceId(getCaptainTitle(project));
+      if (!wsId)
+        return { status: "no-session" };
+      const surfaces = await cmux2.listSurfaces(wsId);
+      const want = getCaptainTitle(project);
+      const pane = surfaces.find((s) => s.title === want) ?? surfaces[0];
+      if (!pane)
+        return { status: "no-session" };
+      const screen = await cmux2.readPaneScreen(pane);
+      if (screen == null)
+        return { status: "unreadable" };
+      const outputAgoMs = opts.noteScreen?.(project, screenHash(screen));
+      return classifyCaptainPane(screen, { outputAgoMs, idleAfterMs });
+    } catch (e) {
+      opts.log?.(`captain pane read failed project=${project}: ${e.message}`);
+      return { status: "unreadable" };
+    }
+  };
+}
 function createDirectCrewPaneReader(cmux2, getCaptainTitle) {
   return async (rec) => {
     try {
@@ -3562,11 +3824,14 @@ function createDirectCrewPaneReader(cmux2, getCaptainTitle) {
     }
   };
 }
-var TAIL_LINES;
+var TAIL_LINES, HR_RE, WORKING_RE, PANE_IDLE_AFTER_MS;
 var init_crew_pane_reader = __esm({
   "packages/core/dist/crew-pane-reader.js"() {
     init_dist();
     TAIL_LINES = 25;
+    HR_RE = /^\s*─{10,}\s*$/;
+    WORKING_RE = /esc to interrupt|\btokens?\b.*\b(used|left)\b|↓\s*[\d.]+\s*k?\s*tokens?\b|\(\d+m?\s*\d+s\b/i;
+    PANE_IDLE_AFTER_MS = 10 * 6e4;
   }
 });
 
@@ -4237,6 +4502,11 @@ function assertBackendUsable(o) {
 function shouldBuildRouterService(router, isVitest) {
   return !!router && !isVitest;
 }
+function claudeEnvShadowsRouter(claudeEnv) {
+  if (!claudeEnv)
+    return [];
+  return Object.keys(claudeEnv).filter((key) => key.startsWith("ANTHROPIC_"));
+}
 var init_router_resolution = __esm({
   "packages/core/dist/router-resolution.js"() {
     init_dist();
@@ -4263,6 +4533,14 @@ function buildRouterEnv(creds, model) {
     env.ANTHROPIC_MODEL = model;
   return env;
 }
+function mergeClaudeEnvRouterSettings(routerEnv, claudeEnv) {
+  const merged = { ...routerEnv };
+  for (const [key, value] of Object.entries(claudeEnv ?? {})) {
+    if (!key.startsWith("ANTHROPIC_"))
+      merged[key] = value;
+  }
+  return merged;
+}
 function formatCustomHeaders(headers) {
   const entries = Object.entries(headers ?? {});
   if (entries.length === 0)
@@ -4576,10 +4854,18 @@ async function runCrewSpawn(input, config, deps) {
   if (agentName === "claude") {
     let routerEnv = {};
     if (backend !== "native") {
+      if (!deps.writeRouterSettings) {
+        throw new Error(`backend '${backend}' requires a per-spawn --settings writer to outrank defaults.claudeEnv, but the spawn path has none \u2014 refusing to launch a routed session that would silently bypass the router shim`);
+      }
       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);
+      const shadowed = claudeEnvShadowsRouter(config.defaults.claudeEnv);
+      if (shadowed.length > 0) {
+        process.stderr.write(`\u26A0\uFE0F  backend '${backend}' selected but defaults.claudeEnv sets ${shadowed.join(", ")} \u2014 these would shadow the router shim. Overriding via a per-spawn --settings env block (outranks ~/.claude/settings.json).
+`);
+      }
     }
     ensureSocksDir();
     const messagingSocketPath = path9.join(CC_SOCKS_DIR, `squadrant-${randomUUID3()}.sock`);
@@ -4592,6 +4878,12 @@ async function runCrewSpawn(input, config, deps) {
       name,
       messagingSocketPath
     });
+    const routerSettingsPath = Object.keys(routerEnv).length > 0 ? deps.writeRouterSettings({
+      stateRoot: STATE_ROOT,
+      project: input.project,
+      taskId: rec.id,
+      env: mergeClaudeEnvRouterSettings(routerEnv, config.defaults.claudeEnv)
+    }) : void 0;
     let hooksInstalled = false;
     try {
       deps.writeSettingsLocal(spawnCwd);
@@ -4607,18 +4899,25 @@ async function runCrewSpawn(input, config, deps) {
       messagingSocketPath,
       // Permission mode is config-driven so squadrant can default crews to 'auto'
       // or keep the semi-automatic 'acceptEdits' gate. Falls back to 'acceptEdits'.
-      permissionMode: config.defaults.permissions?.crew ?? "acceptEdits",
+      // #772: a router-backed crew MUST use 'default' — 'auto' makes the built-in
+      // Sonnet-5 classifier own PermissionRequest and the gate yields, which is
+      // exactly the fail-closed dead end U7 exists to fix. The rubric owns the
+      // permission mode for a routed spawn; the operator's config cannot override
+      // it back into the broken path.
+      permissionMode: backend !== "native" ? "default" : config.defaults.permissions?.crew ?? "acceptEdits",
       // #708: self-describing name so ListAgents/the registry can tell this
       // crew apart from an unrelated session instead of an auto-derived cwd
       // basename (only the claude driver reads this — other agents ignore it).
       sessionName: crewSessionName(input.project, name),
       ...crewModel ? { model: crewModel } : {},
-      ...crewThinking ? { thinking: crewThinking } : {}
+      ...crewThinking ? { thinking: crewThinking } : {},
+      ...routerSettingsPath ? { settingsPath: routerSettingsPath } : {}
     });
     const direction2 = input.direction ?? "tab";
     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}`;
+    const gateEnv = backend !== "native" ? " SQUADRANT_GATE=on" : "";
+    const envPrefix = `SQUADRANT_CREW_TASK_ID=${rec.id} SQUADRANT_CREW_PROJECT=${input.project}${gateEnv}`;
     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) ?? "";
@@ -5397,8 +5696,9 @@ function createDelivery(ctx, daemonCmux, isSurfaceAlive) {
               if (mode !== "off")
                 throw new DeferDelivery(null, "no-channel");
             }
+            const paneOpts = { ...sendOpts, agent };
             try {
-              return await cmux2.send(surface, text, sendOpts);
+              return await cmux2.send(surface, text, paneOpts);
             } catch (e) {
               if (!(e instanceof DeferDelivery) || e.reason !== "probe-failed")
                 throw e;
@@ -5410,7 +5710,7 @@ function createDelivery(ctx, daemonCmux, isSurfaceAlive) {
               }
               log(`delivery project=${project}: probe-failed on ${surface.workspaceId}/${surface.surfaceId} \u2014 re-resolved to ${next.workspaceId}/${next.surfaceId}, retrying`);
               surface = next;
-              return cmux2.send(next, text, sendOpts);
+              return cmux2.send(next, text, paneOpts);
             }
           });
           if ("delivered" in result) {
@@ -6341,16 +6641,26 @@ function createRunCommand(cliBin) {
     }
   };
 }
+function captainAliveStateFromHealth(rows, project) {
+  const row = rows.find((h) => h.kind === "captain" && h.project === project);
+  if (!row)
+    return "unknown";
+  if (row.state === "alive")
+    return "alive";
+  if (row.state === "gone" || row.state === "stopped")
+    return "dead";
+  return "unknown";
+}
 function isCaptainAliveFromHealth(rows, project) {
-  return rows.some((h) => h.kind === "captain" && h.project === project && h.state === "alive");
+  return captainAliveStateFromHealth(rows, project) === "alive";
 }
 function createIsCaptainAlive(sock) {
   return async (project) => {
     try {
       const health = await sendRequest(sock, { kind: "health", project }, 5e3);
-      return isCaptainAliveFromHealth(health ?? [], project);
+      return captainAliveStateFromHealth(health ?? [], project);
     } catch {
-      return false;
+      return "unknown";
     }
   };
 }
@@ -6387,16 +6697,19 @@ function createEnsureCaptainAlive(deps) {
   const now = deps.now ?? (() => Date.now());
   const inFlight = /* @__PURE__ */ new Map();
   async function run(project) {
-    if (await deps.isAlive(project))
+    const first = await deps.isAlive(project);
+    if (first === "alive")
       return "alive";
     await deps.launch(project);
     const deadline = now() + warmupTimeoutMs;
+    let last = first;
     while (now() < deadline) {
-      if (await deps.isAlive(project))
+      last = await deps.isAlive(project);
+      if (last === "alive")
         return "launched";
       await sleep3(pollMs);
     }
-    return "timeout";
+    return last === "dead" ? "timeout" : "unknown";
   }
   return function ensure(project) {
     const existing = inFlight.get(project);
@@ -6451,6 +6764,26 @@ ${ev.question}`;
 function formatInbound(text) {
   return `\u{1F4E9} [from Telegram] ${text}`;
 }
+function mediaKind(m) {
+  for (const [field, name] of MEDIA_KINDS) {
+    if (m[field] !== void 0)
+      return name;
+  }
+  return void 0;
+}
+function mediaMarker(kind) {
+  return `[${kind} attached - not forwarded]`;
+}
+function inboundBody(text, kind) {
+  if (kind === void 0)
+    return text ?? "";
+  const marker = mediaMarker(kind);
+  return text ? `${text}
+${marker}` : marker;
+}
+function formatMediaReceipt(kind, hasCaption) {
+  return hasCaption ? `\u{1F4CE} ${kind} not forwarded \u2014 your caption reached the captain` : `\u{1F4CE} ${kind} not forwarded \u2014 the captain was told it arrived, nothing else was sent`;
+}
 function formatUsageLine(u) {
   const reqs = u.requests === 1 ? "1 req" : `${u.requests} reqs`;
   const named = Object.keys(u.models).filter((m) => m !== "unknown").sort((a, b) => u.models[b].costUsd - u.models[a].costUsd);
@@ -6462,8 +6795,19 @@ function maskToken(token) {
     return token;
   return "*".repeat(token.length - 4) + token.slice(-4);
 }
+var MEDIA_KINDS;
 var init_format = __esm({
   "packages/core/dist/telegram/format.js"() {
+    MEDIA_KINDS = [
+      ["photo", "photo"],
+      ["voice", "voice message"],
+      ["video_note", "video message"],
+      ["video", "video"],
+      ["audio", "audio file"],
+      ["document", "document"],
+      ["animation", "animation"],
+      ["sticker", "sticker"]
+    ];
   }
 });
 
@@ -6486,6 +6830,8 @@ function loadState(stateRoot) {
     };
     if (typeof data.lastUserId === "number")
       result.lastUserId = data.lastUserId;
+    if (data.pending && Object.keys(data.pending).length > 0)
+      result.pending = data.pending;
     return result;
   } catch {
     return { offset: 0, topics: {}, notify: {} };
@@ -6499,6 +6845,19 @@ function setTopic(stateRoot, project, topicId, scope = "project") {
   s.topics[topicKey(project, scope)] = topicId;
   saveState(stateRoot, s);
 }
+function pruneTopics(stateRoot, keep) {
+  const s = loadState(stateRoot);
+  const removed = Object.keys(s.topics).filter((key) => {
+    const sep3 = key.indexOf("::");
+    return !keep(sep3 === -1 ? key : key.slice(0, sep3));
+  });
+  if (removed.length === 0)
+    return [];
+  for (const key of removed)
+    delete s.topics[key];
+  saveState(stateRoot, s);
+  return removed;
+}
 function isNotifyActive(stateRoot, project) {
   return loadState(stateRoot).notify[project] === true;
 }
@@ -6512,6 +6871,42 @@ function setNotify(stateRoot, project, active) {
   s.notify[project] = active;
   saveState(stateRoot, s);
 }
+function loadPending(stateRoot) {
+  return loadState(stateRoot).pending ?? {};
+}
+function setPending(stateRoot, project, p) {
+  const s = loadState(stateRoot);
+  s.pending = { ...s.pending ?? {}, [project]: p };
+  saveState(stateRoot, s);
+}
+function clearPending(stateRoot, project) {
+  const s = loadState(stateRoot);
+  if (!s.pending || !(project in s.pending))
+    return;
+  delete s.pending[project];
+  if (Object.keys(s.pending).length === 0)
+    delete s.pending;
+  saveState(stateRoot, s);
+}
+function markPendingWarned(stateRoot, project, at) {
+  const s = loadState(stateRoot);
+  const p = s.pending?.[project];
+  if (!p)
+    return;
+  s.pending[project] = { ...p, warnedAt: at };
+  saveState(stateRoot, s);
+}
+function notePaneScreen(stateRoot, project, hash, at) {
+  const s = loadState(stateRoot);
+  const p = s.pending?.[project];
+  if (!p)
+    return void 0;
+  if (p.paneHash === hash && p.paneChangedAt !== void 0)
+    return at - p.paneChangedAt;
+  s.pending[project] = { ...p, paneHash: hash, paneChangedAt: at };
+  saveState(stateRoot, s);
+  return void 0;
+}
 function findProjectByThread(stateRoot, threadId) {
   const s = loadState(stateRoot);
   for (const [key, id] of Object.entries(s.topics)) {
@@ -6534,17 +6929,18 @@ var init_state = __esm({
 function createTelegramClient(opts) {
   const fetchImpl = opts.fetch ?? fetch;
   const base = `https://api.telegram.org/bot${opts.token}`;
-  async function call(method, body) {
+  async function call(method, body, signal) {
     const res = await fetchImpl(`${base}/${method}`, {
       method: "POST",
       headers: { "content-type": "application/json" },
-      body: JSON.stringify(body)
+      body: JSON.stringify(body),
+      ...signal ? { signal } : {}
     });
     const json = await res.json();
     if (!res.ok || !json.ok) {
       const code = json.error_code ?? res.status;
       const desc = json.description ?? "unknown error";
-      throw new Error(`telegram ${method} failed (${code}): ${desc}`);
+      throw new TelegramApiError(code, `telegram ${method} failed (${code}): ${desc}`, json.parameters?.retry_after);
     }
     return json.result;
   }
@@ -6553,8 +6949,8 @@ function createTelegramClient(opts) {
       const r = await call("getMe", {});
       return { id: r.id, username: r.username };
     },
-    getUpdates(offset, timeoutSec = 50) {
-      return call("getUpdates", { offset, timeout: timeoutSec });
+    getUpdates(offset, timeoutSec = 50, signal) {
+      return call("getUpdates", { offset, timeout: timeoutSec }, signal);
     },
     async sendMessage(chatId, threadId, text, replyMarkup) {
       const body = { chat_id: chatId, text };
@@ -6577,6 +6973,9 @@ function createTelegramClient(opts) {
       const r = await call("createForumTopic", { chat_id: chatId, name });
       return r.message_thread_id;
     },
+    async deleteForumTopic(chatId, threadId) {
+      await call("deleteForumTopic", { chat_id: chatId, message_thread_id: threadId });
+    },
     async setMyCommands(commands) {
       await call("setMyCommands", { commands });
     },
@@ -6585,11 +6984,241 @@ function createTelegramClient(opts) {
       if (threadId !== void 0)
         body.message_thread_id = threadId;
       await call("sendChatAction", body);
+    },
+    async setMessageReaction(chatId, messageId, emoji) {
+      await call("setMessageReaction", {
+        chat_id: chatId,
+        message_id: messageId,
+        reaction: [{ type: "emoji", emoji }]
+      });
     }
   };
 }
+var TelegramApiError;
 var init_client = __esm({
   "packages/core/dist/telegram/client.js"() {
+    TelegramApiError = class extends Error {
+      code;
+      retryAfterSec;
+      constructor(code, message, retryAfterSec) {
+        super(message);
+        this.code = code;
+        this.retryAfterSec = retryAfterSec;
+        this.name = "TelegramApiError";
+      }
+    };
+  }
+});
+
+// packages/core/dist/telegram/inbound-lifecycle.js
+function defaultSchedule(fn, ms) {
+  const t = setTimeout(fn, ms);
+  t.unref?.();
+  return () => clearTimeout(t);
+}
+function formatWatchdogWarning(project, read, minutes) {
+  const head = `\u23F1\uFE0F [${project}] no reply for ${minutes} minutes`;
+  switch (read.status) {
+    case "locked":
+      return `${head} \u2014 the captain is LOCKED on a prompt, waiting for a human. Answer it in the pane (or with \`squadrant crew answer\`) and it will continue.`;
+    case "mid-turn":
+      return `${head} \u2014 the captain is still working (a turn is in flight), just slow. No action needed yet.`;
+    case "no-session":
+      return `${head} \u2014 the captain looks GONE (no live session in its pane). Run \`squadrant launch ${project}\`.`;
+    case "unreadable":
+      return `${head} \u2014 couldn't read the captain's pane to classify it. Check it manually.`;
+  }
+}
+function createInboundLifecycle(opts) {
+  const { stateRoot, cfg, sendChatAction, sendReply, readPane, log } = opts;
+  const now = opts.now ?? Date.now;
+  const schedule = opts.schedule ?? defaultSchedule;
+  const typingMs = opts.typingMs ?? TYPING_KEEPALIVE_MS;
+  const watchdogMs = opts.watchdogMs ?? WATCHDOG_MS;
+  const warnAtMs = watchdogMs + (opts.watchdogMs === void 0 ? WATCHDOG_GRACE_MS : 0);
+  const active = /* @__PURE__ */ new Set();
+  let running = false;
+  function issue(project, threadId) {
+    void Promise.resolve(sendChatAction(cfg.supergroupId, threadId, "typing")).catch((e) => log(`telegram typing keep-alive failed project=${project}: ${e.message}`));
+  }
+  function drain(project) {
+    active.add(project);
+    const tick = () => {
+      if (!running || !active.has(project))
+        return;
+      const p = loadPending(stateRoot)[project];
+      if (!p) {
+        active.delete(project);
+        return;
+      }
+      if (now() - p.startedAt >= warnAtMs && p.warnedAt === void 0) {
+        void warn(project, p.threadId);
+      }
+      issue(project, p.threadId);
+      schedule(tick, typingMs);
+    };
+    schedule(tick, typingMs);
+  }
+  async function warn(project, threadId) {
+    markPendingWarned(stateRoot, project, now());
+    let read = { status: "unreadable" };
+    try {
+      if (readPane)
+        read = await readPane(project);
+    } catch (e) {
+      log(`telegram watchdog pane read failed project=${project}: ${e.message}`);
+    }
+    try {
+      await sendReply(threadId, formatWatchdogWarning(project, read, Math.floor(watchdogMs / 6e4)));
+    } catch (e) {
+      log(`telegram watchdog warning failed project=${project}: ${e.message}`);
+    }
+  }
+  return {
+    start() {
+      running = true;
+      for (const [project, p] of Object.entries(loadPending(stateRoot))) {
+        void (async () => {
+          let read = { status: "unreadable" };
+          try {
+            if (readPane)
+              read = await readPane(project);
+          } catch (e) {
+            log(`telegram resume pane read failed project=${project}: ${e.message}`);
+          }
+          const still = loadPending(stateRoot)[project];
+          if (!still || still.startedAt !== p.startedAt)
+            return;
+          if (read.status === "no-session") {
+            clearPending(stateRoot, project);
+            log(`telegram typing lifecycle cleared for ${project}: captain session gone on boot`);
+            return;
+          }
+          log(`telegram typing lifecycle resumed for ${project} (thread ${p.threadId})`);
+          issue(project, p.threadId);
+          drain(project);
+        })();
+      }
+    },
+    stop() {
+      running = false;
+      active.clear();
+    },
+    begin(project, threadId) {
+      setPending(stateRoot, project, { threadId, startedAt: now() });
+      issue(project, threadId);
+      if (running && !active.has(project))
+        drain(project);
+    },
+    pending() {
+      return loadPending(stateRoot);
+    }
+  };
+}
+var TYPING_KEEPALIVE_MS, WATCHDOG_MS, WATCHDOG_GRACE_MS;
+var init_inbound_lifecycle = __esm({
+  "packages/core/dist/telegram/inbound-lifecycle.js"() {
+    init_state();
+    TYPING_KEEPALIVE_MS = 4e3;
+    WATCHDOG_MS = 15 * 6e4;
+    WATCHDOG_GRACE_MS = 1;
+  }
+});
+
+// packages/core/dist/telegram/notify.js
+function runTelegramStatus(opts) {
+  const tg = opts.config.telegram;
+  const env = opts.env ?? process.env;
+  const tokenSet = !!(tg?.botToken ?? env.TELEGRAM_BOT_TOKEN);
+  const links = Object.entries(loadState(opts.stateRoot).topics).map(([key, topicId]) => {
+    const sep3 = key.indexOf("::");
+    return { project: key.slice(0, sep3), scope: key.slice(sep3 + 2), topicId };
+  });
+  return { tokenSet, supergroupId: tg?.supergroupId ?? null, links };
+}
+function runTelegramNotifySet(opts) {
+  setNotify(opts.stateRoot, opts.project, opts.active);
+}
+function runTelegramNotifyPref(args) {
+  const { project, dimension, value, root } = args;
+  if (dimension === "crew") {
+    if (!["all", "alert_only", "done_only", "none"].includes(value))
+      return { ok: false, message: "crew must be all|alert_only|done_only|none" };
+    saveProjectOverride(project, { telegram: { notify: { crew: value } } }, root);
+    return { ok: true };
+  }
+  if (value !== "on" && value !== "off")
+    return { ok: false, message: "cap must be on|off" };
+  saveProjectOverride(project, { telegram: { notify: { cap: value === "on" } } }, root);
+  return { ok: true };
+}
+function runTelegramNotifyStatus(opts) {
+  const s = loadState(opts.stateRoot);
+  const projects = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(s.topics)) {
+    const sep3 = key.indexOf("::");
+    projects.add(sep3 === -1 ? key : key.slice(0, sep3));
+  }
+  for (const p of Object.keys(s.notify))
+    projects.add(p);
+  return [...projects].map((project) => ({ project, active: s.notify[project] === true }));
+}
+function capAllowed(project, globalNotify, root) {
+  return resolveNotify(globalNotify, loadProjectOverride(project, root)).cap;
+}
+function confirmationText(project, before, after, dim) {
+  if (dim === "active")
+    return `\u{1F515} ${project} \u2014 all notifications muted here. Unmute: squadrant telegram notify ${project} on`;
+  if (dim === "cap")
+    return `\u{1F515} ${project} \u2014 captain messages muted here. Re-enable: squadrant telegram notify ${project} cap on`;
+  return `\u{1F515} ${project} \u2014 crew notifications now '${after.crew}' (was '${before.crew}'). Re-enable: squadrant telegram notify ${project} crew ${before.crew}`;
+}
+async function runNotifyConfirmation(opts) {
+  const { quieter, dim } = isQuieter(opts.before, opts.after);
+  if (!quieter || dim === null)
+    return false;
+  const topicId = loadState(opts.stateRoot).topics[topicKey(opts.project)];
+  if (topicId === void 0)
+    return false;
+  const text = confirmationText(opts.project, opts.before, opts.after, dim);
+  try {
+    await opts.client.sendMessage(opts.cfg.supergroupId, topicId, text);
+    return true;
+  } catch {
+    console.warn(`[squadrant] mute-confirmation send failed for ${opts.project} \u2014 notification preference was still saved`);
+    return false;
+  }
+}
+async function runTelegramSend(opts) {
+  const topicId = loadState(opts.stateRoot).topics[topicKey(opts.project)];
+  if (topicId === void 0) {
+    throw new Error(`project "${opts.project}" is not linked \u2014 run: squadrant telegram link ${opts.project}`);
+  }
+  await opts.client.sendMessage(opts.cfg.supergroupId, topicId, opts.message);
+  clearPending(opts.stateRoot, opts.project);
+  return { chatId: opts.cfg.supergroupId, topicId };
+}
+async function runTelegramLink(opts) {
+  const existing = loadState(opts.stateRoot).topics[topicKey(opts.project)];
+  if (existing !== void 0)
+    return { topicId: existing, created: false };
+  const topicId = await opts.client.createForumTopic(opts.cfg.supergroupId, topicName(opts.project));
+  const winner = loadState(opts.stateRoot).topics[topicKey(opts.project)];
+  if (winner !== void 0) {
+    try {
+      await opts.client.deleteForumTopic?.(opts.cfg.supergroupId, topicId);
+    } catch {
+    }
+    return { topicId: winner, created: false };
+  }
+  setTopic(opts.stateRoot, opts.project, topicId);
+  return { topicId, created: true };
+}
+var init_notify = __esm({
+  "packages/core/dist/telegram/notify.js"() {
+    init_dist();
+    init_state();
+    init_format();
   }
 });
 
@@ -6677,8 +7306,10 @@ var init_tiers = __esm({
 });
 
 // packages/core/dist/telegram/bridge.js
+import fs11 from "fs";
 import os5 from "os";
 import path12 from "path";
+import crypto2 from "crypto";
 function formatInboundReceipt(project, outcome) {
   if (!outcome)
     return void 0;
@@ -6694,6 +7325,85 @@ function formatInboundReceipt(project, outcome) {
       return void 0;
   }
 }
+function telegramPollLockPath(token) {
+  const hash = crypto2.createHash("sha256").update(token).digest("hex").slice(0, 16);
+  return path12.join(os5.tmpdir(), `squadrant-telegram-poll-${hash}.lock`);
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+function lockIsHeld(file) {
+  let pid;
+  let ageMs;
+  try {
+    const parsed = Number.parseInt(fs11.readFileSync(file, "utf8").trim(), 10);
+    pid = Number.isFinite(parsed) ? parsed : void 0;
+    ageMs = Date.now() - fs11.statSync(file).mtimeMs;
+  } catch {
+    return false;
+  }
+  if (pid !== void 0)
+    return pidAlive(pid);
+  return ageMs < POLL_LOCK_STALE_MS;
+}
+function acquirePollLock(token) {
+  const file = telegramPollLockPath(token);
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const fd = fs11.openSync(file, "wx");
+      fs11.writeSync(fd, String(process.pid));
+      fs11.closeSync(fd);
+      return () => {
+        try {
+          fs11.unlinkSync(file);
+        } catch {
+        }
+      };
+    } catch (e) {
+      if (e.code !== "EEXIST")
+        return null;
+      if (attempt === 0 && !lockIsHeld(file)) {
+        try {
+          fs11.unlinkSync(file);
+        } catch {
+        }
+        continue;
+      }
+      return null;
+    }
+  }
+  return null;
+}
+function defaultSchedule2(fn, ms) {
+  const t = setTimeout(fn, ms);
+  t.unref?.();
+  return () => clearTimeout(t);
+}
+function foreignPollLockHolder(token, selfPid = process.pid) {
+  const file = telegramPollLockPath(token);
+  let pid;
+  try {
+    const parsed = Number.parseInt(fs11.readFileSync(file, "utf8").trim(), 10);
+    if (!Number.isFinite(parsed))
+      return null;
+    pid = parsed;
+  } catch {
+    return null;
+  }
+  if (pid === selfPid)
+    return null;
+  return pidAlive(pid) ? pid : null;
+}
+function pollBackoffMs(err, pollMs) {
+  if (err instanceof TelegramApiError && err.retryAfterSec !== void 0)
+    return err.retryAfterSec * 1e3;
+  return pollMs;
+}
 function parseNotifyPref(text) {
   const parts = text.trim().split(/\s+/);
   if (stripBotMention(parts[0] ?? "").toLowerCase() !== "/notify")
@@ -6720,9 +7430,17 @@ function notifyToggle(text) {
 }
 function createTelegramBridge(opts) {
   const { cfg, stateRoot, client, appendCaptainMessage: appendCaptainMessage2, log, ensureCaptainAlive, runCommand, sendReply } = opts;
+  const lifecycle = opts.lifecycle;
   const configRoot = opts.configRoot ?? path12.join(os5.homedir(), ".config", "squadrant");
   const pollMs = cfg.pollMs ?? 1e3;
+  const schedule = opts.schedule ?? defaultSchedule2;
+  const lockToken = cfg.botToken ?? process.env.TELEGRAM_BOT_TOKEN;
+  let releasePollLock = null;
+  let pollAbort = null;
   let running = false;
+  let pollStopped = false;
+  let selfHealCancel = null;
+  let conflictCount = 0;
   let lastSuccessfulPollAt = null;
   let lastError = null;
   let lastErrorAt = null;
@@ -6732,12 +7450,8 @@ function createTelegramBridge(opts) {
     saveState(stateRoot, s);
   }
   async function sendToTopic(project, text) {
-    let threadId = loadState(stateRoot).topics[topicKey(project)];
-    if (threadId === void 0) {
-      threadId = await client.createForumTopic(cfg.supergroupId, topicName(project));
-      setTopic(stateRoot, project, threadId);
-    }
-    await client.sendMessage(cfg.supergroupId, threadId, text);
+    const { topicId } = await runTelegramLink({ project, cfg, client, stateRoot });
+    await client.sendMessage(cfg.supergroupId, topicId, text);
   }
   async function deliverOutbound(project, ev) {
     const resolved = resolveNotify(cfg.notify, loadProjectOverride(project, configRoot));
@@ -6924,10 +7638,13 @@ ${formatUsageLine(usage2)}`;
     }
     await runChannelCommand(text, fromId, void 0);
   }
-  async function handleProjectTopic(text, threadId, fromId) {
+  async function handleProjectTopic(text, threadId, fromId, messageId, media) {
     const resolved = findProjectByThread(stateRoot, threadId);
-    if (!resolved)
+    if (!resolved) {
+      log(`telegram inbound in unbound topic thread=${threadId} \u2014 no project linked, message dropped`);
+      await reply(threadId, "\u26A0\uFE0F this topic isn't linked to a project \u2014 run: squadrant telegram link <project>");
       return;
+    }
     if (isBareSpawn(text)) {
       if (!isControlEnabled(cfg) || !isAuthorized(fromId, cfg)) {
         await reply(threadId, "\u26D4 not authorized");
@@ -6977,21 +7694,16 @@ ${formatUsageLine(usage2)}`;
       await runChannelCommand(text, fromId, threadId);
       return;
     }
-    void client.sendChatAction(cfg.supergroupId, threadId, "typing").catch((e) => {
-      log(`telegram sendChatAction failed: ${e.message}`);
-    });
+    if (messageId !== void 0) {
+      void Promise.resolve(client.setMessageReaction?.(cfg.supergroupId, messageId, "\u{1F44D}")).catch((e) => log(`telegram stage-1 reaction failed project=${resolved.project}: ${e.message}`));
+    }
     setNotify(stateRoot, resolved.project, true);
     if (ensureCaptainAlive && isControlEnabled(cfg) && isAuthorized(fromId, cfg)) {
-      try {
-        const r = await ensureCaptainAlive(resolved.project);
+      void ensureCaptainAlive(resolved.project).then((r) => {
         if (r === "timeout") {
-          await reply(threadId, `\u274C couldn't reach ${resolved.project} captain \u2014 saved to mailbox, will deliver when you open the workspace.`);
-        } else {
-          await reply(threadId, `\u{1F4E8} delivered to ${resolved.project} captain`);
+          log(`telegram auto-launch: warmup timed out project=${resolved.project} \u2014 delivery verdict (not this probe) decides the receipt`);
         }
-      } catch (e) {
-        log(`telegram auto-launch failed project=${resolved.project}: ${e.message}`);
-      }
+      }).catch((e) => log(`telegram auto-launch failed project=${resolved.project}: ${e.message}`));
     }
     let handled = false;
     let outcome;
@@ -7000,13 +7712,22 @@ ${formatUsageLine(usage2)}`;
       handled = res.handled;
       outcome = res.outcome;
     }
+    const deliveryHeld = outcome?.status === "held";
     if (!handled) {
       await appendCaptainMessage2({ stateRoot, project: resolved.project, text: formatInbound(text), source: "telegram" });
+      outcome = void 0;
     }
     const receipt = formatInboundReceipt(resolved.project, outcome);
     if (receipt && sendReply) {
       await sendReply(threadId, receipt).catch((e) => log(`telegram receipt failed project=${resolved.project}: ${e.message}`));
     }
+    if (media) {
+      await reply(threadId, formatMediaReceipt(media.kind, media.hasCaption));
+    }
+    if (deliveryHeld)
+      return;
+    await reply(threadId, CAPTAIN_RECEIVED_ACK);
+    lifecycle?.begin(resolved.project, threadId);
   }
   async function handleUpdate(u) {
     if (u.callback_query) {
@@ -7014,7 +7735,11 @@ ${formatUsageLine(usage2)}`;
       return;
     }
     const m = u.message;
-    if (!m || m.text === void 0)
+    if (!m)
+      return;
+    const kind = mediaKind(m);
+    const text = m.text ?? m.caption;
+    if (text === void 0 && kind === void 0)
       return;
     if (!cfg.chats.includes(m.chat.id))
       return;
@@ -7028,7 +7753,7 @@ ${formatUsageLine(usage2)}`;
         await reply(threadId, "\u26D4 not authorized");
         return;
       }
-      const task = m.text.trim();
+      const task = (text ?? "").trim();
       if (!task) {
         await reply(threadId, "spawn cancelled \u2014 empty task");
         return;
@@ -7039,39 +7764,122 @@ ${formatUsageLine(usage2)}`;
       return;
     }
     if (m.message_thread_id === void 0) {
+      if (m.text === void 0)
+        return;
       await handleGeneral(m.text, m.from?.id);
       return;
     }
-    await handleProjectTopic(m.text, m.message_thread_id, m.from?.id);
+    await handleProjectTopic(inboundBody(text, kind), m.message_thread_id, m.from?.id, m.message_id, kind === void 0 ? void 0 : { kind, hasCaption: text !== void 0 });
+  }
+  function acquirePollLockOrLog() {
+    if (!lockToken)
+      return true;
+    releasePollLock = acquirePollLock(lockToken);
+    if (releasePollLock)
+      return true;
+    const holder = foreignPollLockHolder(lockToken);
+    log(`telegram inbound poll disabled: another consumer already polls this bot token (single-consumer guard, #830)${holder !== null ? ` \u2014 lock held by pid ${holder}` : ""}`);
+    return false;
+  }
+  function scheduleSelfHeal() {
+    selfHealCancel?.();
+    selfHealCancel = schedule(() => {
+      selfHealCancel = null;
+      if (pollStopped || running)
+        return;
+      if (!acquirePollLockOrLog()) {
+        scheduleSelfHeal();
+        return;
+      }
+      running = true;
+      conflictCount = 0;
+      log("telegram inbound poll re-attempting after a 409 stop (#850)");
+      void pollLoop();
+    }, CONFLICT_409_SELF_HEAL_MS);
   }
   async function pollLoop() {
     while (running) {
+      const ac = new AbortController();
+      pollAbort = ac;
+      let waitMs = pollMs;
       try {
         const offset = loadState(stateRoot).offset;
-        const updates = await client.getUpdates(offset, LONG_POLL_SEC);
+        const updates = await client.getUpdates(offset, LONG_POLL_SEC, ac.signal);
+        conflictCount = 0;
         for (const u of updates) {
           await handleUpdate(u);
           persistOffset(u.update_id + 1);
         }
         lastSuccessfulPollAt = Date.now();
       } catch (e) {
-        lastError = e.message;
+        if (ac.signal.aborted)
+          break;
+        const msg = e.message;
+        lastError = msg;
         lastErrorAt = Date.now();
-        log(`telegram inbound poll failed: ${e.message}`);
+        if (e instanceof TelegramApiError && e.code === 409) {
+          conflictCount += 1;
+          if (conflictCount >= CONFLICT_409_TERMINAL_AFTER) {
+            log(`telegram inbound poll stopped: repeated 409 conflict (another getUpdates consumer holds this token) \u2014 ${msg}`);
+            break;
+          }
+        } else {
+          log(`telegram inbound poll failed: ${msg}`);
+        }
+        waitMs = pollBackoffMs(e, pollMs);
+      } finally {
+        pollAbort = null;
       }
       if (running)
-        await sleep2(pollMs);
+        await sleep2(waitMs);
     }
+    running = false;
+    releasePollLock?.();
+    releasePollLock = null;
+    if (!pollStopped)
+      scheduleSelfHeal();
   }
   return {
     start() {
       if (running)
         return;
+      pollStopped = false;
+      selfHealCancel?.();
+      selfHealCancel = null;
+      if (!acquirePollLockOrLog())
+        return;
+      const known = opts.registeredProjects?.();
+      if (known !== void 0) {
+        try {
+          const removed = pruneTopics(stateRoot, (p) => known.includes(p));
+          if (removed.length > 0)
+            log(`telegram registry pruned ${removed.length} stale topic link(s): ${removed.join(", ")}`);
+        } catch (e) {
+          log(`telegram registry prune failed: ${e.message}`);
+        }
+      }
       running = true;
+      conflictCount = 0;
+      try {
+        lifecycle?.start();
+      } catch (e) {
+        log(`telegram lifecycle start failed: ${e.message}`);
+      }
       void pollLoop();
     },
     stop() {
       running = false;
+      pollStopped = true;
+      selfHealCancel?.();
+      selfHealCancel = null;
+      try {
+        lifecycle?.stop();
+      } catch (e) {
+        log(`telegram lifecycle stop failed: ${e.message}`);
+      }
+      pollAbort?.abort();
+      releasePollLock?.();
+      releasePollLock = null;
     },
     pushLifecycle(project, ev) {
       void deliverOutbound(project, ev).catch((e) => {
@@ -7088,17 +7896,23 @@ ${formatUsageLine(usage2)}`;
     }
   };
 }
-var LONG_POLL_SEC, sleep2, CREW_TIERS, RECOGNIZED_CHANNEL_COMMANDS;
+var CAPTAIN_RECEIVED_ACK, LONG_POLL_SEC, POLL_LOCK_STALE_MS, CONFLICT_409_TERMINAL_AFTER, CONFLICT_409_SELF_HEAL_MS, sleep2, CREW_TIERS, RECOGNIZED_CHANNEL_COMMANDS;
 var init_bridge = __esm({
   "packages/core/dist/telegram/bridge.js"() {
     init_dist();
+    init_client();
     init_auth();
     init_commands();
     init_format();
+    init_notify();
     init_panels();
     init_state();
     init_tiers();
+    CAPTAIN_RECEIVED_ACK = "\u2705 captain received";
     LONG_POLL_SEC = 50;
+    POLL_LOCK_STALE_MS = 2 * 6e4;
+    CONFLICT_409_TERMINAL_AFTER = 3;
+    CONFLICT_409_SELF_HEAL_MS = 5 * 6e4;
     sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
     CREW_TIERS = ["all", "alert_only", "done_only", "none"];
     RECOGNIZED_CHANNEL_COMMANDS = /* @__PURE__ */ new Set(["status", "projects", "crews", "launch", "effort", "spawn"]);
@@ -7143,7 +7957,7 @@ var init_restart_daemon = __esm({
 });
 
 // packages/core/dist/telegram/setup.js
-import fs11 from "fs";
+import fs12 from "fs";
 function resolveSetupGroup(existingSupergroupId, opts) {
   if (existingSupergroupId !== void 0 && !opts.redetect)
     return "reuse";
@@ -7194,130 +8008,42 @@ function writeTelegramConfig(configPath, opts) {
   let config;
   let raw = null;
   try {
-    raw = fs11.readFileSync(configPath, "utf-8");
+    raw = fs12.readFileSync(configPath, "utf-8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       throw new Error(`refusing to overwrite unreadable config at ${configPath}: ${String(err)}`);
-    }
-  }
-  if (raw !== null) {
-    try {
-      config = JSON.parse(raw);
-    } catch (err) {
-      throw new Error(`refusing to overwrite corrupt config at ${configPath}: ${String(err)}`);
-    }
-  } else {
-    config = {};
-  }
-  const prev = config.telegram && typeof config.telegram === "object" ? config.telegram : {};
-  const next = {
-    botToken: opts.token,
-    supergroupId: opts.supergroupId,
-    chats: [opts.supergroupId]
-  };
-  const users = opts.users ?? prev.users;
-  const remoteControl = opts.remoteControl ?? prev.remoteControl;
-  if (users !== void 0)
-    next.users = users;
-  if (remoteControl !== void 0)
-    next.remoteControl = remoteControl;
-  config.telegram = next;
-  writeConfigFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-}
-var init_setup = __esm({
-  "packages/core/dist/telegram/setup.js"() {
-    init_dist();
-    init_state();
-    init_bot_commands();
-    init_restart_daemon();
-  }
-});
-
-// packages/core/dist/telegram/notify.js
-function runTelegramStatus(opts) {
-  const tg = opts.config.telegram;
-  const env = opts.env ?? process.env;
-  const tokenSet = !!(tg?.botToken ?? env.TELEGRAM_BOT_TOKEN);
-  const links = Object.entries(loadState(opts.stateRoot).topics).map(([key, topicId]) => {
-    const sep3 = key.indexOf("::");
-    return { project: key.slice(0, sep3), scope: key.slice(sep3 + 2), topicId };
-  });
-  return { tokenSet, supergroupId: tg?.supergroupId ?? null, links };
-}
-function runTelegramNotifySet(opts) {
-  setNotify(opts.stateRoot, opts.project, opts.active);
-}
-function runTelegramNotifyPref(args) {
-  const { project, dimension, value, root } = args;
-  if (dimension === "crew") {
-    if (!["all", "alert_only", "done_only", "none"].includes(value))
-      return { ok: false, message: "crew must be all|alert_only|done_only|none" };
-    saveProjectOverride(project, { telegram: { notify: { crew: value } } }, root);
-    return { ok: true };
-  }
-  if (value !== "on" && value !== "off")
-    return { ok: false, message: "cap must be on|off" };
-  saveProjectOverride(project, { telegram: { notify: { cap: value === "on" } } }, root);
-  return { ok: true };
-}
-function runTelegramNotifyStatus(opts) {
-  const s = loadState(opts.stateRoot);
-  const projects = /* @__PURE__ */ new Set();
-  for (const key of Object.keys(s.topics)) {
-    const sep3 = key.indexOf("::");
-    projects.add(sep3 === -1 ? key : key.slice(0, sep3));
-  }
-  for (const p of Object.keys(s.notify))
-    projects.add(p);
-  return [...projects].map((project) => ({ project, active: s.notify[project] === true }));
-}
-function capAllowed(project, globalNotify, root) {
-  return resolveNotify(globalNotify, loadProjectOverride(project, root)).cap;
-}
-function confirmationText(project, before, after, dim) {
-  if (dim === "active")
-    return `\u{1F515} ${project} \u2014 all notifications muted here. Unmute: squadrant telegram notify ${project} on`;
-  if (dim === "cap")
-    return `\u{1F515} ${project} \u2014 captain messages muted here. Re-enable: squadrant telegram notify ${project} cap on`;
-  return `\u{1F515} ${project} \u2014 crew notifications now '${after.crew}' (was '${before.crew}'). Re-enable: squadrant telegram notify ${project} crew ${before.crew}`;
-}
-async function runNotifyConfirmation(opts) {
-  const { quieter, dim } = isQuieter(opts.before, opts.after);
-  if (!quieter || dim === null)
-    return false;
-  const topicId = loadState(opts.stateRoot).topics[topicKey(opts.project)];
-  if (topicId === void 0)
-    return false;
-  const text = confirmationText(opts.project, opts.before, opts.after, dim);
-  try {
-    await opts.client.sendMessage(opts.cfg.supergroupId, topicId, text);
-    return true;
-  } catch {
-    console.warn(`[squadrant] mute-confirmation send failed for ${opts.project} \u2014 notification preference was still saved`);
-    return false;
-  }
-}
-async function runTelegramSend(opts) {
-  const topicId = loadState(opts.stateRoot).topics[topicKey(opts.project)];
-  if (topicId === void 0) {
-    throw new Error(`project "${opts.project}" is not linked \u2014 run: squadrant telegram link ${opts.project}`);
+    }
   }
-  await opts.client.sendMessage(opts.cfg.supergroupId, topicId, opts.message);
-  return { chatId: opts.cfg.supergroupId, topicId };
-}
-async function runTelegramLink(opts) {
-  const existing = loadState(opts.stateRoot).topics[topicKey(opts.project)];
-  if (existing !== void 0)
-    return { topicId: existing, created: false };
-  const topicId = await opts.client.createForumTopic(opts.cfg.supergroupId, topicName(opts.project));
-  setTopic(opts.stateRoot, opts.project, topicId);
-  return { topicId, created: true };
+  if (raw !== null) {
+    try {
+      config = JSON.parse(raw);
+    } catch (err) {
+      throw new Error(`refusing to overwrite corrupt config at ${configPath}: ${String(err)}`);
+    }
+  } else {
+    config = {};
+  }
+  const prev = config.telegram && typeof config.telegram === "object" ? config.telegram : {};
+  const next = {
+    botToken: opts.token,
+    supergroupId: opts.supergroupId,
+    chats: [opts.supergroupId]
+  };
+  const users = opts.users ?? prev.users;
+  const remoteControl = opts.remoteControl ?? prev.remoteControl;
+  if (users !== void 0)
+    next.users = users;
+  if (remoteControl !== void 0)
+    next.remoteControl = remoteControl;
+  config.telegram = next;
+  writeConfigFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
 }
-var init_notify = __esm({
-  "packages/core/dist/telegram/notify.js"() {
+var init_setup = __esm({
+  "packages/core/dist/telegram/setup.js"() {
     init_dist();
     init_state();
-    init_format();
+    init_bot_commands();
+    init_restart_daemon();
   }
 });
 
@@ -7332,6 +8058,7 @@ var init_telegram = __esm({
     init_format();
     init_state();
     init_client();
+    init_inbound_lifecycle();
     init_bridge();
     init_setup();
     init_notify();
@@ -7526,6 +8253,26 @@ function writeJson(res, status, body) {
   res.writeHead(status, { "content-type": "application/json" });
   res.end(JSON.stringify(body));
 }
+function pathnameOf(url) {
+  if (!url)
+    return "";
+  const q = url.indexOf("?");
+  return q === -1 ? url : url.slice(0, q);
+}
+function modelsList(ids) {
+  const data = ids.map((id) => ({
+    type: "model",
+    id,
+    display_name: id,
+    created_at: "1970-01-01T00:00:00Z"
+  }));
+  return {
+    data,
+    has_more: false,
+    first_id: ids[0] ?? null,
+    last_id: ids[ids.length - 1] ?? null
+  };
+}
 function buildUpstreamHeaders(req, upstream, stream) {
   const headers = {
     "content-type": "application/json",
@@ -7554,6 +8301,7 @@ function createRouterShim(opts) {
   let lastError;
   let upstreamReachable = true;
   const upstreamUrl = joinUrl(opts.upstream.baseUrl, "/v1/messages");
+  const advertisedModels = new Set(opts.models ?? []);
   function emitUsage(u) {
     try {
       opts.onUsage?.(u);
@@ -7583,6 +8331,8 @@ function createRouterShim(opts) {
     const body = parsed;
     const wantsStream = body.stream === true;
     const model = typeof body.model === "string" ? body.model : void 0;
+    if (model)
+      advertisedModels.add(model);
     const sanitized = sanitizeRequest(body, opts.upstream);
     let upstreamRes;
     try {
@@ -7655,8 +8405,20 @@ function createRouterShim(opts) {
       emitUsage(usage2);
     writeJson(res, upstreamRes.status, upstreamBody);
   }
+  async function handleCountTokens(req, res) {
+    let text;
+    try {
+      text = await readBody(req);
+    } catch {
+      const e = anthropicError(400, "invalid_request_error", "malformed request body");
+      writeJson(res, e.status, e.body);
+      return;
+    }
+    writeJson(res, 200, { input_tokens: Math.max(1, Math.ceil(text.length / 4)) });
+  }
   function handler(req, res) {
-    if (req.method === "POST" && req.url === "/v1/messages") {
+    const path39 = pathnameOf(req.url);
+    if (req.method === "POST" && path39 === "/v1/messages") {
       void handleMessages(req, res).catch((err) => {
         log(`router internal error: ${err instanceof Error ? err.message : String(err)}`);
         if (!res.headersSent) {
@@ -7668,7 +8430,18 @@ function createRouterShim(opts) {
       });
       return;
     }
-    if (req.method === "GET" && req.url === "/healthz") {
+    if (req.method === "POST" && path39 === "/v1/messages/count_tokens") {
+      void handleCountTokens(req, res).catch(() => {
+        if (!res.headersSent)
+          writeJson(res, 502, anthropicError(502, "api_error", "router internal error").body);
+      });
+      return;
+    }
+    if (req.method === "GET" && path39 === "/v1/models") {
+      writeJson(res, 200, modelsList([...advertisedModels]));
+      return;
+    }
+    if (req.method === "GET" && path39 === "/healthz") {
       writeJson(res, 200, { ready: server?.listening === true, upstreamReachable, lastError });
       return;
     }
@@ -7793,12 +8566,17 @@ function createRouterService(router, projects, deps = {}) {
     tokenByProject.set(p, t);
     projectTokens.set(t, p);
   }
+  const models = [
+    ...deps.models ?? [],
+    ...Object.values(router.models ?? {}).map((m) => m.upstream)
+  ];
   const ledger = createUsageLedger();
   const shim = createRouterShim({
     upstream,
     projectTokens,
     port: router.port ?? 0,
     log,
+    models,
     onUsage: (u) => ledger.record(u),
     ...deps.fetch ? { fetch: deps.fetch } : {}
   });
@@ -7861,12 +8639,53 @@ var init_router = __esm({
   }
 });
 
+// packages/core/dist/captain-router.js
+async function prepareCaptainRoute(o) {
+  assertBackendUsable({ backend: o.backend, agent: o.agentName, router: o.config.defaults.router });
+  if (o.backend === "native") {
+    return { backend: "native", model: o.model, permissionMode: o.configuredPermissionMode, env: {} };
+  }
+  if (!o.deps.routerCredentials) {
+    throw new Error(`captain launch: backend '${o.backend}' requires router credentials from the daemon, but this launch path has no credentials provider`);
+  }
+  if (!o.deps.writeRouterSettings) {
+    throw new Error(`captain launch: backend '${o.backend}' requires a per-spawn --settings writer to outrank defaults.claudeEnv, but this launch path has none \u2014 refusing to launch a routed captain that would silently bypass the router shim`);
+  }
+  const model = resolveRouterModel(o.model, o.agentName, o.config.defaults.router);
+  const creds = await o.deps.routerCredentials({ project: o.project, backend: o.backend });
+  const routerEnv = buildRouterEnv(creds, model);
+  const shadowed = claudeEnvShadowsRouter(o.config.defaults.claudeEnv);
+  if (shadowed.length > 0) {
+    o.warn?.(`backend '${o.backend}' selected but defaults.claudeEnv sets ${shadowed.join(", ")} \u2014 these would shadow the router shim. Overriding via a per-spawn --settings env block (outranks ~/.claude/settings.json).`);
+  }
+  const settingsPath = o.deps.writeRouterSettings({
+    stateRoot: o.stateRoot,
+    project: o.project,
+    taskId: "captain",
+    env: mergeClaudeEnvRouterSettings(routerEnv, o.config.defaults.claudeEnv)
+  });
+  return {
+    backend: o.backend,
+    model,
+    permissionMode: "default",
+    env: { ...routerEnv, SQUADRANT_GATE: "on" },
+    settingsPath
+  };
+}
+var init_captain_router = __esm({
+  "packages/core/dist/captain-router.js"() {
+    init_dist();
+    init_router_resolution();
+    init_env();
+  }
+});
+
 // packages/core/dist/permission-gate.js
 import { createHash } from "crypto";
 import { mkdirSync as mkdirSync7, readFileSync as readFileSync11, renameSync as renameSync4, writeFileSync as writeFileSync10, unlinkSync as unlinkSync4 } from "fs";
 import { dirname as dirname5, join as join15 } from "path";
 function isGateSession(env) {
-  return Boolean(env.SQUADRANT_CREW_TASK_ID) || env[SIDE_SESSION_ENV] === "1";
+  return Boolean(env.SQUADRANT_CREW_TASK_ID) || env[SIDE_SESSION_ENV] === "1" || env.SQUADRANT_ROLE === "captain";
 }
 function resolveGateMode(env, gate) {
   const fromEnv = env.SQUADRANT_GATE;
@@ -8062,7 +8881,15 @@ async function callClassifier(o) {
       return "ask";
     }
     const data = await res.json();
+    if (data?.stop_reason === "max_tokens") {
+      o.log?.("gate: classifier exhausted max_tokens before a verdict \u2014 asking");
+      return "ask";
+    }
     const text = Array.isArray(data?.content) ? data.content.filter((b) => b?.type === "text" && typeof b.text === "string").map((b) => b.text).join(" ") : "";
+    if (!text.trim()) {
+      o.log?.("gate: classifier returned no text verdict \u2014 asking");
+      return "ask";
+    }
     return parseClassifierVerdict(text);
   } catch (e) {
     o.log?.(`gate: classifier unavailable (${e.message}) \u2014 asking`);
@@ -8081,7 +8908,7 @@ ${toolPayload}`).digest("hex");
 }
 async function evaluatePermissionRequest(input) {
   if (!isGateSession(input.env)) {
-    return { decision: "yield", reason: "not a squadrant crew/side session" };
+    return { decision: "yield", reason: "not a squadrant crew/side/captain session" };
   }
   const gate = input.config.defaults.gate;
   const mode = resolveGateMode(input.env, gate);
@@ -8167,7 +8994,7 @@ var init_permission_gate = __esm({
     DEFAULT_CACHE_TTL_MS = 10 * 60 * 1e3;
     DEFAULT_CACHE_MAX_ENTRIES = 500;
     DEFAULT_CLASSIFIER_TIMEOUT_MS = 5e3;
-    CLASSIFIER_MAX_TOKENS = 8;
+    CLASSIFIER_MAX_TOKENS = 256;
     MAX_PAYLOAD_CHARS = 2e3;
     DEFAULT_GATE_DENY_RULES = [
       // Flag-order-agnostic: both recursive and force must be present, in any order,
@@ -8497,7 +9324,7 @@ var init_launch_workspace = __esm({
 });
 
 // packages/core/dist/side-session.js
-import fs12 from "fs";
+import fs13 from "fs";
 function sideTitleFor(project, name) {
   return `\u{1F5D2} ${project}:${name}`;
 }
@@ -8599,7 +9426,7 @@ async function runSideClose(runtime, workspaceId, project, name, projPath, workt
   await runtime.closePane(pane);
   if (projPath) {
     const wtPath = worktreePath(projPath, worktreeDir, project, name);
-    if (fs12.existsSync(wtPath)) {
+    if (fs13.existsSync(wtPath)) {
       try {
         removeWorktree(projPath, wtPath);
       } catch (e) {
@@ -9036,8 +9863,10 @@ __export(dist_exports2, {
   AGENT_BINS: () => AGENT_BINS,
   ANTHROPIC_ONLY_REQUEST_FIELDS: () => ANTHROPIC_ONLY_REQUEST_FIELDS,
   BOT_COMMANDS: () => BOT_COMMANDS,
+  CAPTAIN_RECEIVED_ACK: () => CAPTAIN_RECEIVED_ACK,
   CC_SOCKS_DIR: () => CC_SOCKS_DIR,
   CMUX_PRESERVE_CLAUDE_AUTH_ENV: () => CMUX_PRESERVE_CLAUDE_AUTH_ENV,
+  CONFLICT_409_SELF_HEAL_MS: () => CONFLICT_409_SELF_HEAL_MS,
   CREW_GONE_MS: () => CREW_GONE_MS,
   CREW_STALE_MS: () => CREW_STALE_MS,
   CaptainDelivery: () => CaptainDelivery,
@@ -9057,6 +9886,7 @@ __export(dist_exports2, {
   LivenessRegistry: () => LivenessRegistry,
   MONITOR_STALL_BUDGET_MS: () => MONITOR_STALL_BUDGET_MS,
   OPERATOR_INITIATED_COMMANDS: () => OPERATOR_INITIATED_COMMANDS,
+  PANE_IDLE_AFTER_MS: () => PANE_IDLE_AFTER_MS,
   PROBE_QUIET_MS: () => PROBE_QUIET_MS,
   PROTOCOL_VERSION: () => PROTOCOL_VERSION,
   READ_ONLY_CREW_SUBCOMMANDS: () => READ_ONLY_CREW_SUBCOMMANDS,
@@ -9069,6 +9899,10 @@ __export(dist_exports2, {
   TERMINAL_RECORD_KEEP_PER_PROJECT: () => TERMINAL_RECORD_KEEP_PER_PROJECT,
   TERMINAL_RECORD_TTL_MS: () => TERMINAL_RECORD_TTL_MS,
   TOOL_STALL_BUDGET_MS: () => TOOL_STALL_BUDGET_MS,
+  TYPING_KEEPALIVE_MS: () => TYPING_KEEPALIVE_MS,
+  TelegramApiError: () => TelegramApiError,
+  WATCHDOG_GRACE_MS: () => WATCHDOG_GRACE_MS,
+  WATCHDOG_MS: () => WATCHDOG_MS,
   WORK_ITEM_TTL_MS: () => WORK_ITEM_TTL_MS,
   WRITABLE_CONFIG_KEYS: () => WRITABLE_CONFIG_KEYS,
   _resetRestartInFlightForTest: () => _resetRestartInFlightForTest,
@@ -9090,14 +9924,19 @@ __export(dist_exports2, {
   callClassifier: () => callClassifier,
   capAllowed: () => capAllowed,
   capOutput: () => capOutput,
+  captainAliveStateFromHealth: () => captainAliveStateFromHealth,
   captainRecordPath: () => captainRecordPath,
   captainSocketPath: () => captainSocketPath,
   checkFact: () => checkFact,
+  classifyCaptainPane: () => classifyCaptainPane,
   classifyHealth: () => classifyHealth,
+  claudeEnvShadowsRouter: () => claudeEnvShadowsRouter,
+  clearPending: () => clearPending,
   closeWorkItem: () => closeWorkItem,
   computeTemplateHash: () => computeTemplateHash,
   consumeExitMarker: () => consumeExitMarker,
   createAttach: () => createAttach,
+  createCaptainPaneReader: () => createCaptainPaneReader,
   createCrewPaneReader: () => createCrewPaneReader,
   createDaemon: () => createDaemon,
   createDecoder: () => createDecoder,
@@ -9106,6 +9945,7 @@ __export(dist_exports2, {
   createDirectSurfaceLivenessProbe: () => createDirectSurfaceLivenessProbe,
   createEnsureCaptainAlive: () => createEnsureCaptainAlive,
   createEventsSource: () => createEventsSource,
+  createInboundLifecycle: () => createInboundLifecycle,
   createInteractiveProbe: () => createInteractiveProbe,
   createIsCaptainAlive: () => createIsCaptainAlive,
   createLaunch: () => createLaunch,
@@ -9161,12 +10001,16 @@ __export(dist_exports2, {
   formatInbound: () => formatInbound,
   formatInboundReceipt: () => formatInboundReceipt,
   formatLifecycle: () => formatLifecycle,
+  formatMediaReceipt: () => formatMediaReceipt,
   formatPermissionDecision: () => formatPermissionDecision,
   formatUsageLine: () => formatUsageLine,
+  formatWatchdogWarning: () => formatWatchdogWarning,
   freshTrace: () => freshTrace,
   gateCacheKey: () => gateCacheKey,
   getDaemonPid: () => getDaemonPid,
+  hasModalOptionList: () => hasModalOptionList,
   healCmdFor: () => healCmdFor,
+  inboundBody: () => inboundBody,
   isAuthorized: () => isAuthorized,
   isBareSpawn: () => isBareSpawn,
   isCaptainAlive: () => isCaptainAlive,
@@ -9188,17 +10032,23 @@ __export(dist_exports2, {
   kickstartArgv: () => kickstartArgv,
   launchOneWorkspace: () => launchOneWorkspace,
   listSessions: () => listSessions,
+  loadPending: () => loadPending,
   loadSessions: () => loadSessions,
   loadState: () => loadState,
   mailboxStats: () => mailboxStats,
   makeGate: () => makeGate,
+  markPendingWarned: () => markPendingWarned,
   maskToken: () => maskToken,
   matchTier1Deny: () => matchTier1Deny,
+  mediaKind: () => mediaKind,
+  mediaMarker: () => mediaMarker,
+  mergeClaudeEnvRouterSettings: () => mergeClaudeEnvRouterSettings,
   mintToken: () => mintToken,
   nameFromTitle: () => nameFromTitle,
   newestSessionInDirectory: () => newestSessionInDirectory,
   nextAutoName: () => nextAutoName,
   niceCrewCommand: () => niceCrewCommand,
+  notePaneScreen: () => notePaneScreen,
   notifyToggle: () => notifyToggle,
   parseBearer: () => parseBearer,
   parseClassifierVerdict: () => parseClassifierVerdict,
@@ -9207,12 +10057,15 @@ __export(dist_exports2, {
   parseNotifyPref: () => parseNotifyPref,
   parseProgramArgs: () => parseProgramArgs,
   plistPath: () => plistPath,
+  pollBackoffMs: () => pollBackoffMs,
   pollNewestSessionInDirectory: () => pollNewestSessionInDirectory,
+  prepareCaptainRoute: () => prepareCaptainRoute,
   printForeignInstallError: () => printForeignInstallError,
   printVersionUpgradeNotice: () => printVersionUpgradeNotice,
   probeCaptainChannel: () => probeCaptainChannel,
   programArgsBlock: () => programArgsBlock,
   projectHealth: () => projectHealth,
+  pruneTopics: () => pruneTopics,
   purgeExpiredWorkItems: () => purgeExpiredWorkItems,
   readCaptainAddress: () => readCaptainAddress,
   readCursor: () => readCursor,
@@ -9279,9 +10132,11 @@ __export(dist_exports2, {
   saveSessions: () => saveSessions,
   saveState: () => saveState,
   screenHasSplashMarker: () => screenHasSplashMarker,
+  screenHash: () => screenHash,
   sendRequest: () => sendRequest,
   setLastUserId: () => setLastUserId,
   setNotify: () => setNotify,
+  setPending: () => setPending,
   setTopic: () => setTopic,
   shellQuote: () => shellQuote,
   shouldBuildRouterService: () => shouldBuildRouterService,
@@ -9294,6 +10149,7 @@ __export(dist_exports2, {
   startServer: () => startServer,
   stripBotMention: () => stripBotMention,
   surfaceVerdict: () => surfaceVerdict,
+  telegramPollLockPath: () => telegramPollLockPath,
   timeoutGate: () => timeoutGate,
   titleFor: () => titleFor,
   toControlEvent: () => toControlEvent,
@@ -9340,6 +10196,7 @@ var init_dist2 = __esm({
     init_router();
     init_crew_routing();
     init_router_resolution();
+    init_captain_router();
     init_permission_gate();
     init_restart_daemon();
     init_group_dispatch();
@@ -9362,7 +10219,7 @@ var init_dist2 = __esm({
 });
 
 // packages/agents/dist/claude/registry.js
-import fs13 from "fs";
+import fs14 from "fs";
 import { join as join17 } from "path";
 import { homedir as homedir7 } from "os";
 function parseRegistryDir(files, readFile7) {
@@ -9407,11 +10264,11 @@ function readClaudeStatus(task) {
     return void 0;
   let files;
   try {
-    files = fs13.readdirSync(CLAUDE_SESSIONS_DIR);
+    files = fs14.readdirSync(CLAUDE_SESSIONS_DIR);
   } catch {
     return void 0;
   }
-  const entries = parseRegistryDir(files, (name) => fs13.readFileSync(join17(CLAUDE_SESSIONS_DIR, name), "utf8"));
+  const entries = parseRegistryDir(files, (name) => fs14.readFileSync(join17(CLAUDE_SESSIONS_DIR, name), "utf8"));
   let entry;
   if (task.messagingSocketPath) {
     entry = entries.find((e) => e.messagingSocketPath === task.messagingSocketPath);
@@ -9426,11 +10283,11 @@ function readClaudeStatus(task) {
 function readClaudeStatusByCwd(cwd) {
   let files;
   try {
-    files = fs13.readdirSync(CLAUDE_SESSIONS_DIR);
+    files = fs14.readdirSync(CLAUDE_SESSIONS_DIR);
   } catch {
     return void 0;
   }
-  const entries = parseRegistryDir(files, (name) => fs13.readFileSync(join17(CLAUDE_SESSIONS_DIR, name), "utf8"));
+  const entries = parseRegistryDir(files, (name) => fs14.readFileSync(join17(CLAUDE_SESSIONS_DIR, name), "utf8"));
   const entry = entries.find((e) => e.cwd === cwd);
   if (!entry)
     return void 0;
@@ -9439,11 +10296,11 @@ function readClaudeStatusByCwd(cwd) {
 function readClaudeStatusBySocketPath(socketPath2) {
   let files;
   try {
-    files = fs13.readdirSync(CLAUDE_SESSIONS_DIR);
+    files = fs14.readdirSync(CLAUDE_SESSIONS_DIR);
   } catch {
     return void 0;
   }
-  const entries = parseRegistryDir(files, (name) => fs13.readFileSync(join17(CLAUDE_SESSIONS_DIR, name), "utf8"));
+  const entries = parseRegistryDir(files, (name) => fs14.readFileSync(join17(CLAUDE_SESSIONS_DIR, name), "utf8"));
   const entry = entries.find((e) => e.messagingSocketPath === socketPath2);
   if (!entry)
     return void 0;
@@ -9866,9 +10723,9 @@ var init_registry2 = __esm({
 });
 
 // packages/agents/dist/drivers/launch-cmd.js
-import fs14 from "fs";
+import fs15 from "fs";
 import path13 from "path";
-function buildAgentCmd(agentName, registry, role, fresh, permissionMode, model, templatesDir, messagingSocketPath, sessionName, thinking, captainBoot) {
+function buildAgentCmd(agentName, registry, role, fresh, permissionMode, model, templatesDir, messagingSocketPath, sessionName, thinking, captainBoot, settingsPath) {
   const driver = registry.getDriver(agentName);
   if (driver.name === "claude") {
     let cmd = fresh ? "claude" : "claude -c";
@@ -9881,6 +10738,8 @@ function buildAgentCmd(agentName, registry, role, fresh, permissionMode, model,
       cmd += " --permission-mode auto";
     } else if (permissionMode === "bypassPermissions") {
       cmd += " --dangerously-skip-permissions";
+    } else if (permissionMode === "default") {
+      cmd += " --permission-mode default";
     }
     if (model) {
       cmd += ` --model ${model}`;
@@ -9888,15 +10747,18 @@ function buildAgentCmd(agentName, registry, role, fresh, permissionMode, model,
     if (thinking) {
       cmd += ` --effort ${thinking}`;
     }
+    if (settingsPath) {
+      cmd += ` --settings ${settingsPath}`;
+    }
     if (templatesDir) {
       const roleFile2 = path13.join(templatesDir, `${role}.claude.md`);
       const legacyRoleFile = path13.join(templatesDir, `${role}.CLAUDE.md`);
-      const actualRoleFile = fs14.existsSync(roleFile2) ? roleFile2 : fs14.existsSync(legacyRoleFile) ? legacyRoleFile : null;
+      const actualRoleFile = fs15.existsSync(roleFile2) ? roleFile2 : fs15.existsSync(legacyRoleFile) ? legacyRoleFile : null;
       if (actualRoleFile) {
         cmd += ` --append-system-prompt-file ${actualRoleFile}`;
       }
       const pluginDir = path13.join(templatesDir, "..", "plugin");
-      if (fs14.existsSync(pluginDir)) {
+      if (fs15.existsSync(pluginDir)) {
         cmd += ` --plugin-dir ${pluginDir}`;
       }
     }
@@ -9912,7 +10774,7 @@ function buildAgentCmd(agentName, registry, role, fresh, permissionMode, model,
     role,
     model,
     autoApprove: true,
-    promptFile: roleFile && fs14.existsSync(roleFile) ? roleFile : void 0,
+    promptFile: roleFile && fs15.existsSync(roleFile) ? roleFile : void 0,
     ...captainBoot && role === "captain" ? {
       interactive: true,
       ...captainBoot.port ? { port: captainBoot.port } : {},
@@ -10284,7 +11146,7 @@ var init_opencode2 = __esm({
 });
 
 // packages/agents/dist/projection/opencode-skills.js
-import fs15 from "fs";
+import fs16 from "fs";
 import os10 from "os";
 import path18 from "path";
 function defaultOpencodeSkillsRoot(env = process.env) {
@@ -10303,62 +11165,62 @@ function parseSkillName(raw) {
 }
 function listSourceSkills(sourceSkillsDir) {
   const out = /* @__PURE__ */ new Map();
-  if (!fs15.existsSync(sourceSkillsDir))
+  if (!fs16.existsSync(sourceSkillsDir))
     return out;
-  for (const entry of fs15.readdirSync(sourceSkillsDir, { withFileTypes: true })) {
+  for (const entry of fs16.readdirSync(sourceSkillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory())
       continue;
     const skillPath = path18.join(sourceSkillsDir, entry.name, "SKILL.md");
-    if (!fs15.existsSync(skillPath))
+    if (!fs16.existsSync(skillPath))
       continue;
-    const name = parseSkillName(fs15.readFileSync(skillPath, "utf-8"));
+    const name = parseSkillName(fs16.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));
+  return fs16.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))
+  if (wanted.size === 0 && !fs16.existsSync(opts.sourceSkillsDir))
     return result;
   if (!opts.dryRun)
-    fs15.mkdirSync(opts.skillsRoot, { recursive: true });
+    fs16.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) {
+    if (fs16.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))) {
+    const current = fs16.existsSync(targetSkill) ? fs16.readFileSync(targetSkill) : null;
+    if (current && current.equals(fs16.readFileSync(srcPath))) {
       if (!managed && !opts.dryRun) {
-        fs15.writeFileSync(path18.join(targetDir, OPENCODE_SKILL_MARKER), MARKER_BODY);
+        fs16.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);
+      fs16.mkdirSync(targetDir, { recursive: true });
+      fs16.copyFileSync(srcPath, targetSkill);
+      fs16.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 (fs16.existsSync(opts.skillsRoot)) {
+    for (const entry of fs16.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 });
+        fs16.rmSync(dir, { recursive: true, force: true });
       result.removed.push(entry.name);
     }
   }
@@ -12167,6 +13029,9 @@ var init_peer_channel = __esm({
             return { status: "accepted", via: this.name, confirmed: true };
           }
         }
+        if (statusBefore === "busy" || statusBefore === "shell") {
+          return { status: "queued", via: this.name };
+        }
         if (statusBefore === "idle") {
           await this.deps.sleep(window);
           const afterInfo = this.deps.statusFor(taskId);
@@ -12312,7 +13177,7 @@ var init_receipt_listener = __esm({
 });
 
 // packages/agents/dist/claude/api-key-approval.js
-import fs16 from "fs";
+import fs17 from "fs";
 import os12 from "os";
 import path20 from "path";
 function ensureClaudeApiKeyApproved(apiKey, opts = {}) {
@@ -12322,12 +13187,12 @@ function ensureClaudeApiKeyApproved(apiKey, opts = {}) {
   const file = opts.claudeJsonPath ?? path20.join(os12.homedir(), ".claude.json");
   const log = opts.log ?? (() => {
   });
-  if (!fs16.existsSync(file)) {
+  if (!fs17.existsSync(file)) {
     return { changed: false, reason: "no ~/.claude.json yet \u2014 skipping routed-key pre-approval" };
   }
   let doc;
   try {
-    doc = JSON.parse(fs16.readFileSync(file, "utf8"));
+    doc = JSON.parse(fs17.readFileSync(file, "utf8"));
   } catch {
     return {
       changed: false,
@@ -12349,11 +13214,11 @@ function ensureClaudeApiKeyApproved(apiKey, opts = {}) {
   };
   const tmp = `${file}.squadrant-tmp`;
   try {
-    fs16.writeFileSync(tmp, JSON.stringify(doc, null, 2) + "\n", { mode: fs16.statSync(file).mode & 511 });
-    fs16.renameSync(tmp, file);
+    fs17.writeFileSync(tmp, JSON.stringify(doc, null, 2) + "\n", { mode: fs17.statSync(file).mode & 511 });
+    fs17.renameSync(tmp, file);
   } catch (e) {
     try {
-      fs16.unlinkSync(tmp);
+      fs17.unlinkSync(tmp);
     } catch {
     }
     return {
@@ -12709,11 +13574,11 @@ function parseDraftFromScreen(screen) {
   if (!screen)
     return null;
   const lines = screen.split(/\r?\n/);
-  const HR_RE = /^\s*─{10,}\s*$/;
+  const HR_RE2 = /^\s*─{10,}\s*$/;
   let bottomHR = -1;
   let topHR = -1;
   for (let i = lines.length - 1; i >= 0; i--) {
-    if (HR_RE.test(lines[i])) {
+    if (HR_RE2.test(lines[i])) {
       if (bottomHR === -1) {
         bottomHR = i;
       } else {
@@ -12751,11 +13616,11 @@ function hasCCInputBox(screen) {
   if (!screen)
     return false;
   const lines = screen.split(/\r?\n/);
-  const HR_RE = /^\s*─{10,}\s*$/;
+  const HR_RE2 = /^\s*─{10,}\s*$/;
   let bottomHR = -1;
   let topHR = -1;
   for (let i = lines.length - 1; i >= 0; i--) {
-    if (HR_RE.test(lines[i])) {
+    if (HR_RE2.test(lines[i])) {
       if (bottomHR === -1)
         bottomHR = i;
       else {
@@ -12768,15 +13633,15 @@ function hasCCInputBox(screen) {
     return false;
   return lines.slice(topHR + 1, bottomHR).some((l) => /[>❯]/.test(l));
 }
-function hasModalOptionList(screen) {
+function hasModalOptionList2(screen) {
   if (!screen)
     return false;
   const lines = screen.split(/\r?\n/);
-  const HR_RE = /^\s*─{10,}\s*$/;
+  const HR_RE2 = /^\s*─{10,}\s*$/;
   let bottomHR = -1;
   let topHR = -1;
   for (let i = lines.length - 1; i >= 0; i--) {
-    if (HR_RE.test(lines[i])) {
+    if (HR_RE2.test(lines[i])) {
       if (bottomHR === -1)
         bottomHR = i;
       else {
@@ -12790,14 +13655,14 @@ function hasModalOptionList(screen) {
   return lines.slice(topHR + 1, bottomHR).some((l) => /^\s*\d+\.\s/.test(l));
 }
 function parseModalOptions(screen) {
-  if (!hasModalOptionList(screen))
+  if (!hasModalOptionList2(screen))
     return null;
   const lines = screen.split(/\r?\n/);
-  const HR_RE = /^\s*─{10,}\s*$/;
+  const HR_RE2 = /^\s*─{10,}\s*$/;
   let bottomHR = -1;
   let topHR = -1;
   for (let i = lines.length - 1; i >= 0; i--) {
-    if (HR_RE.test(lines[i])) {
+    if (HR_RE2.test(lines[i])) {
       if (bottomHR === -1)
         bottomHR = i;
       else {
@@ -12822,11 +13687,11 @@ function readInputBoxRaw(screen, opts) {
   if (!screen)
     return null;
   const lines = screen.split(/\r?\n/);
-  const HR_RE = /^\s*─{10,}\s*$/;
+  const HR_RE2 = /^\s*─{10,}\s*$/;
   let bottomHR = -1;
   let topHR = -1;
   for (let i = lines.length - 1; i >= 0; i--) {
-    if (HR_RE.test(lines[i])) {
+    if (HR_RE2.test(lines[i])) {
       if (bottomHR === -1)
         bottomHR = i;
       else {
@@ -12859,6 +13724,30 @@ function classifyOpencodeStartupSurface(screen) {
     return "loading";
   return OC_IDLE_MARKERS.some((m) => screenHasSplashMarker(screen, m)) ? "idle" : "loading";
 }
+function parseOpencodeDraftFromScreen(screen) {
+  if (!screen)
+    return null;
+  if (OC_BUSY_RE.test(screen))
+    return null;
+  const lines = screen.split(/\r?\n/);
+  let bottom = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (OC_BOX_BOTTOM_RE.test(lines[i])) {
+      bottom = i;
+      break;
+    }
+  }
+  if (bottom === -1)
+    return null;
+  const content = [];
+  for (let i = bottom - 1; i >= 0 && OC_BOX_SIDE_RE.test(lines[i]); i--) {
+    content.push(lines[i].replace(/^\s*┃\s*/, "").replace(/[\s┃│]+$/, ""));
+  }
+  if (content.length === 0)
+    return null;
+  const hasDraft = content.some((l) => l !== "" && !OC_BOX_STATUS_RE.test(l) && !screenHasSplashMarker(l, "Ask anything"));
+  return hasDraft ? null : "";
+}
 function sendDebugEnabled() {
   return !!process.env.SQUADRANT_DEBUG_SEND;
 }
@@ -13074,10 +13963,10 @@ function createCmuxDriver() {
 `);
         throw new DeferDelivery(null, "probe-failed");
       }
-      const draft = parseDraftFromScreen(screen);
+      const draft = opts?.agent === "opencode" ? parseOpencodeDraftFromScreen(screen) : parseDraftFromScreen(screen);
       if (draft === null)
         throw new DeferDelivery(null, "no-box");
-      if (hasModalOptionList(screen))
+      if (hasModalOptionList2(screen))
         throw new DeferDelivery(null, "modal");
       if (draft === "") {
         await deliver();
@@ -13181,7 +14070,7 @@ function createCmuxDriver() {
     }
   };
 }
-var CMUX_TIMEOUT, CmuxTimeoutError, CC_INITIALIZED_RE, CC_WORKING_RE, OC_IDLE_MARKERS;
+var CMUX_TIMEOUT, CmuxTimeoutError, CC_INITIALIZED_RE, CC_WORKING_RE, OC_IDLE_MARKERS, OC_BOX_BOTTOM_RE, OC_BOX_SIDE_RE, OC_BOX_STATUS_RE, OC_BUSY_RE;
 var init_cmux = __esm({
   "packages/workspaces/dist/runtimes/cmux.js"() {
     init_dist();
@@ -13199,6 +14088,10 @@ var init_cmux = __esm({
     CC_INITIALIZED_RE = /⏵⏵|Ctx Used|for shortcuts|accept edits/i;
     CC_WORKING_RE = /↓\s*[\d.]+\s*k?\s*tokens?\b|esc to interrupt|\bshell still running\b|·\s*\d+\s*shell\b|\(\d+m?\s*\d*s\b/i;
     OC_IDLE_MARKERS = ["Ask anything", "ctrl+p commands"];
+    OC_BOX_BOTTOM_RE = /^\s*╹[▀]{6,}\s*$/;
+    OC_BOX_SIDE_RE = /^\s*┃/;
+    OC_BOX_STATUS_RE = /^Build\s*·/i;
+    OC_BUSY_RE = /esc\s+interrupt/i;
   }
 });
 
@@ -13323,7 +14216,7 @@ var init_notifiers = __esm({
 });
 
 // packages/workspaces/dist/workspaces/obsidian.js
-import fs17 from "fs/promises";
+import fs18 from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
 import path21 from "path";
 function resolveInRoot(root, relative) {
@@ -13348,16 +14241,16 @@ function createObsidianDriver(scope) {
       };
     },
     async read(rel) {
-      return fs17.readFile(resolveInRoot(root, rel), "utf-8");
+      return fs18.readFile(resolveInRoot(root, rel), "utf-8");
     },
     async write(rel, content) {
       const abs = resolveInRoot(root, rel);
-      await fs17.mkdir(path21.dirname(abs), { recursive: true });
-      await fs17.writeFile(abs, content);
+      await fs18.mkdir(path21.dirname(abs), { recursive: true });
+      await fs18.writeFile(abs, content);
     },
     async exists(rel) {
       try {
-        await fs17.access(resolveInRoot(root, rel));
+        await fs18.access(resolveInRoot(root, rel));
         return true;
       } catch {
         return false;
@@ -13365,13 +14258,13 @@ function createObsidianDriver(scope) {
     },
     async list(rel) {
       try {
-        return await fs17.readdir(resolveInRoot(root, rel));
+        return await fs18.readdir(resolveInRoot(root, rel));
       } catch {
         return [];
       }
     },
     async mkdir(rel) {
-      await fs17.mkdir(resolveInRoot(root, rel), { recursive: true });
+      await fs18.mkdir(resolveInRoot(root, rel), { recursive: true });
     }
   };
 }
@@ -14269,7 +15162,7 @@ async function resolveCaptainWorkspace(project) {
 }
 async function paneHasOpenModal(runtime, pane) {
   const screen = await runtime.readPaneScreen(pane) ?? "";
-  return hasModalOptionList(screen);
+  return hasModalOptionList2(screen);
 }
 async function readModalOptions(runtime, pane) {
   const screen = await runtime.readPaneScreen(pane) ?? "";
@@ -14277,7 +15170,7 @@ async function readModalOptions(runtime, pane) {
 }
 async function confirmedSendToPane(runtime, pane, message) {
   const preSendScreen = await runtime.readPaneScreen(pane) ?? "";
-  if (hasModalOptionList(preSendScreen)) {
+  if (hasModalOptionList2(preSendScreen)) {
     return { delivered: false, blockedByModal: true };
   }
   await runtime.pasteToPane(pane, message);
@@ -14530,9 +15423,9 @@ async function runRuntimeSend(arg1, arg2, opts, confirmOpts) {
   const resolved = resolveTarget(registry, config, target, !!opts.command);
   await needRef(resolved);
   const finalProject = opts.command ? config.commandName : target;
-  const { join: join35, dirname: dirname11 } = await import("path");
+  const { join: join36, dirname: dirname12 } = await import("path");
   const { DEFAULT_CONFIG_PATH: DEFAULT_CONFIG_PATH2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
-  const stateRoot = join35(dirname11(DEFAULT_CONFIG_PATH2), "state");
+  const stateRoot = join36(dirname12(DEFAULT_CONFIG_PATH2), "state");
   const seq = await appendCaptainMessage2({
     stateRoot,
     project: finalProject,
@@ -14641,7 +15534,7 @@ init_dist3();
 import { Command as Command38 } from "commander";
 import { existsSync as existsSync14, readFileSync as readFileSync21 } from "fs";
 import { fileURLToPath as fileURLToPath6 } from "url";
-import { dirname as dirname10, join as join34 } from "path";
+import { dirname as dirname11, join as join35 } from "path";
 import { homedir as homedir20 } from "os";
 
 // packages/cli/src/commands/doctor.ts
@@ -14651,7 +15544,7 @@ init_dist();
 init_dist4();
 import { Command } from "commander";
 import { execSync as execSync8 } from "child_process";
-import fs18 from "fs";
+import fs19 from "fs";
 import { stat } from "fs/promises";
 import path22 from "path";
 import chalk3 from "chalk";
@@ -14755,7 +15648,7 @@ function settingsHaveAgentTeams() {
   try {
     const home = process.env.HOME || "";
     const settings = JSON.parse(
-      fs18.readFileSync(`${home}/.claude/settings.json`, "utf-8")
+      fs19.readFileSync(`${home}/.claude/settings.json`, "utf-8")
     );
     return settings?.env?.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS === "1";
   } catch {
@@ -14766,7 +15659,7 @@ function pluginInstalled(pluginKey) {
   try {
     const home = process.env.HOME || "";
     const plugins = JSON.parse(
-      fs18.readFileSync(
+      fs19.readFileSync(
         `${home}/.claude/plugins/installed_plugins.json`,
         "utf-8"
       )
@@ -14812,7 +15705,7 @@ ${lines.join("\n")}
 }
 function readPackageVersion(packageJsonPath) {
   try {
-    const pkg2 = JSON.parse(fs18.readFileSync(packageJsonPath, "utf-8"));
+    const pkg2 = JSON.parse(fs19.readFileSync(packageJsonPath, "utf-8"));
     return typeof pkg2.version === "string" ? pkg2.version : null;
   } catch {
     return null;
@@ -14848,7 +15741,7 @@ var doctorCommand = new Command("doctor").description("Check system health and p
   ));
   results.push(check(
     "Obsidian installed",
-    commandExists("obsidian") || fs18.existsSync("/Applications/Obsidian.app"),
+    commandExists("obsidian") || fs19.existsSync("/Applications/Obsidian.app"),
     "Install from: https://obsidian.md"
   ));
   results.push(check(
@@ -14956,7 +15849,7 @@ var doctorCommand = new Command("doctor").description("Check system health and p
   results.push(
     check(
       "Squadrant config exists",
-      fs18.existsSync(
+      fs19.existsSync(
         process.env.SQUADRANT_CONFIG || `${process.env.HOME}/.config/squadrant/config.json`
       ),
       "Run: squadrant init"
@@ -15040,7 +15933,7 @@ init_dist();
 init_dist4();
 init_dist();
 import { Command as Command2 } from "commander";
-import fs19 from "fs";
+import fs20 from "fs";
 import path23 from "path";
 import os13 from "os";
 import readline from "readline";
@@ -15140,6 +16033,13 @@ function mergeCrewPermissions(settings) {
   permissions.allow = [.../* @__PURE__ */ new Set([...existing, ...CREW_PERMISSION_ALLOWLIST])];
   return next;
 }
+function writeRouterSettings(o) {
+  const dir = join26(o.stateRoot, o.project, o.taskId);
+  mkdirSync9(dir, { recursive: true });
+  const file = join26(dir, "router-settings.json");
+  writeFileSync12(file, JSON.stringify({ env: o.env }, null, 2));
+  return file;
+}
 function writePerCrewSettingsLocal(o) {
   const dir = join26(o.projectCwd, ".claude");
   mkdirSync9(dir, { recursive: true });
@@ -15250,25 +16150,57 @@ function writePerCrewOpencodeConfig(o) {
   return file;
 }
 
+// packages/cli/src/lib/claude-auth.ts
+import { execSync as execSync9 } from "child_process";
+function parseClaudeAuthStatus(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const obj = parsed;
+  if (typeof obj.loggedIn !== "boolean") return null;
+  return {
+    authenticated: obj.loggedIn,
+    method: typeof obj.authMethod === "string" ? obj.authMethod : void 0,
+    provider: typeof obj.apiProvider === "string" ? obj.apiProvider : void 0
+  };
+}
+function detectClaudeAuth(probe = {}) {
+  const run = probe.run ?? (() => execSync9("claude auth status", {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: 1e4
+  }));
+  try {
+    const parsed = parseClaudeAuthStatus(run());
+    return parsed ?? { authenticated: false, reason: "unreadable `claude auth status` output" };
+  } catch {
+    return { authenticated: false, reason: "`claude auth status` unavailable" };
+  }
+}
+
 // packages/cli/src/commands/init.ts
 init_dist3();
 function findPackageRoot() {
   let dir = path23.dirname(new URL(import.meta.url).pathname);
   while (dir !== "/") {
-    if (fs19.existsSync(path23.join(dir, "package.json"))) return dir;
+    if (fs20.existsSync(path23.join(dir, "package.json"))) return dir;
     dir = path23.dirname(dir);
   }
   return process.cwd();
 }
 function copyDirRecursive(src, dest) {
-  fs19.mkdirSync(dest, { recursive: true });
-  for (const entry of fs19.readdirSync(src, { withFileTypes: true })) {
+  fs20.mkdirSync(dest, { recursive: true });
+  for (const entry of fs20.readdirSync(src, { withFileTypes: true })) {
     const srcPath = path23.join(src, entry.name);
     const destPath = path23.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath);
     } else {
-      fs19.copyFileSync(srcPath, destPath);
+      fs20.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -15285,16 +16217,70 @@ function promptLine(question) {
     });
   });
 }
-var initCommand = new Command2("init").description("Guided first-time setup: hub vault, agents, plugins, projects (re-run-safe)").option("--hub <path>", "Hub vault path", "~/squadrant-hub").action(async (opts) => {
+async function resolveRouter(config, opts, isTTY) {
+  if (config.defaults?.router) return config.defaults.router;
+  let kind = opts.routerKind;
+  let baseUrl = opts.routerBaseUrl;
+  let apiKeyEnv = opts.routerApiKeyEnv;
+  if (isTTY && (!kind || !baseUrl)) {
+    const k = await promptLine(chalk4.cyan(`    Router kind [${DEFAULT_ROUTER_KIND}]: `));
+    kind = kind ?? (k || DEFAULT_ROUTER_KIND);
+    const b = await promptLine(chalk4.cyan(`    Router base URL [${DEFAULT_ROUTER_BASE_URL}]: `));
+    baseUrl = baseUrl ?? (b || DEFAULT_ROUTER_BASE_URL);
+    const e = await promptLine(chalk4.cyan("    Env var holding the API key (optional): "));
+    apiKeyEnv = apiKeyEnv ?? (e || void 0);
+  }
+  const resolvedKind = kind && isRouterKind(kind) ? kind : DEFAULT_ROUTER_KIND;
+  const resolvedBase = baseUrl || DEFAULT_ROUTER_BASE_URL;
+  if (!isTTY && !opts.routerBaseUrl) {
+    console.log(chalk4.dim(`    - no router flags given; defaulting to ${resolvedKind} (${resolvedBase})`));
+    console.log(chalk4.dim("      set a credential: squadrant config set defaults.router.apiKeyEnv <VAR>"));
+  }
+  return { kind: resolvedKind, baseUrl: resolvedBase, ...apiKeyEnv ? { apiKeyEnv } : {} };
+}
+async function askProvider(current, auth) {
+  console.log(chalk4.bold("\n    Choose your provider:"));
+  for (const p of PROVIDER_PRESETS) {
+    const currentTag = p.id === current ? chalk4.dim(" (current)") : "";
+    console.log(`      ${chalk4.cyan(`${p.id})`)} ${p.label}${currentTag}`);
+    console.log(chalk4.dim(`         ${p.summary}`));
+  }
+  if (!auth.authenticated) {
+    console.log(chalk4.yellow("\n    \u26A0 No Anthropic credential detected \u2014 preset a will not work; consider b or c."));
+  }
+  const answer = (await promptLine(chalk4.cyan(`
+    Provider [a/b/c/d] (default ${current}): `))).toLowerCase();
+  if (!answer) return current;
+  if (isProviderPresetId(answer)) return answer;
+  console.log(chalk4.yellow(`    \u26A0 Unknown choice '${answer}' \u2014 keeping '${current}'.`));
+  return current;
+}
+function warnIfNoAnthropic(preset, auth) {
+  if (preset !== "a" || auth.authenticated) return;
+  console.log(chalk4.yellow("    \u26A0 No Anthropic credential detected (`claude auth status`)."));
+  console.log(chalk4.dim("      Preset A (Claude Pro/Max or an API key) may not work \u2014 consider preset b or c."));
+}
+var initCommand = new Command2("init").description("Guided first-time setup: provider, hub vault, agents, plugins, projects (re-run-safe)").option("--hub <path>", "Hub vault path", "~/squadrant-hub").option("--preset <id>", "provider preset: a|b|c|d (non-interactive)").option("--router-kind <kind>", "router kind for --preset c (opencode-go|openrouter|ccr|litellm|custom)").option("--router-base-url <url>", "router base URL for --preset c").option("--router-api-key-env <env>", "env var holding the router credential for --preset c").action(async (opts) => {
   const hubPath = resolveHome(opts.hub);
   const pkgRoot = findPackageRoot();
   const configDir = path23.join(os13.homedir(), ".config", "squadrant");
   const isTTY = process.stdin.isTTY === true;
   console.log(chalk4.bold("\nSquadrant Init\n"));
-  if (!isTTY) {
+  let explicitPreset;
+  if (opts.preset !== void 0) {
+    const candidate = opts.preset.toLowerCase();
+    if (!isProviderPresetId(candidate)) {
+      console.error(chalk4.red(`  \u2718 Unknown --preset '${opts.preset}'. Valid values: a, b, c, d`));
+      process.exitCode = 1;
+      return;
+    }
+    explicitPreset = candidate;
+  }
+  if (!isTTY && !explicitPreset) {
     console.log("  Run these steps to get started:\n");
-    console.log(chalk4.bold("  1/5  Hub vault"));
+    console.log(chalk4.bold("  1/5  Hub vault + provider"));
     console.log(chalk4.cyan(`       squadrant init --hub ${opts.hub}`));
+    console.log(chalk4.dim("       Choose a provider: squadrant init --preset a|b|c|d"));
     console.log(chalk4.bold("\n  2/5  Agent + projection setup"));
     console.log("       (handled automatically by: " + chalk4.cyan("squadrant init") + ")");
     console.log(chalk4.bold("\n  3/5  Plugins \u2014 open Claude Code and run:"));
@@ -15314,8 +16300,8 @@ var initCommand = new Command2("init").description("Guided first-time setup: hub
   }
   const wsRegistry = new WorkspaceRegistry({ obsidian: createObsidianDriver });
   try {
-    if (fs19.existsSync(DEFAULT_CONFIG_PATH)) {
-      const existing = JSON.parse(fs19.readFileSync(DEFAULT_CONFIG_PATH, "utf-8"));
+    if (fs20.existsSync(DEFAULT_CONFIG_PATH)) {
+      const existing = JSON.parse(fs20.readFileSync(DEFAULT_CONFIG_PATH, "utf-8"));
       wsRegistry.get(existing.workspace ?? "obsidian");
     }
   } catch (err) {
@@ -15323,45 +16309,76 @@ var initCommand = new Command2("init").description("Guided first-time setup: hub
     return;
   }
   stepHeader(1, 5, "Hub vault");
-  if (fs19.existsSync(DEFAULT_CONFIG_PATH)) {
+  const configExists = fs20.existsSync(DEFAULT_CONFIG_PATH);
+  let config;
+  if (configExists) {
     console.log(chalk4.yellow("    \u26A0 Config already exists, skipping creation"));
+    config = loadConfig();
   } else {
-    const config = getDefaultConfig();
+    config = getDefaultConfig();
     config.hubVault = hubPath;
+  }
+  const auth = detectClaudeAuth();
+  let chosenPreset = explicitPreset;
+  if (!chosenPreset && isTTY) {
+    chosenPreset = await askProvider(detectProviderPresetId(config), auth);
+  }
+  let appliedChanges = [];
+  if (chosenPreset) {
+    const label = PROVIDER_PRESETS.find((p) => p.id === chosenPreset)?.label ?? chosenPreset;
+    const router = chosenPreset === "c" ? await resolveRouter(config, opts, isTTY) : void 0;
+    const overwrite = !configExists || explicitPreset !== void 0;
+    const result = applyProviderPreset(config, chosenPreset, { router, overwrite });
+    appliedChanges = result.changes;
+    config = result.config;
+    console.log(chalk4.bold(`
+    Provider: ${chosenPreset.toUpperCase()} \u2014 ${label}`));
+    if (appliedChanges.length) {
+      console.log("    Will change:");
+      for (const change of appliedChanges) console.log(chalk4.dim(`      - ${change}`));
+    } else {
+      console.log(chalk4.dim("    - provider config already set (unchanged)"));
+    }
+    if (!isTTY) warnIfNoAnthropic(chosenPreset, auth);
+  }
+  if (!configExists) {
     saveConfig(config);
     console.log(chalk4.green(`    \u2714 Config created at ${DEFAULT_CONFIG_PATH}`));
+  } else if (appliedChanges.length) {
+    saveConfig(config);
+    console.log(chalk4.green(`    \u2714 Config updated at ${DEFAULT_CONFIG_PATH}`));
   }
   const hubTemplate = path23.join(pkgRoot, "obsidian", "hub");
-  if (fs19.existsSync(hubPath)) {
+  if (fs20.existsSync(hubPath)) {
     console.log(chalk4.yellow(`    \u26A0 Hub vault already exists at ${hubPath}`));
-  } else if (fs19.existsSync(hubTemplate)) {
+  } else if (fs20.existsSync(hubTemplate)) {
     copyDirRecursive(hubTemplate, hubPath);
     console.log(chalk4.green(`    \u2714 Hub vault scaffolded at ${hubPath}`));
   } else {
-    fs19.mkdirSync(hubPath, { recursive: true });
+    fs20.mkdirSync(hubPath, { recursive: true });
     console.log(chalk4.yellow(`    \u26A0 Hub template not found; created empty directory at ${hubPath}`));
   }
   const hubDashboardSrc = path23.join(pkgRoot, "obsidian", "hub", "dashboard.md");
   const hubDashboardDest = path23.join(hubPath, "dashboard.md");
-  if (fs19.existsSync(hubDashboardSrc)) {
-    fs19.copyFileSync(hubDashboardSrc, hubDashboardDest);
+  if (fs20.existsSync(hubDashboardSrc)) {
+    fs20.copyFileSync(hubDashboardSrc, hubDashboardDest);
     console.log(chalk4.green(`    \u2714 Dashboard refreshed`));
   }
-  fs19.mkdirSync(path23.join(hubPath, "projects"), { recursive: true });
+  fs20.mkdirSync(path23.join(hubPath, "projects"), { recursive: true });
   ensureRuntimeSynced({ sourceRoot: pkgRoot, runtimeRoot: configDir });
   console.log(chalk4.green(`    \u2714 Runtime assets synced to ${configDir}`));
   stepHeader(2, 5, "Agent + projection setup");
   const settingsPath = path23.join(os13.homedir(), ".claude", "settings.json");
   try {
     let settings = {};
-    if (fs19.existsSync(settingsPath)) {
-      settings = JSON.parse(fs19.readFileSync(settingsPath, "utf-8"));
+    if (fs20.existsSync(settingsPath)) {
+      settings = JSON.parse(fs20.readFileSync(settingsPath, "utf-8"));
     }
     const env = settings.env || {};
     if (env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS !== "1") {
       settings.env = { ...env, CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1" };
-      fs19.mkdirSync(path23.dirname(settingsPath), { recursive: true });
-      fs19.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      fs20.mkdirSync(path23.dirname(settingsPath), { recursive: true });
+      fs20.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
       console.log(chalk4.green("    \u2714 Agent Teams enabled in ~/.claude/settings.json"));
     } else {
       console.log(chalk4.green("    \u2714 Agent Teams already enabled"));
@@ -15441,7 +16458,7 @@ var initCommand = new Command2("init").description("Guided first-time setup: hub
 init_dist();
 init_dist2();
 import { Command as Command3 } from "commander";
-import fs20 from "fs";
+import fs21 from "fs";
 import path24 from "path";
 import chalk5 from "chalk";
 function restartAfterProjectsAdd(opts) {
@@ -15456,20 +16473,20 @@ function restartAfterProjectsAdd(opts) {
 function findPackageRoot2() {
   let dir = path24.dirname(new URL(import.meta.url).pathname);
   while (dir !== "/") {
-    if (fs20.existsSync(path24.join(dir, "package.json"))) return dir;
+    if (fs21.existsSync(path24.join(dir, "package.json"))) return dir;
     dir = path24.dirname(dir);
   }
   return process.cwd();
 }
 function copyDirRecursive2(src, dest) {
-  fs20.mkdirSync(dest, { recursive: true });
-  for (const entry of fs20.readdirSync(src, { withFileTypes: true })) {
+  fs21.mkdirSync(dest, { recursive: true });
+  for (const entry of fs21.readdirSync(src, { withFileTypes: true })) {
     const srcPath = path24.join(src, entry.name);
     const destPath = path24.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive2(srcPath, destPath);
     } else {
-      fs20.copyFileSync(srcPath, destPath);
+      fs21.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -15505,7 +16522,7 @@ var addCmd = new Command3("add").description("Register a project").argument("<na
     process.exit(1);
   }
   const resolvedPath = resolveHome(projectPath);
-  if (!fs20.existsSync(path24.join(resolvedPath, ".git"))) {
+  if (!fs21.existsSync(path24.join(resolvedPath, ".git"))) {
     console.log(chalk5.yellow(`
   \u26A0 No .git found at ${resolvedPath}. Make sure this is the project root, not a parent directory.
 `));
@@ -15574,19 +16591,19 @@ var addCmd = new Command3("add").description("Register a project").argument("<na
   restartAfterProjectsAdd({ noRestart: opts.restart === false });
   const pkgRoot = findPackageRoot2();
   const spokeTemplate = path24.join(pkgRoot, "obsidian", "spoke");
-  if (fs20.existsSync(spokeVault)) {
+  if (fs21.existsSync(spokeVault)) {
     console.log(chalk5.yellow(`  \u26A0 Spoke vault already exists at ${spokeVault}, skipping scaffold`));
-  } else if (fs20.existsSync(spokeTemplate)) {
+  } else if (fs21.existsSync(spokeTemplate)) {
     copyDirRecursive2(spokeTemplate, spokeVault);
     const statusPath = path24.join(spokeVault, "status.md");
-    if (fs20.existsSync(statusPath)) {
-      const content = fs20.readFileSync(statusPath, "utf-8");
+    if (fs21.existsSync(statusPath)) {
+      const content = fs21.readFileSync(statusPath, "utf-8");
       const updated = content.replace(/^project: unnamed/m, `project: ${name}`);
-      fs20.writeFileSync(statusPath, updated);
+      fs21.writeFileSync(statusPath, updated);
     }
     console.log(chalk5.green(`  \u2714 Spoke vault scaffolded at ${spokeVault}`));
   } else {
-    fs20.mkdirSync(spokeVault, { recursive: true });
+    fs21.mkdirSync(spokeVault, { recursive: true });
     console.log(chalk5.yellow(`  \u26A0 Spoke template not found; created empty dir at ${spokeVault}`));
   }
   console.log("");
@@ -15654,7 +16671,7 @@ init_dist4();
 init_dist3();
 init_dist();
 import { Command as Command5 } from "commander";
-import { execSync as execSync9 } from "child_process";
+import { execSync as execSync10 } from "child_process";
 import path25 from "path";
 import os14 from "os";
 import chalk7 from "chalk";
@@ -15665,7 +16682,7 @@ var TASK_PROMPTS = {
   "wiki-aggregate": "Run a wiki aggregation pass using the squadrant:command-ops skill. Scan each spoke wiki index, identify shared knowledge worth promoting, write hub wiki pages, and exit when done."
 };
 function detectCurrentWorkspace() {
-  const out = execSync9(`"${resolveCmuxBin()}" current-workspace`, { encoding: "utf-8" }).trim();
+  const out = execSync10(`"${resolveCmuxBin()}" current-workspace`, { encoding: "utf-8" }).trim();
   const match = out.match(/workspace:\d+/);
   if (!match) {
     throw new Error("Could not detect current cmux workspace. Run `squadrant command` from inside a cmux workspace.");
@@ -16533,6 +17550,7 @@ async function runCrewSpawn2(input) {
     },
     writeSettingsLocal: (cwd) => writePerCrewSettingsLocal({ projectCwd: cwd }),
     writeOpencodeConfig: writePerCrewOpencodeConfig,
+    writeRouterSettings,
     sendFirstTurn: (pane, firstTurn, preLaunchScreen, opts) => sendFirstTurnWhenReady(runtime, pane, firstTurn, preLaunchScreen, opts),
     getFreePort,
     sendCodexFirstTurn,
@@ -16982,7 +18000,7 @@ init_dist4();
 init_dist();
 init_dist2();
 import { Command as Command12 } from "commander";
-import fs21 from "fs";
+import fs22 from "fs";
 import path26 from "path";
 import os15 from "os";
 import chalk12 from "chalk";
@@ -17019,7 +18037,7 @@ async function runSideSpawn2(input) {
     prompt: input.topic,
     workdir: spawnCwd,
     role: "side",
-    promptFile: fs21.existsSync(promptFile) ? promptFile : void 0,
+    promptFile: fs22.existsSync(promptFile) ? promptFile : void 0,
     interactive: true,
     permissionMode: config.defaults.permissions?.crew ?? "auto",
     ...sideModel ? { model: sideModel } : {},
@@ -17126,7 +18144,7 @@ sideCommand.command("close").description("Close a side-session (closes its tab)"
 init_dist();
 init_dist4();
 import { Command as Command13 } from "commander";
-import { execSync as execSync10 } from "child_process";
+import { execSync as execSync11 } from "child_process";
 import chalk14 from "chalk";
 
 // packages/web/dist/read-status.js
@@ -17282,7 +18300,7 @@ function renderDashboard(rows, opts) {
 
 // packages/web/dist/sync-hub.js
 init_dist();
-import fs22 from "fs";
+import fs23 from "fs";
 import path27 from "path";
 function buildMirrorMarkdown(s) {
   const fenced = "```";
@@ -17309,8 +18327,8 @@ function buildMirrorMarkdown(s) {
 function syncHub(deps) {
   if (!deps.config.hubVault)
     return [];
-  const writeFile6 = deps.writeFile ?? ((p, c) => fs22.writeFileSync(p, c));
-  const mkdir6 = deps.mkdir ?? ((p) => fs22.mkdirSync(p, { recursive: true }));
+  const writeFile6 = deps.writeFile ?? ((p, c) => fs23.writeFileSync(p, c));
+  const mkdir6 = deps.mkdir ?? ((p) => fs23.mkdirSync(p, { recursive: true }));
   const projectsDir = path27.join(resolveHome(deps.config.hubVault), "projects");
   mkdir6(projectsDir);
   const out = [];
@@ -17330,6 +18348,7 @@ function syncHub(deps) {
 // packages/web/dist/web-server.js
 init_dist2();
 import { createServer as createServer5 } from "http";
+import { dirname as dirname7, join as join29 } from "path";
 
 // packages/web/dist/snapshot-merge.js
 function mergeSnapshot(daemon, external, now) {
@@ -17795,6 +18814,24 @@ function renderEnv(ext) {
   out.push(`</section>`);
   return out.join("");
 }
+function renderLogs() {
+  return [
+    `<section class="panel" data-panel="logs" role="tabpanel" aria-label="Logs">`,
+    sectionHead("Daemon log", "Live tail of squadrantd.log \u2014 lifecycle events, delivery attempts, auto-launches and errors as the daemon writes them."),
+    `<div class="log-controls">`,
+    `<div class="filter-bar" role="group" aria-label="Filter log lines by severity">`,
+    `<button class="filter-btn on" data-log-sev="all" aria-pressed="true">All</button>`,
+    `<button class="filter-btn" data-log-sev="warn" aria-pressed="false">Warn+</button>`,
+    `<button class="filter-btn" data-log-sev="error" aria-pressed="false">Errors</button>`,
+    `</div>`,
+    `<button class="filter-btn" data-log-pause aria-pressed="false">Pause</button>`,
+    `<button class="filter-btn" data-log-copy>Copy</button>`,
+    `<span class="log-status" data-log-status>connecting\u2026</span>`,
+    `</div>`,
+    `<div class="log-view mono" data-log-view aria-live="polite" aria-label="Daemon log lines"></div>`,
+    `</section>`
+  ].join("");
+}
 var ATTN_ORDER = { stale: 0, gone: 1, alive: 2, unknown: 3, stopped: 4 };
 var STATE_LABEL = { alive: "running", stale: "blocked", gone: "errored", unknown: "idle", stopped: "offline" };
 var STATE_CLS = { alive: "s-alive", stale: "s-stale", gone: "s-gone", unknown: "s-unknown", stopped: "s-stopped" };
@@ -17923,7 +18960,8 @@ var TABS = [
   ["overview", "Overview"],
   ["projects", "Projects"],
   ["daemon", "Daemon"],
-  ["environment", "Environment"]
+  ["environment", "Environment"],
+  ["logs", "Logs"]
 ];
 function tabNav() {
   const btns = TABS.map(([id, label], i) => `<button class="tab${i === 0 ? " on" : ""}" data-tab="${id}" role="tab" aria-selected="${i === 0 ? "true" : "false"}">${esc(label)}</button>`).join("");
@@ -17972,6 +19010,7 @@ function renderContent(snap) {
   out.push(renderProjects(snap, col.now));
   out.push(renderDaemon(snap));
   out.push(renderEnv(snap.external));
+  out.push(renderLogs());
   out.push(`</div>`);
   out.push(metricsBlob(col, linkLost));
   return out.join("\n");
@@ -18213,6 +19252,17 @@ body{margin:0;min-height:100vh;background:radial-gradient(1200px 760px at 50% -2
 
 .empty{border:1px dashed var(--bezel);border-radius:12px;padding:24px;color:var(--ink-dim);text-align:center;background:var(--panel)}
 
+/* Logs (live daemon-log tail) */
+.log-controls{display:flex;gap:8px;align-items:center;flex-wrap:wrap;margin:0 0 12px}
+.log-controls .filter-bar{margin:0}
+.log-status{margin-left:auto;color:var(--ink-dim);font-size:11px}
+.log-view{height:min(58vh,520px);overflow:auto;background:#0b1220;border:1px solid var(--bezel);border-radius:12px;
+  padding:12px 14px;box-shadow:var(--shadow);font-size:12px;line-height:1.55}
+.log-line{white-space:pre-wrap;word-break:break-word;color:#c7d2e0}
+.log-line.l-warn{color:#f0c674}
+.log-line.l-error{color:#ff8a80}
+.log-view .empty-log{color:#6b7a90}
+
 :focus-visible{outline:2px solid var(--hud);outline-offset:2px;border-radius:4px}
 
 @keyframes beat{0%,100%{box-shadow:0 0 0 0 rgba(58,210,159,.45)}50%{box-shadow:0 0 0 6px rgba(58,210,159,0)}}
@@ -18226,6 +19276,7 @@ body{margin:0;min-height:100vh;background:radial-gradient(1200px 760px at 50% -2
 var CLIENT_JS = `
 (function(){
   var activeTab='live';var hist={};var prev={};var currentFilter='all';var currentSort='attention';var sortAsc=true;var currentSearch='';var expandedProjects={};
+  var logLines=[];var logSev='all';var logPaused=false;var logAutoscroll=true;var logConnected=false;var logScrollSave=0;var LOG_MAX=1000;
   function pushHist(k,v,t){var a=hist[k]||(hist[k]=[]);if(a.length&&a[a.length-1].t===t)return;a.push({t:t,v:v});if(a.length>48)a.shift();}
   function ingest(){var el=document.getElementById('squadrant-metrics');if(!el)return;var m;try{m=JSON.parse(el.textContent);}catch(e){return;}pushHist('errors',m.errors,m.t);pushHist('behind',m.behind,m.t);pushHist('crewAge',Math.round(m.crewAgeMs/1000),m.t);pushHist('defers',m.maxDeferCount,m.t);}
   function sparkSVG(a){var W=100,H=28,p=2;if(!a.length)return'';var vs=a.map(function(x){return x.v;});var mx=Math.max.apply(null,vs),mn=Math.min.apply(null,vs);if(mx===mn)mx=mn+1;var n=a.length;var pts=a.map(function(x,i){var px=n>1?p+i/(n-1)*(W-2*p):W/2;var py=H-p-(x.v-mn)/(mx-mn)*(H-2*p);return[px,py];});var d=pts.map(function(pt,i){return(i?'L':'M')+pt[0].toFixed(1)+' '+pt[1].toFixed(1);}).join(' ');var last=pts[pts.length-1];var area=d+' L'+last[0].toFixed(1)+' '+H+' L'+pts[0][0].toFixed(1)+' '+H+' Z';return'<path class="spark-area" d="'+area+'"/><path class="spark-line" d="'+d+'"/><circle class="spark-dot" cx="'+last[0].toFixed(1)+'" cy="'+last[1].toFixed(1)+'" r="2"/>';}
@@ -18238,9 +19289,19 @@ var CLIENT_JS = `
   function applySearch(){var q=currentSearch.toLowerCase();document.querySelectorAll('[data-panel="live"] .live-row').forEach(function(r){if(!q){if(!hideByFilter(r.getAttribute('data-rollup'),currentFilter))r.hidden=false;return;}var pn=(r.getAttribute('data-project')||'').toLowerCase();var dd=((r.querySelector('.live-detail')||{}).textContent||'').toLowerCase();var rl=r.getAttribute('data-rollup');if(hideByFilter(rl,currentFilter)){r.hidden=true;return;}r.hidden=pn.indexOf(q)===-1&&dd.indexOf(q)===-1;});}
   function applySort(){var table=document.querySelector('[data-panel="live"] [data-live-table]');if(!table)return;var tbody=table.querySelector('tbody');if(!tbody)return;var rows=Array.prototype.slice.call(tbody.querySelectorAll('.live-row'));var dir=sortAsc?1:-1;rows.sort(function(a,b){var va,vb;if(currentSort==='name'){va=(a.getAttribute('data-project')||'').toLowerCase();vb=(b.getAttribute('data-project')||'').toLowerCase();}else if(currentSort==='attention'){var order={gone:0,stale:1,alive:2,unknown:3,stopped:4};va=order[a.getAttribute('data-rollup')]??99;vb=order[b.getAttribute('data-rollup')]??99;if(va===vb){va=(a.getAttribute('data-project')||'').toLowerCase();vb=(b.getAttribute('data-project')||'').toLowerCase();return va<vb?-1:va>vb?1:0;}}else if(currentSort==='activity'){va=parseInt(a.getAttribute('data-max-age'))||0;vb=parseInt(b.getAttribute('data-max-age'))||0;}return va<vb?-dir:va>vb?dir:0;});rows.forEach(function(r){tbody.appendChild(r);});}
   function applyExpand(){document.querySelectorAll('[data-panel="live"] .live-row').forEach(function(r){var pn=r.getAttribute('data-project');var er=document.querySelector('[data-panel="live"] .live-expand[data-project="'+pn+'"]');if(er){var show=!!expandedProjects[pn];er.hidden=!show;r.classList.toggle('expanded',show);}});}
-  function refresh(){ingest();applyTab();drawSparks();countUps();applyFilter();applySearch();applySort();applyExpand();}
-  document.addEventListener('click',function(e){var t=e.target&&e.target.closest?e.target.closest('[data-tab]'):null;if(t){activeTab=t.getAttribute('data-tab');applyTab();var c=document.getElementById('content');if(c){c.classList.remove('swap');void c.offsetWidth;c.classList.add('swap');}}var fb=e.target&&e.target.closest?e.target.closest('[data-filter]'):null;if(fb){currentFilter=fb.getAttribute('data-filter');applyFilter();applySearch();}var sh=e.target&&e.target.closest?e.target.closest('[data-sort]'):null;if(sh){var key=sh.getAttribute('data-sort');if(key===currentSort)sortAsc=!sortAsc;else{currentSort=key;sortAsc=true;}applySort();}var lr=e.target&&e.target.closest?e.target.closest('[data-panel="live"] .live-row'):null;if(lr&&!e.target.closest('[data-sort]')){var pn=lr.getAttribute('data-project');var er=document.querySelector('[data-panel="live"] .live-expand[data-project="'+pn+'"]');if(er){var show=er.hidden;er.hidden=!show;lr.classList.toggle('expanded',!!show);expandedProjects[pn]=!!show;}}});
-  document.addEventListener('keydown',function(e){var ae=document.activeElement;if((e.key==='ArrowRight'||e.key==='ArrowLeft')&&ae&&ae.getAttribute&&ae.getAttribute('data-tab')){var o=['live','overview','projects','daemon','environment'];var i=o.indexOf(activeTab);i=(i+(e.key==='ArrowRight'?1:o.length-1))%o.length;activeTab=o[i];applyTab();var nt=document.querySelector('[data-tab="'+activeTab+'"]');if(nt)nt.focus();e.preventDefault();}});
+  function logSevOf(s){return /error|failed|fatal/i.test(s)?'error':/warn/i.test(s)?'warn':'info';}
+  function logMatch(l){if(logSev==='all')return true;if(logSev==='error')return logSevOf(l)==='error';if(logSev==='warn')return logSevOf(l)!=='info';return true;}
+  function escHtml(s){return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');}
+  function logVisible(){return logLines.filter(logMatch);}
+  function renderLogs(){var v=document.querySelector('[data-log-view]');if(!v)return;var vis=logVisible();var html='';for(var i=0;i<vis.length;i++){html+='<div class="log-line l-'+logSevOf(vis[i])+'">'+escHtml(vis[i])+'</div>';}v.innerHTML=html||'<div class="empty-log">waiting for log output\u2026</div>';if(logAutoscroll)v.scrollTop=v.scrollHeight;else v.scrollTop=logScrollSave;
+    var sb=document.querySelectorAll('[data-log-sev]');for(var j=0;j<sb.length;j++){var on=sb[j].getAttribute('data-log-sev')===logSev;sb[j].classList.toggle('on',on);sb[j].setAttribute('aria-pressed',on?'true':'false');}
+    var pb=document.querySelector('[data-log-pause]');if(pb){pb.textContent=logPaused?'Resume':'Pause';pb.classList.toggle('on',logPaused);pb.setAttribute('aria-pressed',logPaused?'true':'false');}
+    var st=document.querySelector('[data-log-status]');if(st){if(!logConnected)st.textContent='log stream reconnecting\u2026';else st.textContent=(logPaused?'paused \xB7 ':'')+vis.length+(vis.length===logLines.length?'':'/'+logLines.length)+' lines';}
+  }
+  function ingestLog(lines){if(!lines||!lines.length)return;logLines=logLines.concat(lines);if(logLines.length>LOG_MAX)logLines=logLines.slice(logLines.length-LOG_MAX);if(activeTab==='logs'&&!logPaused)renderLogs();}
+  function refresh(){ingest();applyTab();drawSparks();countUps();applyFilter();applySearch();applySort();applyExpand();if(activeTab==='logs')renderLogs();}
+  document.addEventListener('click',function(e){var t=e.target&&e.target.closest?e.target.closest('[data-tab]'):null;if(t){activeTab=t.getAttribute('data-tab');applyTab();var c=document.getElementById('content');if(c){c.classList.remove('swap');void c.offsetWidth;c.classList.add('swap');}if(activeTab==='logs')renderLogs();}var fb=e.target&&e.target.closest?e.target.closest('[data-filter]'):null;if(fb){currentFilter=fb.getAttribute('data-filter');applyFilter();applySearch();}var sh=e.target&&e.target.closest?e.target.closest('[data-sort]'):null;if(sh){var key=sh.getAttribute('data-sort');if(key===currentSort)sortAsc=!sortAsc;else{currentSort=key;sortAsc=true;}applySort();}var sv=e.target&&e.target.closest?e.target.closest('[data-log-sev]'):null;if(sv){logSev=sv.getAttribute('data-log-sev');renderLogs();}var lp=e.target&&e.target.closest?e.target.closest('[data-log-pause]'):null;if(lp){logPaused=!logPaused;renderLogs();}var cp=e.target&&e.target.closest?e.target.closest('[data-log-copy]'):null;if(cp&&navigator.clipboard){navigator.clipboard.writeText(logVisible().join('\\n'));}var lr=e.target&&e.target.closest?e.target.closest('[data-panel="live"] .live-row'):null;if(lr&&!e.target.closest('[data-sort]')){var pn=lr.getAttribute('data-project');var er=document.querySelector('[data-panel="live"] .live-expand[data-project="'+pn+'"]');if(er){var show=er.hidden;er.hidden=!show;lr.classList.toggle('expanded',!!show);expandedProjects[pn]=!!show;}}});
+  document.addEventListener('keydown',function(e){var ae=document.activeElement;if((e.key==='ArrowRight'||e.key==='ArrowLeft')&&ae&&ae.getAttribute&&ae.getAttribute('data-tab')){var o=['live','overview','projects','daemon','environment','logs'];var i=o.indexOf(activeTab);i=(i+(e.key==='ArrowRight'?1:o.length-1))%o.length;activeTab=o[i];applyTab();var nt=document.querySelector('[data-tab="'+activeTab+'"]');if(nt)nt.focus();e.preventDefault();}});
   document.addEventListener('input',function(e){var sb=e.target&&e.target.closest?e.target.closest('[data-live-search]'):null;if(sb){currentSearch=sb.value;applySearch();}});
   var led=document.getElementById('led');var conn=document.getElementById('conn');var updated=document.getElementById('updated');
   function tickAge(){if(!generatedAt)return;var s=Math.max(0,Math.round((Date.now()-generatedAt)/1000));updated.textContent='updated '+s+'s ago';}
@@ -18249,6 +19310,11 @@ var CLIENT_JS = `
   es.onopen=function(){conn.textContent='live';conn.className='conn live';led.className='led live';};
   es.onerror=function(){conn.textContent='reconnecting';conn.className='conn down';led.className='led down';};
   es.onmessage=function(e){try{var d=JSON.parse(e.data);document.getElementById('content').innerHTML=d.contentHtml;generatedAt=d.generatedAt;tickAge();refresh();}catch(_){}};
+  document.addEventListener('scroll',function(e){var v=e.target;if(v&&v.getAttribute&&v.getAttribute('data-log-view')!==null){logAutoscroll=v.scrollTop+v.clientHeight>=v.scrollHeight-6;logScrollSave=v.scrollTop;}},true);
+  var les=new EventSource('/logs');
+  les.onopen=function(){logConnected=true;renderLogs();};
+  les.onerror=function(){logConnected=false;renderLogs();};
+  les.onmessage=function(e){try{var d=JSON.parse(e.data);if(!logPaused)ingestLog(d&&d.lines);}catch(_){}};
   refresh();tickAge();
 })();
 `.trim();
@@ -18271,7 +19337,100 @@ function renderHtml(snap, opts = {}) {
   ].join("");
 }
 
+// packages/web/dist/log-tail.js
+import { closeSync as closeSync3, openSync as openSync3, readSync as readSync2, statSync as statSync4 } from "fs";
+var LOG_TAIL_BYTES = 256 * 1024;
+var LOG_RING_SIZE = 1e3;
+function defaultSize(path39) {
+  try {
+    return statSync4(path39).size;
+  } catch {
+    return 0;
+  }
+}
+function defaultRead(path39, start, len) {
+  if (len <= 0)
+    return "";
+  try {
+    const fd = openSync3(path39, "r");
+    try {
+      const buf = Buffer.alloc(len);
+      const n = readSync2(fd, buf, 0, len, start);
+      return buf.subarray(0, n).toString("utf-8");
+    } finally {
+      closeSync3(fd);
+    }
+  } catch {
+    return "";
+  }
+}
+var LogTailer = class {
+  path;
+  ringSize;
+  offset = 0;
+  pending = "";
+  ring = [];
+  size;
+  read;
+  constructor(path39, ringSize = LOG_RING_SIZE, deps = {}) {
+    this.path = path39;
+    this.ringSize = ringSize;
+    this.size = deps.size ?? defaultSize;
+    this.read = deps.read ?? defaultRead;
+  }
+  /** Seed history from the last `maxBytes` and position the cursor at EOF.
+   *  Idempotent; call once at startup. A trailing partial line stays pending
+   *  so the next append completes it without loss or duplication. */
+  init(maxBytes = LOG_TAIL_BYTES) {
+    const size = this.size(this.path);
+    this.pending = "";
+    this.ring = [];
+    if (size <= 0) {
+      this.offset = size;
+      return;
+    }
+    const start = Math.max(0, size - maxBytes);
+    const parts = this.read(this.path, start, size - start).split("\n");
+    const rest = parts.pop() ?? "";
+    if (start > 0 && parts.length)
+      parts.shift();
+    this.push(parts);
+    this.pending = rest;
+    this.offset = size;
+  }
+  /** Complete lines appended since the previous poll. */
+  poll() {
+    const size = this.size(this.path);
+    if (size < this.offset) {
+      this.offset = 0;
+      this.pending = "";
+    }
+    if (size <= this.offset)
+      return [];
+    const text = this.read(this.path, this.offset, size - this.offset);
+    if (!text)
+      return [];
+    this.offset += Buffer.byteLength(text);
+    const parts = (this.pending + text).split("\n");
+    this.pending = parts.pop() ?? "";
+    this.push(parts);
+    return parts;
+  }
+  /** The buffered backlog (oldest first) replayed to a newly-connected client. */
+  backlog() {
+    return this.ring.slice();
+  }
+  push(lines) {
+    for (const l of lines)
+      this.ring.push(l);
+    const over = this.ring.length - this.ringSize;
+    if (over > 0)
+      this.ring.splice(0, over);
+  }
+};
+
 // packages/web/dist/web-server.js
+var LOG_POLL_MS = 1e3;
 async function querySnapshot(sockPath) {
   try {
     const reply = await sendRequest(sockPath, { kind: "snapshot" });
@@ -18284,6 +19443,9 @@ async function startWebServer(opts) {
   const host = opts.host ?? "127.0.0.1";
   const now = opts.now ?? (() => Date.now());
   const clients = /* @__PURE__ */ new Set();
+  const logClients = /* @__PURE__ */ new Set();
+  const logPath2 = opts.logPath ?? join29(dirname7(opts.sockPath), "squadrantd.log");
+  const tailer = new LogTailer(logPath2);
   let latest = null;
   async function tick() {
     const daemon = await querySnapshot(opts.sockPath);
@@ -18299,6 +19461,19 @@ async function startWebServer(opts) {
       }
     }
   }
+  function broadcastLog(lines) {
+    if (lines.length === 0)
+      return;
+    const payload = `data: ${JSON.stringify({ lines })}
+
+`;
+    for (const res of logClients) {
+      try {
+        res.write(payload);
+      } catch {
+      }
+    }
+  }
   const server = createServer5((req, res) => {
     if (req.method !== "GET") {
       res.writeHead(405).end();
@@ -18324,6 +19499,22 @@ async function startWebServer(opts) {
       req.on("close", () => clients.delete(res));
       return;
     }
+    if (req.url === "/logs") {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      });
+      res.write("retry: 3000\n\n");
+      const backlog = tailer.backlog();
+      if (backlog.length)
+        res.write(`data: ${JSON.stringify({ lines: backlog })}
+
+`);
+      logClients.add(res);
+      req.on("close", () => logClients.delete(res));
+      return;
+    }
     res.writeHead(404).end();
   });
   await new Promise((resolve4, reject) => {
@@ -18338,17 +19529,33 @@ async function startWebServer(opts) {
     });
   }, opts.intervalMs);
   timer.unref?.();
+  tailer.init();
+  const logTimer = setInterval(() => {
+    try {
+      broadcastLog(tailer.poll());
+    } catch {
+    }
+  }, LOG_POLL_MS);
+  logTimer.unref?.();
   return {
     port: boundPort,
     close: () => new Promise((resolve4) => {
       clearInterval(timer);
+      clearInterval(logTimer);
       for (const res of clients) {
         try {
           res.end();
         } catch {
         }
       }
+      for (const res of logClients) {
+        try {
+          res.end();
+        } catch {
+        }
+      }
       clients.clear();
+      logClients.clear();
       server.close(() => resolve4());
     })
   };
@@ -18358,7 +19565,7 @@ async function startWebServer(opts) {
 init_dist();
 var SOCK3 = DAEMON_SOCK_PATH;
 function detectCurrentWorkspace2() {
-  const out = execSync10(`"${resolveCmuxBin()}" current-workspace`, { encoding: "utf-8" }).trim();
+  const out = execSync11(`"${resolveCmuxBin()}" current-workspace`, { encoding: "utf-8" }).trim();
   const match = out.match(/workspace:\d+/);
   if (!match) {
     throw new Error("Could not detect current cmux workspace. Run `squadrant dashboard --pane` from inside a cmux workspace.");
@@ -18441,8 +19648,8 @@ init_dist3();
 init_dist4();
 init_dist2();
 import { Command as Command14 } from "commander";
-import { execSync as execSync11, execFileSync as execFileSync10 } from "child_process";
-import fs23 from "fs";
+import { execSync as execSync12, execFileSync as execFileSync10 } from "child_process";
+import fs24 from "fs";
 import path28 from "path";
 import os16 from "os";
 import chalk15 from "chalk";
@@ -18528,6 +19735,10 @@ function resolveLaunchAgent(overrides, roleConfig, roleModelDefault) {
     thinking: overrides.thinking ?? roleConfig?.thinking
   };
 }
+function resolveLaunchBackend(o) {
+  const roleBackend = o.agentName === "claude" ? o.roleConfig?.backend : void 0;
+  return o.backendOverride ?? roleBackend ?? "native";
+}
 
 // packages/cli/src/commands/launch.ts
 init_dist2();
@@ -18569,17 +19780,24 @@ function resolveAnthropicRefusal(role, workspaceName, agentName, model, readOpen
 function ensureCmuxReady(headless) {
   if (headless || isInsideCmux()) return;
   console.log(chalk15.yellow("\n  Not running inside cmux. Opening cmux app...\n"));
-  execSync11(`open "${CMUX_APP}"`, { stdio: "inherit" });
+  execSync12(`open "${CMUX_APP}"`, { stdio: "inherit" });
   console.log(chalk15.bold("  Run `squadrant launch` from inside a cmux workspace.\n"));
   process.exit(0);
 }
 var launchCommand = new Command14("launch").description(
   "Launch a project captain (with project arg) or all captains (--all). Use `squadrant command` for one-shot Command tasks."
-).argument("[project]", "Project name to launch captain for").option("--fresh", "Start a new session instead of resuming the last one").option("--keep", "Resume the latest session even on a new day / after a template change").option("--all", "Launch all captain workspaces").option("--headless", "Skip the interactive cmux-app requirement (used by the daemon to boot captains without a terminal)").option("--agent <name>", "Override captain agent for this launch (claude|codex|gemini|opencode); takes precedence over defaults.roles.captain.agent").option("--model <name>", "Override captain model for this launch; takes precedence over defaults.roles.captain.model").option("--thinking <level>", `Override captain thinking level for this launch (${THINKING_LEVELS.join("|")}) \u2192 claude --effort; takes precedence over defaults.roles.captain.thinking`).action(async (project, opts) => {
+).argument("[project]", "Project name to launch captain for").option("--fresh", "Start a new session instead of resuming the last one").option("--keep", "Resume the latest session even on a new day / after a template change").option("--all", "Launch all captain workspaces").option("--headless", "Skip the interactive cmux-app requirement (used by the daemon to boot captains without a terminal)").option("--agent <name>", "Override captain agent for this launch (claude|codex|gemini|opencode); takes precedence over defaults.roles.captain.agent").option("--model <name>", "Override captain model for this launch; takes precedence over defaults.roles.captain.model").option("--thinking <level>", `Override captain thinking level for this launch (${THINKING_LEVELS.join("|")}) \u2192 claude --effort; takes precedence over defaults.roles.captain.thinking`).option("--backend <mode>", "Override captain backend for this launch (native|direct|proxy); takes precedence over defaults.roles.captain.backend").action(async (project, opts) => {
   if (opts.fresh && opts.keep) {
     console.error(chalk15.red("\n  \u2718 --fresh and --keep are mutually exclusive\n"));
     process.exit(1);
   }
+  if (opts.backend !== void 0 && !isBackendMode(opts.backend)) {
+    console.error(chalk15.red(`
+  \u2718 Invalid --backend value '${opts.backend}'. Valid values: native, direct, proxy
+`));
+    process.exit(1);
+  }
+  const backendOverride = opts.backend;
   let thinkingOverride;
   try {
     thinkingOverride = opts.thinking ? parseThinkingLevel(opts.thinking) : void 0;
@@ -18606,6 +19824,7 @@ var launchCommand = new Command14("launch").description(
       roleConfig,
       config.defaults.models?.[role]
     );
+    const backend = resolveLaunchBackend({ backendOverride, agentName, roleConfig });
     const refusal = resolveAnthropicRefusal(role, workspaceName, agentName, model);
     if (refusal) {
       console.error(chalk15.red(`
@@ -18635,6 +19854,29 @@ var launchCommand = new Command14("launch").description(
     if (isOpencodeCaptain && projectName) {
       captainOpencodeConfigPath = writePerCrewOpencodeConfig({ stateRoot, project: projectName, taskId: "captain" });
     }
+    let route;
+    if (role === "captain") {
+      try {
+        route = await prepareCaptainRoute({
+          backend,
+          agentName,
+          configuredPermissionMode: permissionMode,
+          project: projectName ?? "",
+          model,
+          stateRoot,
+          config,
+          deps: {
+            routerCredentials: (o) => fetchRouterCredentials(o.project, o.backend, { call: squadrantdCall }),
+            writeRouterSettings
+          },
+          warn: (m) => console.error(chalk15.yellow(`  \u26A0 ${m}`))
+        });
+      } catch (err) {
+        console.error(chalk15.red(`  \u2718 ${err.message}`));
+        hadFailure = true;
+        return;
+      }
+    }
     const priorRecord = projectName ? readCaptainAddress(stateRoot, projectName) : null;
     const captainPort = isOpencodeCaptain ? await getFreePort() : void 0;
     let opencodeResumeSessionId;
@@ -18660,15 +19902,18 @@ var launchCommand = new Command14("launch").description(
             registry,
             role,
             forceFresh,
-            permissionMode,
-            model,
+            route?.permissionMode ?? permissionMode,
+            route?.model ?? model,
             TEMPLATES_DIR4,
             resolveCaptainSocketPath(captainChannelEnabled, projectName, workspaceName),
             resolveCaptainSessionName(agentName, projectName),
             thinking,
-            captainBoot
+            captainBoot,
+            route?.settingsPath
           );
-          return captainOpencodeConfigPath ? `OPENCODE_CONFIG=${captainOpencodeConfigPath} ${baseCmd}` : baseCmd;
+          const gatePrefix = route && Object.keys(route.env).length > 0 ? `${renderEnvAssignments(route.env)} ` : "";
+          const cmd = `${gatePrefix}${baseCmd}`;
+          return captainOpencodeConfigPath ? `OPENCODE_CONFIG=${captainOpencodeConfigPath} ${cmd}` : cmd;
         },
         initialPrompt,
         runtime,
@@ -18732,12 +19977,12 @@ var launchCommand = new Command14("launch").description(
   }
   if (opts.all) {
     const hubPath = resolveHome(config.hubVault);
-    fs23.mkdirSync(hubPath, { recursive: true });
+    fs24.mkdirSync(hubPath, { recursive: true });
     console.log(chalk15.bold("\nLaunching all captain workspaces\n"));
     for (const [name, proj] of Object.entries(config.projects)) {
       const projPath = resolveHome(proj.path);
       const spokePath = resolveHome(proj.spokeVault);
-      if (!fs23.existsSync(spokePath)) {
+      if (!fs24.existsSync(spokePath)) {
         const spokeDriver = new WorkspaceRegistry({ obsidian: createObsidianDriver }).forProject(name, config);
         await ensureSpokeLayout(spokeDriver);
         console.log(chalk15.cyan(`  \u2714 Created spoke vault at ${spokePath}`));
@@ -18775,7 +20020,7 @@ Launching ${selected.length} captain workspace(s) in parallel
       const proj = config.projects[name];
       const projPath = resolveHome(proj.path);
       const spokePath = resolveHome(proj.spokeVault);
-      if (!fs23.existsSync(spokePath)) {
+      if (!fs24.existsSync(spokePath)) {
         const spokeDriver = new WorkspaceRegistry({ obsidian: createObsidianDriver }).forProject(name, config);
         await ensureSpokeLayout(spokeDriver);
         console.log(chalk15.cyan(`  \u2714 Created spoke vault at ${spokePath}`));
@@ -18799,7 +20044,7 @@ Launching ${selected.length} captain workspace(s) in parallel
     const proj = config.projects[project];
     const projPath = resolveHome(proj.path);
     const spokePath = resolveHome(proj.spokeVault);
-    if (!fs23.existsSync(spokePath)) {
+    if (!fs24.existsSync(spokePath)) {
       const spokeDriver = new WorkspaceRegistry({ obsidian: createObsidianDriver }).forProject(project, config);
       await ensureSpokeLayout(spokeDriver);
       console.log(chalk15.cyan(`  \u2714 Created spoke vault at ${spokePath}`));
@@ -18935,24 +20180,24 @@ Shutting down captain workspace for '${project}'...
 // packages/cli/src/commands/feedback.ts
 init_dist();
 import { Command as Command16 } from "commander";
-import fs24 from "fs";
+import fs25 from "fs";
 import os17 from "os";
 import path29 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { execSync as execSync12 } from "child_process";
+import { execSync as execSync13 } from "child_process";
 import chalk17 from "chalk";
 var REPO_URL = "https://github.com/tu11aa/squadrant";
 function readPkgVersion() {
   try {
     const pkgPath = path29.join(path29.dirname(fileURLToPath3(import.meta.url)), "..", "package.json");
-    return JSON.parse(fs24.readFileSync(pkgPath, "utf-8")).version ?? "unknown";
+    return JSON.parse(fs25.readFileSync(pkgPath, "utf-8")).version ?? "unknown";
   } catch {
     return "unknown";
   }
 }
 function readMetrics(metricsPath) {
   try {
-    return JSON.parse(fs24.readFileSync(metricsPath, "utf-8"));
+    return JSON.parse(fs25.readFileSync(metricsPath, "utf-8"));
   } catch {
     return {};
   }
@@ -18998,7 +20243,7 @@ var feedbackCommand = new Command16("feedback").description("Open a pre-filled G
   console.log(chalk17.dim(`  URL: ${issueUrl.substring(0, 80)}...
 `));
   try {
-    execSync12(`open "${issueUrl}"`, { stdio: "ignore" });
+    execSync13(`open "${issueUrl}"`, { stdio: "ignore" });
     console.log(chalk17.green("  \u2714 Browser opened\n"));
   } catch {
     console.log(chalk17.yellow("  \u26A0 Could not open browser automatically."));
@@ -19400,7 +20645,7 @@ init_dist4();
 init_dist();
 import { Command as Command21 } from "commander";
 import chalk22 from "chalk";
-import fs25 from "fs";
+import fs26 from "fs";
 import path30 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function parseScope(v2) {
@@ -19412,7 +20657,7 @@ function parseScope(v2) {
 function findPackageRoot3() {
   let dir = path30.dirname(fileURLToPath4(import.meta.url));
   while (dir !== "/" && dir !== "") {
-    if (fs25.existsSync(path30.join(dir, "package.json"))) return dir;
+    if (fs26.existsSync(path30.join(dir, "package.json"))) return dir;
     dir = path30.dirname(dir);
   }
   return process.cwd();
@@ -19609,12 +20854,12 @@ init_dist();
 init_dist();
 init_dist2();
 import { Command as Command23 } from "commander";
-import fs26 from "fs";
+import fs27 from "fs";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { dirname as dirname7, join as join29 } from "path";
+import { dirname as dirname8, join as join30 } from "path";
 import chalk23 from "chalk";
 function runConfigCheck(opts) {
-  const raw = JSON.parse(fs26.readFileSync(opts.configPath, "utf-8"));
+  const raw = JSON.parse(fs27.readFileSync(opts.configPath, "utf-8"));
   const def = getDefaultConfig();
   const items = detectDrift(raw, def);
   let working = raw;
@@ -19702,7 +20947,7 @@ function printItems(items) {
 var configCommand = new Command23("config").description("Inspect and reconcile squadrant config");
 configCommand.command("check").description("Detect config drift vs the current default schema").option("--fix", "Apply the safe tier (add missing, remove deprecated)", false).option("--accept", "Stamp the current version without changing config (dismiss advisories)", false).option("--json", "Output drift items as JSON", false).action((opts) => {
   const pkgVersion = readPkgVersion2();
-  if (!fs26.existsSync(DEFAULT_CONFIG_PATH)) {
+  if (!fs27.existsSync(DEFAULT_CONFIG_PATH)) {
     console.log(chalk23.yellow("No config found \u2014 run `squadrant init` first."));
     return;
   }
@@ -19747,14 +20992,14 @@ configCommand.command("set").description("Write a config value by dotted key (e.
   }
 });
 function readPkgVersion2() {
-  const pkgPath = join29(dirname7(fileURLToPath5(import.meta.url)), "..", "package.json");
-  return JSON.parse(fs26.readFileSync(pkgPath, "utf-8")).version;
+  const pkgPath = join30(dirname8(fileURLToPath5(import.meta.url)), "..", "package.json");
+  return JSON.parse(fs27.readFileSync(pkgPath, "utf-8")).version;
 }
 
 // packages/cli/src/commands/heal.ts
 init_dist();
 import { execFileSync as execFileSync11 } from "child_process";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 import { homedir as homedir17 } from "os";
 import { Command as Command24 } from "commander";
 import chalk24 from "chalk";
@@ -19994,8 +21239,8 @@ var healCommand = new Command24("heal").description("Targeted, idempotent remedi
     }
     const config = loadConfig();
     const projects = opts.all ? Object.keys(config.projects) : [project];
-    const stateRoot = join30(homedir17(), ".config", "squadrant", "state");
-    const registry = new LivenessRegistry({ path: join30(stateRoot, "liveness.json") });
+    const stateRoot = join31(homedir17(), ".config", "squadrant", "state");
+    const registry = new LivenessRegistry({ path: join31(stateRoot, "liveness.json") });
     registry.load();
     const code = await runHealCaptain(projects, {
       liveness: readCmuxLiveness,
@@ -20027,7 +21272,7 @@ import chalk26 from "chalk";
 init_dist();
 init_dist2();
 import { Command as Command25 } from "commander";
-import { execSync as execSync13 } from "child_process";
+import { execSync as execSync14 } from "child_process";
 import chalk25 from "chalk";
 async function runDispatch(toProject, task, opts) {
   const fromProject = resolveCurrentProject(loadConfig());
@@ -20043,7 +21288,7 @@ async function runDispatch(toProject, task, opts) {
     warmupTimeoutMs: opts.warmupTimeout,
     bootCaptain: async (project) => {
       try {
-        execSync13(`squadrant launch ${project}`, { stdio: "ignore", timeout: 15e3 });
+        execSync14(`squadrant launch ${project}`, { stdio: "ignore", timeout: 15e3 });
       } catch {
         throw new Error(`failed to launch captain for '${project}' \u2014 is squadrant installed?`);
       }
@@ -20079,7 +21324,7 @@ init_dist();
 init_dist2();
 init_runtime2();
 init_require_daemon();
-import { join as join32, dirname as dirname8 } from "path";
+import { join as join33, dirname as dirname9 } from "path";
 import { homedir as homedir18 } from "os";
 import { Command as Command27 } from "commander";
 import chalk28 from "chalk";
@@ -20088,23 +21333,23 @@ import chalk28 from "chalk";
 init_dist3();
 init_dist2();
 import { createServer as createServer6, connect as netConnect2 } from "net";
-import fs27 from "fs";
-import { join as join31 } from "path";
+import fs28 from "fs";
+import { join as join32 } from "path";
 import { randomUUID as randomUUID7 } from "crypto";
 import chalk27 from "chalk";
 var shared;
-var registryEntryPath = () => join31(CLAUDE_SESSIONS_DIR, `${process.pid}.json`);
+var registryEntryPath = () => join32(CLAUDE_SESSIONS_DIR, `${process.pid}.json`);
 function unregisterSenderIdentity() {
   try {
-    fs27.unlinkSync(registryEntryPath());
+    fs28.unlinkSync(registryEntryPath());
   } catch {
   }
 }
 function registerSenderIdentity(socketPath2) {
   try {
     unregisterSenderIdentity();
-    fs27.mkdirSync(CLAUDE_SESSIONS_DIR, { recursive: true });
-    fs27.writeFileSync(
+    fs28.mkdirSync(CLAUDE_SESSIONS_DIR, { recursive: true });
+    fs28.writeFileSync(
       registryEntryPath(),
       JSON.stringify({
         pid: process.pid,
@@ -20130,7 +21375,7 @@ async function sharedReceiptListener() {
     // must never be the reason we refuse to start.
     unlinkStale: (p) => {
       try {
-        fs27.unlinkSync(p);
+        fs28.unlinkSync(p);
       } catch {
       }
     },
@@ -20200,7 +21445,7 @@ async function runPing(project, message) {
   await requireDaemon();
   await needRef(resolved);
   const mode = resolveCaptainChannelMode(config.defaults);
-  const stateRoot = join32(homedir18(), ".config", "squadrant", "state");
+  const stateRoot = join33(homedir18(), ".config", "squadrant", "state");
   const { channels, agentFor } = mode === "off" ? { channels: {}, agentFor: () => void 0 } : await buildCaptainChannels({ stateRoot, configAgent: config.defaults.roles?.captain?.agent });
   const channel = channels[agentFor(project) ?? ""];
   const { handled, outcome } = await deliverToCaptain(project, message, {
@@ -20209,7 +21454,7 @@ async function runPing(project, message) {
     log: (m) => console.error(chalk28.dim(m))
   });
   if (!handled) {
-    const stateRoot2 = join32(dirname8(DEFAULT_CONFIG_PATH), "state");
+    const stateRoot2 = join33(dirname9(DEFAULT_CONFIG_PATH), "state");
     await appendCaptainMessage({
       stateRoot: stateRoot2,
       project,
@@ -20288,7 +21533,7 @@ var cmuxCommand = new Command28("cmux").description("cmux integration helpers").
 // packages/cli/src/commands/effort.ts
 init_dist();
 init_dist2();
-import fs28 from "fs";
+import fs29 from "fs";
 import path31 from "path";
 import { Command as Command29 } from "commander";
 import chalk30 from "chalk";
@@ -20332,7 +21577,7 @@ function effortScopeLabel(projectName) {
 }
 function canonical(p) {
   try {
-    return fs28.realpathSync(p);
+    return fs29.realpathSync(p);
   } catch {
     return path31.resolve(p);
   }
@@ -20394,7 +21639,7 @@ var effortCommand = new Command29("effort").description("Get or set the crew tok
 
 // packages/cli/src/commands/tokens.ts
 init_dist();
-import fs29 from "fs";
+import fs30 from "fs";
 import path32 from "path";
 import os18 from "os";
 import readline3 from "readline";
@@ -20450,7 +21695,7 @@ function foldTranscriptLine(agg, rawLine, state) {
 async function aggregateTranscriptFile(filePath) {
   const agg = emptySessionAggregate();
   const state = { lastCacheRead: null };
-  const rl = readline3.createInterface({ input: fs29.createReadStream(filePath), crlfDelay: Infinity });
+  const rl = readline3.createInterface({ input: fs30.createReadStream(filePath), crlfDelay: Infinity });
   for await (const line of rl) {
     foldTranscriptLine(agg, line, state);
   }
@@ -20518,7 +21763,7 @@ function buildRoleReport(role, sessions) {
 }
 async function readdirSafe(dir) {
   try {
-    return await fs29.promises.readdir(dir);
+    return await fs30.promises.readdir(dir);
   } catch {
     return [];
   }
@@ -20685,12 +21930,12 @@ var tokensCommand = new Command30("tokens").description(
 // packages/cli/src/commands/telegram.ts
 init_dist();
 init_dist2();
-import { join as join33, dirname as dirname9 } from "path";
+import { join as join34, dirname as dirname10 } from "path";
 import { emitKeypressEvents } from "readline";
 import { Command as Command31 } from "commander";
 import chalk32 from "chalk";
 function defaultStateRoot() {
-  return join33(dirname9(DEFAULT_CONFIG_PATH), "state");
+  return join34(dirname10(DEFAULT_CONFIG_PATH), "state");
 }
 async function questionMasked() {
   return new Promise((resolve4) => {
@@ -21019,7 +22264,7 @@ import { Command as Command33 } from "commander";
 import { homedir as homedir19 } from "os";
 
 // packages/cli/src/lib/captain-session-registry.ts
-import fs30 from "fs";
+import fs31 from "fs";
 import path33 from "path";
 
 // packages/cli/src/lib/handoff-facts.ts
@@ -21071,15 +22316,15 @@ function assembleHandoffFacts(live, claudeMem, gapSessions, checkpoint, now, ext
 // packages/cli/src/lib/captain-session-registry.ts
 var CAPTAIN_SESSION_REGISTRY_FILE = "captain-sessions.jsonl";
 function appendCaptainSession(spokeVault, record) {
-  fs30.mkdirSync(spokeVault, { recursive: true });
+  fs31.mkdirSync(spokeVault, { recursive: true });
   const file = path33.join(spokeVault, CAPTAIN_SESSION_REGISTRY_FILE);
-  fs30.appendFileSync(file, JSON.stringify(record) + "\n");
+  fs31.appendFileSync(file, JSON.stringify(record) + "\n");
 }
 function readCaptainSessionRegistry(spokeVault) {
   const file = path33.join(spokeVault, CAPTAIN_SESSION_REGISTRY_FILE);
-  if (!fs30.existsSync(file)) return [];
+  if (!fs31.existsSync(file)) return [];
   const records = [];
-  for (const line of fs30.readFileSync(file, "utf-8").split("\n")) {
+  for (const line of fs31.readFileSync(file, "utf-8").split("\n")) {
     if (!line.trim()) continue;
     try {
       records.push(JSON.parse(line));
@@ -21110,9 +22355,8 @@ async function runGatePermissionRequest(deps) {
   const p = payload;
   const taskId = env.SQUADRANT_CREW_TASK_ID;
   const project = env.SQUADRANT_CREW_PROJECT;
-  const isSide = env[SIDE_SESSION_ENV] === "1";
-  if (!taskId && !isSide) {
-    return { decision: "yield", reason: "not a squadrant crew/side session" };
+  if (!isGateSession(env)) {
+    return { decision: "yield", reason: "not a squadrant crew/side/captain session" };
   }
   const stdout = deps.stdout ?? (() => {
   });
@@ -21457,7 +22701,7 @@ import os19 from "os";
 // packages/cli/src/lib/handoff-live-repo.ts
 init_dist();
 import { execFileSync as execFileSync12 } from "child_process";
-import fs31 from "fs";
+import fs32 from "fs";
 import path35 from "path";
 
 // packages/cli/src/lib/handoff-branch-state.ts
@@ -21597,7 +22841,7 @@ function localAheadOfBase(runner, projectPath, base) {
 }
 function readFetchAgeMs(projectPath, now) {
   try {
-    const stat2 = fs31.statSync(path35.join(projectPath, ".git", "FETCH_HEAD"));
+    const stat2 = fs32.statSync(path35.join(projectPath, ".git", "FETCH_HEAD"));
     return Math.max(0, now - stat2.mtime.getTime());
   } catch {
     return null;
@@ -21668,7 +22912,7 @@ function gatherLiveRepoState(projectPath, fallbackBaseBranch, tasks, runner = de
 
 // packages/cli/src/lib/handoff-claude-mem.ts
 import { createRequire } from "module";
-import fs32 from "fs";
+import fs33 from "fs";
 var { DatabaseSync } = createRequire(import.meta.url)("node:sqlite");
 var CLAUDE_MEM_RECENCY_LIMIT = 20;
 function decisionText(row) {
@@ -21682,7 +22926,7 @@ function decisionText(row) {
   return row.narrative ?? "";
 }
 function queryClaudeMem(dbPath, project) {
-  if (!fs32.existsSync(dbPath)) return null;
+  if (!fs33.existsSync(dbPath)) return null;
   let db;
   try {
     db = new DatabaseSync(dbPath, { readOnly: true });
@@ -21725,7 +22969,7 @@ function queryClaudeMem(dbPath, project) {
 }
 
 // packages/cli/src/lib/handoff-transcript.ts
-import fs33 from "fs";
+import fs34 from "fs";
 var TRANSCRIPT_BYTE_CAP = 2e5;
 var DIGEST_BYTE_CAP = 8 * 1024;
 var PROMPT_TRUNCATE_CHARS = 300;
@@ -21834,27 +23078,27 @@ function extractMessages(tailText) {
   return { lastUserMessage, lastAssistantText, digest };
 }
 function extractTranscriptTail(transcriptPath, byteCap = TRANSCRIPT_BYTE_CAP) {
-  if (!fs33.existsSync(transcriptPath)) return null;
-  const content = fs33.readFileSync(transcriptPath, "utf-8");
+  if (!fs34.existsSync(transcriptPath)) return null;
+  const content = fs34.readFileSync(transcriptPath, "utf-8");
   const { lastUserMessage, lastAssistantText, digest } = extractMessages(tailOf(content, byteCap));
-  const mtimeIso = fs33.statSync(transcriptPath).mtime.toISOString();
+  const mtimeIso = fs34.statSync(transcriptPath).mtime.toISOString();
   return { path: transcriptPath, mtimeIso, lastUserMessage, lastAssistantText, digest };
 }
 
 // packages/cli/src/lib/handoff-archive.ts
-import fs34 from "fs";
+import fs35 from "fs";
 import path36 from "path";
 function readNewestArchivedHandoff(spokeVault, now) {
   const dir = path36.join(spokeVault, "handoffs");
-  if (!fs34.existsSync(dir)) return null;
-  const candidates = fs34.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".json")).map((e) => {
+  if (!fs35.existsSync(dir)) return null;
+  const candidates = fs35.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".json")).map((e) => {
     const full = path36.join(dir, e.name);
-    return { name: e.name, full, mtime: fs34.statSync(full).mtime };
+    return { name: e.name, full, mtime: fs35.statSync(full).mtime };
   }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
   for (const candidate of candidates) {
     let content;
     try {
-      content = JSON.parse(fs34.readFileSync(candidate.full, "utf-8"));
+      content = JSON.parse(fs35.readFileSync(candidate.full, "utf-8"));
     } catch {
       continue;
     }
@@ -22197,15 +23441,15 @@ init_dist();
 init_dist();
 init_dist();
 init_dist();
-var __dirname = dirname10(fileURLToPath6(import.meta.url));
-var pkg = JSON.parse(readFileSync21(join34(__dirname, "..", "package.json"), "utf-8"));
+var __dirname = dirname11(fileURLToPath6(import.meta.url));
+var pkg = JSON.parse(readFileSync21(join35(__dirname, "..", "package.json"), "utf-8"));
 ensureRuntimeSynced({
-  sourceRoot: join34(__dirname, ".."),
-  runtimeRoot: join34(homedir20(), ".config", "squadrant")
+  sourceRoot: join35(__dirname, ".."),
+  runtimeRoot: join35(homedir20(), ".config", "squadrant")
 });
 if (!process.env.VITEST) {
   try {
-    syncShippedOpencodeSkills({ pkgRoot: join34(__dirname, "..") });
+    syncShippedOpencodeSkills({ pkgRoot: join35(__dirname, "..") });
   } catch (err) {
     process.stderr.write(
       `squadrant: opencode skills sync skipped: ${err.message}
@@ -22215,7 +23459,7 @@ if (!process.env.VITEST) {
 }
 if (process.argv[2] !== "config") {
   try {
-    const cfgPath = join34(homedir20(), ".config", "squadrant", "config.json");
+    const cfgPath = join35(homedir20(), ".config", "squadrant", "config.json");
     if (existsSync14(cfgPath)) {
       const cfg = JSON.parse(readConfigFileSync(cfgPath));
       if (needsCheck(cfg, pkg.version)) {