squadrant 0.21.1 → 0.23.0

package/dist/index.js

@@ -98,6 +98,9 @@ function isGateMode(v2) {
 function isGatePolicy(v2) {
   return GATE_POLICIES.includes(v2);
 }
+function isGateEngine(v2) {
+  return GATE_ENGINES.includes(v2);
+}
 function isThinkingLevel(v2) {
   return THINKING_LEVELS.includes(v2);
 }
@@ -156,12 +159,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,18 +201,214 @@ 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, GATE_ENGINES, 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();
     ROUTER_KINDS = ["opencode-go", "openrouter", "ccr", "litellm", "custom"];
     GATE_MODES = ["on", "off", "auto"];
     GATE_POLICIES = ["deny-dangerous", "ask-on-doubt"];
+    GATE_ENGINES = ["router", "auto-gate"];
     THINKING_LEVELS = ["low", "medium", "high", "xhigh", "max"];
     CONTROL_CHANNEL_MODES = /* @__PURE__ */ new Set(["off", "shadow", "on"]);
     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 +1659,17 @@ __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_ENGINES: () => GATE_ENGINES,
   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 +1678,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 +1694,7 @@ __export(dist_exports, {
   defaultStatePath: () => defaultStatePath,
   detectDrift: () => detectDrift,
   detectInstallManager: () => detectInstallManager,
+  detectProviderPresetId: () => detectProviderPresetId,
   ensureCmuxAutoConfig: () => ensureCmuxAutoConfig,
   ensureDirSync: () => ensureDirSync,
   ensureRuntimeSynced: () => ensureRuntimeSynced,
@@ -1508,9 +1710,11 @@ __export(dist_exports, {
   isBackendMode: () => isBackendMode,
   isCacheStale: () => isCacheStale,
   isDaemonCachedKey: () => isDaemonCachedKey,
+  isGateEngine: () => isGateEngine,
   isGateMode: () => isGateMode,
   isGatePolicy: () => isGatePolicy,
   isNewerVersion: () => isNewerVersion,
+  isProviderPresetId: () => isProviderPresetId,
   isQuieter: () => isQuieter,
   isRouterKind: () => isRouterKind,
   isThinkingLevel: () => isThinkingLevel,
@@ -1527,6 +1731,7 @@ __export(dist_exports, {
   parseThinkingLevel: () => parseThinkingLevel,
   probeCmuxDaemonDirect: () => probeCmuxDaemonDirect,
   projectConfigPath: () => projectConfigPath,
+  providerPresetDefaults: () => providerPresetDefaults,
   readConfigFileSync: () => readConfigFileSync,
   readDailyLog: () => readDailyLog,
   readProjectLevelSource: () => readProjectLevelSource,
@@ -1556,6 +1761,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();
@@ -1827,10 +2033,11 @@ function formatDelegationReport(rec, originProject, targetProject) {
       return null;
   }
 }
-function firePush(deps, project, prev, next, event, lastCaptainTurnAt) {
+function firePush(deps, project, prev, next, event, lastCaptainTurnAt, prevRec) {
   if (!deps.notify)
     return;
-  if (prev === next.state)
+  const questionChanged = prev === "blocked" && next.state === "blocked" && prevRec != null && (prevRec.question ?? "").trim() !== (next.question ?? "").trim();
+  if (prev === next.state && !questionChanged)
     return;
   if (!ATTENTION_STATES.has(next.state))
     return;
@@ -1868,6 +2075,7 @@ function createDaemon(deps) {
   const { store, now } = deps;
   const lastCaptainTurnAt = /* @__PURE__ */ new Map();
   const quietNotifiedAt = /* @__PURE__ */ new Map();
+  const blockedRenudgedFor = /* @__PURE__ */ new Map();
   const resendAttemptedAt = /* @__PURE__ */ new Map();
   const firstTurnUndeliveredBudgetMs = deps.firstTurnUndeliveredBudgetMs ?? DEFAULT_FIRST_TURN_UNDELIVERED_BUDGET_MS;
   const firstTurnResendCooldownMs = deps.firstTurnResendCooldownMs ?? DEFAULT_FIRST_TURN_RESEND_COOLDOWN_MS;
@@ -1888,7 +2096,7 @@ function createDaemon(deps) {
     const next = reduce(cur, event, now());
     if (next !== cur) {
       store.put(next);
-      firePush(deps, project, cur.state, next, event, lastCaptainTurnAt.get(next.id));
+      firePush(deps, project, cur.state, next, event, lastCaptainTurnAt.get(next.id), cur);
     }
     return next;
   }
@@ -2040,6 +2248,8 @@ function createDaemon(deps) {
       }
       const recoveryPromises = [];
       for (const r of store.listAll()) {
+        if (r.state !== "blocked")
+          blockedRenudgedFor.delete(r.id);
         if (TERMINAL_STATES.has(r.state) && t - r.lastHeartbeat > TERMINAL_RECORD_TTL_MS) {
           store.delete(r.project, r.id);
           continue;
@@ -2102,6 +2312,27 @@ function createDaemon(deps) {
             continue;
           }
         }
+        if (r.state === "blocked" && !r.operatorHold) {
+          const threshold = deps.blockedRenudgeMs ?? DEFAULT_BLOCKED_RENUDGE_MS;
+          const blockedFor = t - r.lastHeartbeat;
+          const episodeKey = r.question ?? "";
+          if (blockedFor > threshold && blockedRenudgedFor.get(r.id) !== episodeKey) {
+            blockedRenudgedFor.set(r.id, episodeKey);
+            if (deps.notify) {
+              const tag = crewTag(r);
+              const mins = Math.max(1, Math.round(blockedFor / 6e4));
+              const message = `CREW BLOCKED REMINDER ${tag}: still blocked ~${mins}min (reminder \u2014 same question, not a new one): ${(r.question ?? "(no question)").trim()}`;
+              const synthEvent = { type: "task.blocked", id: r.id, reason: "renudge", question: r.question ?? "" };
+              try {
+                const p = deps.notify({ project: r.project, message, record: r, event: synthEvent });
+                if (p && typeof p.catch === "function")
+                  p.catch(() => {
+                  });
+              } catch {
+              }
+            }
+          }
+        }
         if (r.mode === "interactive" && r.state === "submitted" && !r.firstTurnConfirmedAt) {
           const undeliveredMs = t - r.createdAt;
           if (undeliveredMs > firstTurnUndeliveredBudgetMs) {
@@ -2191,7 +2422,7 @@ function createDaemon(deps) {
     }
   };
 }
-var DEFAULT_FIRST_TURN_UNDELIVERED_BUDGET_MS, DEFAULT_FIRST_TURN_RESEND_COOLDOWN_MS, DEFAULT_TASK_TIMEOUT_MS, TERMINAL_RECORD_TTL_MS, TERMINAL_RECORD_KEEP_PER_PROJECT, ATTENTION_STATES, REAPABLE_SURFACE_STATES, IDLE_DEBOUNCE_MS, KNOWN_EVENT_TYPES;
+var DEFAULT_FIRST_TURN_UNDELIVERED_BUDGET_MS, DEFAULT_FIRST_TURN_RESEND_COOLDOWN_MS, DEFAULT_BLOCKED_RENUDGE_MS, DEFAULT_TASK_TIMEOUT_MS, TERMINAL_RECORD_TTL_MS, TERMINAL_RECORD_KEEP_PER_PROJECT, ATTENTION_STATES, REAPABLE_SURFACE_STATES, IDLE_DEBOUNCE_MS, KNOWN_EVENT_TYPES;
 var init_reduce = __esm({
   "packages/core/dist/daemon/reduce.js"() {
     init_dist();
@@ -2199,6 +2430,7 @@ var init_reduce = __esm({
     init_watchdog();
     DEFAULT_FIRST_TURN_UNDELIVERED_BUDGET_MS = 12e4;
     DEFAULT_FIRST_TURN_RESEND_COOLDOWN_MS = 6e4;
+    DEFAULT_BLOCKED_RENUDGE_MS = 30 * 60 * 1e3;
     DEFAULT_TASK_TIMEOUT_MS = 8 * 60 * 60 * 1e3;
     TERMINAL_RECORD_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
     TERMINAL_RECORD_KEEP_PER_PROJECT = 20;
@@ -2793,8 +3025,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 +3772,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 +3856,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;
   }
 });
 
@@ -4264,8 +4561,11 @@ function buildRouterEnv(creds, model) {
     if (headers)
       env.ANTHROPIC_CUSTOM_HEADERS = headers;
   }
-  if (model)
+  if (model) {
     env.ANTHROPIC_MODEL = model;
+    env.CLAUDE_CODE_SUBAGENT_MODEL = model;
+    env.ANTHROPIC_SMALL_FAST_MODEL = model;
+  }
   return env;
 }
 function mergeClaudeEnvRouterSettings(routerEnv, claudeEnv) {
@@ -5431,8 +5731,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;
@@ -5444,7 +5745,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) {
@@ -6375,16 +6676,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";
     }
   };
 }
@@ -6421,16 +6732,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);
@@ -6485,6 +6799,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);
@@ -6496,8 +6830,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"]
+    ];
   }
 });
 
@@ -6520,6 +6865,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: {} };
@@ -6533,6 +6880,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;
 }
@@ -6546,6 +6906,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)) {
@@ -6568,17 +6964,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;
   }
@@ -6587,8 +6984,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 };
@@ -6611,6 +7008,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 });
     },
@@ -6619,11 +7019,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();
   }
 });
 
@@ -6711,8 +7341,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;
@@ -6728,6 +7360,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")
@@ -6754,9 +7465,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;
@@ -6766,12 +7485,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));
@@ -6958,10 +7673,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");
@@ -7011,21 +7729,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;
@@ -7034,13 +7747,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) {
@@ -7048,7 +7770,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;
@@ -7062,7 +7788,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;
@@ -7073,39 +7799,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) => {
@@ -7122,17 +7931,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"]);
@@ -7177,7 +7992,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";
@@ -7228,7 +8043,7 @@ 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)}`);
@@ -7251,107 +8066,19 @@ function writeTelegramConfig(configPath, opts) {
   };
   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 (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();
   }
 });
 
@@ -7366,6 +8093,7 @@ var init_telegram = __esm({
     init_format();
     init_state();
     init_client();
+    init_inbound_lifecycle();
     init_bridge();
     init_setup();
     init_notify();
@@ -8000,6 +8728,12 @@ function resolveGateMode(env, gate) {
     return fromEnv;
   return gate?.mode && isGateMode(gate.mode) ? gate.mode : "auto";
 }
+function resolveGateEngine(env, gate) {
+  const fromEnv = env.SQUADRANT_GATE_ENGINE;
+  if (fromEnv !== void 0 && isGateEngine(fromEnv))
+    return fromEnv;
+  return gate?.engine && isGateEngine(gate.engine) ? gate.engine : "router";
+}
 function resolveGatePolicy(env, gate) {
   const fromEnv = env.SQUADRANT_GATE_POLICY;
   if (fromEnv !== void 0 && isGatePolicy(fromEnv))
@@ -8384,6 +9118,59 @@ var init_permission_gate = __esm({
   }
 });
 
+// packages/core/dist/auto-gate.js
+import { createAutoGate, projectGateConfig } from "@squadrant-ai/auto-gate";
+function gateForProjection(config) {
+  const gate = config.defaults.gate;
+  if (!gate)
+    return {};
+  const out = {};
+  if (gate.mode)
+    out.mode = gate.mode;
+  if (gate.tools)
+    out.tools = gate.tools;
+  if (gate.deny)
+    out.deny = gate.deny;
+  return out;
+}
+function createSquadrantAutoGate(deps) {
+  const env = deps.env ?? process.env;
+  const taskId = env.SQUADRANT_CREW_TASK_ID;
+  const project = deps.project ?? env.SQUADRANT_CREW_PROJECT;
+  const mode = resolveGateMode(env, deps.config.defaults.gate);
+  const projected = projectGateConfig({ gate: { ...gateForProjection(deps.config), mode } });
+  const enabled = mode === "on";
+  const blockedSignal = async (ctx) => {
+    if (!taskId || !project || !deps.sendBlocked)
+      return;
+    const event = {
+      type: "task.blocked",
+      id: taskId,
+      reason: ctx.reason,
+      question: `crew needs permission to run ${ctx.tool}`
+    };
+    await deps.sendBlocked(project, event);
+  };
+  const host = createAutoGate({
+    config: projected,
+    readIntent: (p) => readUserIntent(p) ?? void 0,
+    blockedSignal,
+    ...deps.decide ? { decide: deps.decide } : {},
+    ...project ? { project } : {},
+    env,
+    log: deps.log
+  });
+  if (!enabled) {
+    return { config: host.config, decideClaudeHookPayload: async () => void 0 };
+  }
+  return host;
+}
+var init_auto_gate = __esm({
+  "packages/core/dist/auto-gate.js"() {
+    init_permission_gate();
+  }
+});
+
 // packages/core/dist/group-dispatch.js
 import { randomUUID as randomUUID4 } from "crypto";
 import { createConnection as createConnection2 } from "net";
@@ -8631,7 +9418,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}`;
 }
@@ -8733,7 +9520,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) {
@@ -8790,10 +9577,11 @@ async function runCrewAnswer(project, name, option, runtime, workspaceId, deps,
   if (!crew) {
     throw new Error(`Crew '${name}' not found for ${project}. Run 'squadrant crew list ${project}'.`);
   }
-  const options = await deps.readModalOptions(crew);
-  if (!options) {
+  const modal = await deps.readModalOptions(crew);
+  if (!modal || modal.options.length === 0) {
     throw new Error(`Crew '${name}' has no interactive option prompt visible right now \u2014 nothing to answer. Read its screen with 'squadrant crew read ${project} ${name}' to check its state.`);
   }
+  const options = modal.options;
   const target = resolveOption(options, option);
   if (opts?.expect && !target.label.toLowerCase().includes(opts.expect.toLowerCase())) {
     throw new Error(`Refusing: option ${target.index} is "${target.label}", which does not contain expected text "${opts.expect}". Option order is model-generated and can shift between renders \u2014 re-check with 'squadrant crew read ${project} ${name}'.
@@ -8805,7 +9593,9 @@ ${describeOptions(options)}`);
   log(`\u2192 selecting ${target.index}. "${target.label}"`);
   const current = options.find((o) => o.highlighted) ?? options[0];
   const steps = target.index - current.index;
-  const key = steps >= 0 ? "Down" : "Up";
+  const forwardKey = modal.axis === "horizontal" ? "Right" : "Down";
+  const backwardKey = modal.axis === "horizontal" ? "Left" : "Up";
+  const key = steps >= 0 ? forwardKey : backwardKey;
   for (let i = 0; i < Math.abs(steps); i++) {
     await runtime.sendKeyToPane(crew, key);
   }
@@ -9170,11 +9960,14 @@ __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,
+  DEFAULT_BLOCKED_RENUDGE_MS: () => DEFAULT_BLOCKED_RENUDGE_MS,
   DEFAULT_FIRST_TURN_RESEND_COOLDOWN_MS: () => DEFAULT_FIRST_TURN_RESEND_COOLDOWN_MS,
   DEFAULT_FIRST_TURN_UNDELIVERED_BUDGET_MS: () => DEFAULT_FIRST_TURN_UNDELIVERED_BUDGET_MS,
   DEFAULT_GATE_DENY_RULES: () => DEFAULT_GATE_DENY_RULES,
@@ -9191,6 +9984,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,
@@ -9203,6 +9997,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,
@@ -9224,15 +10022,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,
@@ -9241,12 +10043,14 @@ __export(dist_exports2, {
   createDirectSurfaceLivenessProbe: () => createDirectSurfaceLivenessProbe,
   createEnsureCaptainAlive: () => createEnsureCaptainAlive,
   createEventsSource: () => createEventsSource,
+  createInboundLifecycle: () => createInboundLifecycle,
   createInteractiveProbe: () => createInteractiveProbe,
   createIsCaptainAlive: () => createIsCaptainAlive,
   createLaunch: () => createLaunch,
   createRouterService: () => createRouterService,
   createRouterShim: () => createRouterShim,
   createRunCommand: () => createRunCommand,
+  createSquadrantAutoGate: () => createSquadrantAutoGate,
   createStore: () => createStore,
   createSurfaceLivenessProbe: () => createSurfaceLivenessProbe,
   createTelegramBridge: () => createTelegramBridge,
@@ -9296,12 +10100,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,
@@ -9323,18 +10131,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,
@@ -9343,6 +10156,7 @@ __export(dist_exports2, {
   parseNotifyPref: () => parseNotifyPref,
   parseProgramArgs: () => parseProgramArgs,
   plistPath: () => plistPath,
+  pollBackoffMs: () => pollBackoffMs,
   pollNewestSessionInDirectory: () => pollNewestSessionInDirectory,
   prepareCaptainRoute: () => prepareCaptainRoute,
   printForeignInstallError: () => printForeignInstallError,
@@ -9350,6 +10164,7 @@ __export(dist_exports2, {
   probeCaptainChannel: () => probeCaptainChannel,
   programArgsBlock: () => programArgsBlock,
   projectHealth: () => projectHealth,
+  pruneTopics: () => pruneTopics,
   purgeExpiredWorkItems: () => purgeExpiredWorkItems,
   readCaptainAddress: () => readCaptainAddress,
   readCursor: () => readCursor,
@@ -9377,6 +10192,7 @@ __export(dist_exports2, {
   resolveCurrentProject: () => resolveCurrentProject,
   resolveGate: () => resolveGate,
   resolveGateDenyRules: () => resolveGateDenyRules,
+  resolveGateEngine: () => resolveGateEngine,
   resolveGateMode: () => resolveGateMode,
   resolveGatePolicy: () => resolveGatePolicy,
   resolveGateTools: () => resolveGateTools,
@@ -9416,9 +10232,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,
@@ -9431,6 +10249,7 @@ __export(dist_exports2, {
   startServer: () => startServer,
   stripBotMention: () => stripBotMention,
   surfaceVerdict: () => surfaceVerdict,
+  telegramPollLockPath: () => telegramPollLockPath,
   timeoutGate: () => timeoutGate,
   titleFor: () => titleFor,
   toControlEvent: () => toControlEvent,
@@ -9479,6 +10298,7 @@ var init_dist2 = __esm({
     init_router_resolution();
     init_captain_router();
     init_permission_gate();
+    init_auto_gate();
     init_restart_daemon();
     init_group_dispatch();
     init_launch_workspace();
@@ -9500,7 +10320,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) {
@@ -9545,11 +10365,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);
@@ -9564,11 +10384,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;
@@ -9577,11 +10397,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;
@@ -10004,7 +10824,7 @@ 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, settingsPath) {
   const driver = registry.getDriver(agentName);
@@ -10034,12 +10854,12 @@ function buildAgentCmd(agentName, registry, role, fresh, permissionMode, model,
     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}`;
       }
     }
@@ -10055,7 +10875,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 } : {},
@@ -10427,7 +11247,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) {
@@ -10446,62 +11266,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);
     }
   }
@@ -12310,6 +13130,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);
@@ -12455,7 +13278,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 = {}) {
@@ -12465,12 +13288,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,
@@ -12492,11 +13315,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 {
@@ -12852,11 +13675,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 {
@@ -12894,11 +13717,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 {
@@ -12911,15 +13734,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 {
@@ -12933,14 +13756,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 {
@@ -12961,15 +13784,46 @@ function parseModalOptions(screen) {
   }
   return options.length > 0 ? options : null;
 }
+function parseOpencodePermissionOptions(screen) {
+  if (!screen)
+    return null;
+  if (!/△\s*Permission required/.test(screen))
+    return null;
+  const lines = screen.split(/\r?\n/);
+  const bar = lines.find((l) => /⇆\s*select/.test(l));
+  if (!bar)
+    return null;
+  let region = bar.split("\u21C6")[0];
+  const fullscreenIdx = region.toLowerCase().lastIndexOf("fullscreen");
+  if (fullscreenIdx !== -1) {
+    region = region.slice(0, fullscreenIdx).replace(/\s+\S+\s*$/, "");
+  }
+  region = region.replace(/^[\s┃│╭╮╰╯|]+/, "").trim();
+  if (!region)
+    return null;
+  const labels = region.split(/\s{2,}/).map((s) => s.trim()).filter(Boolean);
+  if (labels.length === 0)
+    return null;
+  return labels.map((label, i) => ({ index: i + 1, label, highlighted: i === 0 }));
+}
+function parseModal(screen) {
+  const claude = parseModalOptions(screen);
+  if (claude)
+    return { options: claude, axis: "vertical" };
+  const opencode = parseOpencodePermissionOptions(screen);
+  if (opencode)
+    return { options: opencode, axis: "horizontal" };
+  return null;
+}
 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 {
@@ -13002,6 +13856,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;
 }
@@ -13217,10 +14095,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();
@@ -13324,7 +14202,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();
@@ -13342,6 +14220,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;
   }
 });
 
@@ -13466,7 +14348,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) {
@@ -13491,16 +14373,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;
@@ -13508,13 +14390,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 });
     }
   };
 }
@@ -14142,6 +15024,47 @@ function removeCommandHandlers(entries, command) {
   }
   return removed;
 }
+function isForeignAutoGateCommand(command) {
+  if (typeof command !== "string")
+    return false;
+  if (command.includes(FOREIGN_AUTO_GATE_MARKER))
+    return true;
+  const first = command.trim().split(/\s+/)[0] ?? "";
+  return /(^|[/\\])auto-gate$/.test(first);
+}
+function findForeignGateHandlers(entries) {
+  const found = [];
+  for (const entry of entries) {
+    const hooks = entry?.hooks;
+    if (!Array.isArray(hooks))
+      continue;
+    for (const h of hooks) {
+      const cmd = h?.command;
+      if (isForeignAutoGateCommand(cmd))
+        found.push(cmd);
+    }
+  }
+  return found;
+}
+function removeForeignGateHandlers(entries) {
+  const removed = [];
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (!Array.isArray(entry?.hooks))
+      continue;
+    entry.hooks = entry.hooks.filter((h) => {
+      const cmd = h?.command;
+      if (isForeignAutoGateCommand(cmd)) {
+        removed.push(cmd);
+        return false;
+      }
+      return true;
+    });
+    if (entry.hooks.length === 0)
+      entries.splice(i, 1);
+  }
+  return removed;
+}
 function installClaudeHooks(opts = {}) {
   const settingsPath = opts.settingsPath ?? join25(homedir13(), ".claude", "settings.json");
   const hookCmd = opts.hookCmd ?? DEFAULT_HOOK_CMD;
@@ -14179,6 +15102,23 @@ function installClaudeHooks(opts = {}) {
         changed = true;
         migrated.push(`${eventName}/${sub}`);
       }
+      const foreign = findForeignGateHandlers(entries);
+      if (foreign.length > 0) {
+        if (opts.gateMode === "on") {
+          const removed = removeForeignGateHandlers(entries);
+          if (removed.length > 0)
+            changed = true;
+          for (const command2 of removed) {
+            log(`native-hook: removed foreign auto-gate PermissionRequest handler in ${settingsPath} [#P6 \xA715#5]: ${command2}`);
+            opts.recordGateAction?.({ action: "removed-foreign-gate", command: command2 });
+          }
+        } else {
+          for (const command2 of foreign) {
+            log(`native-hook: foreign auto-gate PermissionRequest handler present in ${settingsPath} but squadrant's gate is '${opts.gateMode ?? "auto"}' (not 'on') \u2014 foreign entry left untouched [#P6 \xA715#5]: ${command2}`);
+            opts.recordGateAction?.({ action: "left-foreign-gate", command: command2 });
+          }
+        }
+      }
     }
     const alreadyPresent = entries.some((m) => Array.isArray(m.hooks) && m.hooks.some((h) => typeof h.command === "string" && h.command === command));
     if (!alreadyPresent) {
@@ -14209,11 +15149,55 @@ function installClaudeHooks(opts = {}) {
       changed = true;
     }
   }
+  if (typeof settings.env === "object" && settings.env !== null && !Array.isArray(settings.env)) {
+    if (reconcileSubagentModels(settings.env, log))
+      changed = true;
+  }
   if (changed) {
     writeFile6(settingsPath, JSON.stringify(settings, null, 2));
   }
   return settingsPath;
 }
+function isCustomUpstream(baseUrl) {
+  if (typeof baseUrl !== "string" || baseUrl.length === 0)
+    return false;
+  try {
+    return new URL(baseUrl).hostname.toLowerCase() !== "api.anthropic.com";
+  } catch {
+    return false;
+  }
+}
+function isAnthropicModelId(value) {
+  if (typeof value !== "string")
+    return false;
+  const v2 = value.trim().toLowerCase();
+  return v2 === "sonnet" || v2 === "opus" || v2 === "haiku" || v2.startsWith("claude-");
+}
+function reconcileSubagentModels(env, log) {
+  if (!isCustomUpstream(env.ANTHROPIC_BASE_URL))
+    return false;
+  const model = env.ANTHROPIC_MODEL;
+  if (typeof model !== "string" || model.length === 0)
+    return false;
+  let changed = false;
+  for (const key of [SUBAGENT_MODEL_KEY, SMALL_FAST_MODEL_KEY]) {
+    const current = env[key];
+    if (current === void 0) {
+      env[key] = model;
+      changed = true;
+      log(`native-hook: set ${key}='${model}' to match ANTHROPIC_MODEL on a custom upstream`);
+    } else if (isAnthropicModelId(current)) {
+      if (current !== model) {
+        env[key] = model;
+        changed = true;
+        log(`native-hook: aligned ${key} '${String(current)}' \u2192 '${model}' for a custom upstream`);
+      }
+    } else {
+      log(`native-hook: ${key} '${String(current)}' is a custom model id \u2014 left untouched`);
+    }
+  }
+  return changed;
+}
 function mapSubToLifecycle(sub) {
   switch (sub) {
     case "session-start":
@@ -14263,7 +15247,7 @@ function defaultWriteFile(path39, content) {
   mkdirSync8(path39.replace(/\/[^/]+$/, ""), { recursive: true });
   writeFileSync11(path39, content, "utf-8");
 }
-var CLAUDE_HOOK_EVENTS, DEFAULT_HOOK_CMD, GATE_HOOK_CMD, NativeHookSource;
+var CLAUDE_HOOK_EVENTS, DEFAULT_HOOK_CMD, GATE_HOOK_CMD, FOREIGN_AUTO_GATE_MARKER, SUBAGENT_MODEL_KEY, SMALL_FAST_MODEL_KEY, NativeHookSource;
 var init_native_hook_source = __esm({
   "packages/workspaces/dist/native-hooks/native-hook-source.js"() {
     CLAUDE_HOOK_EVENTS = [
@@ -14283,6 +15267,9 @@ var init_native_hook_source = __esm({
     ];
     DEFAULT_HOOK_CMD = "squadrant hooks";
     GATE_HOOK_CMD = "squadrant gate";
+    FOREIGN_AUTO_GATE_MARKER = "auto-gate-managed";
+    SUBAGENT_MODEL_KEY = "CLAUDE_CODE_SUBAGENT_MODEL";
+    SMALL_FAST_MODEL_KEY = "ANTHROPIC_SMALL_FAST_MODEL";
     NativeHookSource = class {
       name = "native-hook";
       hookInstall;
@@ -14412,15 +15399,15 @@ 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) ?? "";
-  return parseModalOptions(screen);
+  return parseModal(screen);
 }
 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);
@@ -14673,9 +15660,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,
@@ -14784,7 +15771,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
@@ -14794,7 +15781,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";
@@ -14898,7 +15885,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 {
@@ -14909,7 +15896,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"
       )
@@ -14955,7 +15942,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;
@@ -14991,7 +15978,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(
@@ -15099,7 +16086,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"
@@ -15183,7 +16170,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";
@@ -15400,25 +16387,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);
     }
   }
 }
@@ -15435,16 +16454,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:"));
@@ -15464,8 +16537,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) {
@@ -15473,45 +16546,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"));
@@ -15591,7 +16695,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) {
@@ -15606,20 +16710,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);
     }
   }
 }
@@ -15655,7 +16759,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.
 `));
@@ -15724,19 +16828,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("");
@@ -15804,7 +16908,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";
@@ -15815,7 +16919,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.");
@@ -17133,7 +18237,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";
@@ -17170,7 +18274,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 } : {},
@@ -17277,7 +18381,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
@@ -17433,7 +18537,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 = "```";
@@ -17460,8 +18564,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 = [];
@@ -17481,6 +18585,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) {
@@ -17946,6 +19051,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" };
@@ -18074,7 +19197,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("");
@@ -18123,6 +19247,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");
@@ -18364,6 +19489,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)}}
@@ -18377,6 +19513,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"/>';}
@@ -18389,9 +19526,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';}
@@ -18400,6 +19547,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();
@@ -18422,7 +19574,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" });
@@ -18435,6 +19680,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);
@@ -18450,6 +19698,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();
@@ -18475,6 +19736,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) => {
@@ -18489,17 +19766,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());
     })
   };
@@ -18509,7 +19802,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.");
@@ -18592,8 +19885,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";
@@ -18724,7 +20017,7 @@ 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);
 }
@@ -18921,12 +20214,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}`));
@@ -18964,7 +20257,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}`));
@@ -18988,7 +20281,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}`));
@@ -19124,24 +20417,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 {};
   }
@@ -19187,7 +20480,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."));
@@ -19589,7 +20882,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) {
@@ -19601,7 +20894,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();
@@ -19798,12 +21091,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;
@@ -19891,7 +21184,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;
   }
@@ -19936,14 +21229,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";
@@ -20183,8 +21476,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,
@@ -20216,7 +21509,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());
@@ -20232,7 +21525,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?`);
       }
@@ -20268,7 +21561,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";
@@ -20277,23 +21570,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,
@@ -20319,7 +21612,7 @@ async function sharedReceiptListener() {
     // must never be the reason we refuse to start.
     unlinkStale: (p) => {
       try {
-        fs27.unlinkSync(p);
+        fs28.unlinkSync(p);
       } catch {
       }
     },
@@ -20389,7 +21682,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, {
@@ -20398,7 +21691,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,
@@ -20477,7 +21770,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";
@@ -20521,7 +21814,7 @@ function effortScopeLabel(projectName) {
 }
 function canonical(p) {
   try {
-    return fs28.realpathSync(p);
+    return fs29.realpathSync(p);
   } catch {
     return path31.resolve(p);
   }
@@ -20583,7 +21876,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";
@@ -20639,7 +21932,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);
   }
@@ -20707,7 +22000,7 @@ function buildRoleReport(role, sessions) {
 }
 async function readdirSafe(dir) {
   try {
-    return await fs29.promises.readdir(dir);
+    return await fs30.promises.readdir(dir);
   } catch {
     return [];
   }
@@ -20874,12 +22167,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) => {
@@ -21208,7 +22501,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
@@ -21260,15 +22553,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));
@@ -21293,6 +22586,30 @@ init_dist();
 init_dist3();
 import { Command as Command32 } from "commander";
 var SOCK4 = DAEMON_SOCK_PATH;
+async function runAutoGateClaudeHook(o) {
+  const make = o.deps.createAutoGate ?? createSquadrantAutoGate;
+  const autoGate = make({
+    config: o.config,
+    env: o.env,
+    ...o.project ? { project: o.project } : {},
+    ...o.deps.sendEvent ? { sendBlocked: o.deps.sendEvent } : {},
+    log: o.log
+  });
+  const out = await autoGate.decideClaudeHookPayload(o.deps.rawPayload ?? "");
+  if (out === void 0) {
+    o.log("gate auto-gate: ask/yield \u2014 normal dialog");
+    return { decision: "ask", tier: 2, reason: "auto-gate: ask/yield" };
+  }
+  o.stdout(out);
+  let decision = "allow";
+  try {
+    const parsed = JSON.parse(out);
+    if (parsed?.hookSpecificOutput?.decision?.behavior === "deny") decision = "deny";
+  } catch {
+  }
+  o.log(`gate auto-gate ${decision}`);
+  return { decision, tier: 2, reason: "auto-gate" };
+}
 async function runGatePermissionRequest(deps) {
   const env = deps.env ?? process.env;
   const payload = deps.payload ?? {};
@@ -21307,6 +22624,10 @@ async function runGatePermissionRequest(deps) {
   const log = deps.log ?? ((m) => process.stderr.write(`[squadrant] ${m}
 `));
   const config = deps.config ?? (deps.loadConfigFn ?? loadConfig)();
+  const gate = config.defaults.gate;
+  if (resolveGateMode(env, gate) === "on" && resolveGateEngine(env, gate) === "auto-gate") {
+    return runAutoGateClaudeHook({ deps, env, config, project, stdout, log });
+  }
   const cwd = deps.cwd ?? (typeof p.cwd === "string" && p.cwd ? p.cwd : env.SQUADRANT_CREW_CWD ?? process.cwd());
   const transcriptPath = typeof p.transcript_path === "string" && p.transcript_path ? p.transcript_path : deriveTranscriptPath(
     typeof p.session_id === "string" ? p.session_id : "",
@@ -21370,6 +22691,7 @@ function gateCommand() {
     }
     await runGatePermissionRequest({
       payload,
+      rawPayload: stdin,
       env: process.env,
       stdout: (s) => process.stdout.write(s),
       sendEvent: async (project, ev) => {
@@ -21452,6 +22774,7 @@ function hooksCommand() {
     if (sub === "permission-request") {
       await runGatePermissionRequest({
         payload,
+        rawPayload: stdin,
         env: process.env,
         stdout: (s) => process.stdout.write(s),
         sendEvent: async (project2, ev2) => {
@@ -21645,7 +22968,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
@@ -21785,7 +23108,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;
@@ -21856,7 +23179,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) {
@@ -21870,7 +23193,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 });
@@ -21913,7 +23236,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;
@@ -22022,27 +23345,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;
     }
@@ -22385,15 +23708,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}
@@ -22403,7 +23726,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)) {