squadrant 0.21.0 → 0.22.0

package/dist/squadrantd.js

@@ -135,12 +135,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: {
@@ -182,7 +177,7 @@ function saveConfig(config, configPath = DEFAULT_CONFIG_PATH) {
 function resolveHome(p) {
   return p.startsWith("~") ? p.replace("~", os.homedir()) : p;
 }
-var GATE_MODES, GATE_POLICIES, DEFAULT_CONFIG_PATH, CONFIG_DIR, DAEMON_SOCK_PATH;
+var GATE_MODES, GATE_POLICIES, DEFAULT_CONFIG_PATH, CONFIG_DIR, DAEMON_SOCK_PATH, DEFAULT_CREW_ROUTING_RULES;
 var init_config = __esm({
   "packages/shared/dist/config.js"() {
     init_config_io();
@@ -191,6 +186,19 @@ var init_config = __esm({
     DEFAULT_CONFIG_PATH = process.env.SQUADRANT_CONFIG || path2.join(os.homedir(), ".config", "squadrant", "config.json");
     CONFIG_DIR = path2.dirname(DEFAULT_CONFIG_PATH);
     DAEMON_SOCK_PATH = path2.join(CONFIG_DIR, "squadrant.sock");
+    DEFAULT_CREW_ROUTING_RULES = [
+      { tier: "extreme", match: "redesign|architect|rewrite|from scratch|deep reasoning", agent: "claude", model: "opus" },
+      { tier: "hard", match: "refactor|migrate|implement|feature|daemon|control-plane", agent: "claude", model: "sonnet" },
+      { tier: "mobile", match: "mobile|ios|swift|android|kotlin|react native", agent: "codex" },
+      { tier: "daily", match: "typo|rename|bump|docs|comment|lint|format", agent: "opencode" }
+    ];
+  }
+});
+
+// packages/shared/dist/provider-preset.js
+var init_provider_preset = __esm({
+  "packages/shared/dist/provider-preset.js"() {
+    init_config();
   }
 });
 
@@ -790,6 +798,7 @@ var init_daemon_keys = __esm({
 var init_dist = __esm({
   "packages/shared/dist/index.js"() {
     init_config();
+    init_provider_preset();
     init_project_config();
     init_effort();
     init_router_model();
@@ -2027,8 +2036,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;
@@ -2774,6 +2783,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 {
@@ -2796,11 +2867,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;
   }
 });
 
@@ -3471,6 +3545,11 @@ function assertBackendUsable(o) {
 function shouldBuildRouterService(router, isVitest) {
   return !!router && !isVitest;
 }
+function claudeEnvShadowsRouter(claudeEnv) {
+  if (!claudeEnv)
+    return [];
+  return Object.keys(claudeEnv).filter((key) => key.startsWith("ANTHROPIC_"));
+}
 var init_router_resolution = __esm({
   "packages/core/dist/router-resolution.js"() {
     init_dist();
@@ -3497,6 +3576,14 @@ function buildRouterEnv(creds, model) {
     env.ANTHROPIC_MODEL = model;
   return env;
 }
+function mergeClaudeEnvRouterSettings(routerEnv, claudeEnv) {
+  const merged = { ...routerEnv };
+  for (const [key, value] of Object.entries(claudeEnv ?? {})) {
+    if (!key.startsWith("ANTHROPIC_"))
+      merged[key] = value;
+  }
+  return merged;
+}
 function formatCustomHeaders(headers) {
   const entries = Object.entries(headers ?? {});
   if (entries.length === 0)
@@ -3810,10 +3897,18 @@ async function runCrewSpawn(input, config, deps) {
   if (agentName === "claude") {
     let routerEnv = {};
     if (backend !== "native") {
+      if (!deps.writeRouterSettings) {
+        throw new Error(`backend '${backend}' requires a per-spawn --settings writer to outrank defaults.claudeEnv, but the spawn path has none \u2014 refusing to launch a routed session that would silently bypass the router shim`);
+      }
       if (!deps.routerCredentials) {
         throw new Error(`backend '${backend}' requires router credentials, but the spawn path has no daemon credentials provider`);
       }
       routerEnv = buildRouterEnv(await deps.routerCredentials({ project: input.project, backend }), crewModel);
+      const shadowed = claudeEnvShadowsRouter(config.defaults.claudeEnv);
+      if (shadowed.length > 0) {
+        process.stderr.write(`\u26A0\uFE0F  backend '${backend}' selected but defaults.claudeEnv sets ${shadowed.join(", ")} \u2014 these would shadow the router shim. Overriding via a per-spawn --settings env block (outranks ~/.claude/settings.json).
+`);
+      }
     }
     ensureSocksDir();
     const messagingSocketPath = path9.join(CC_SOCKS_DIR, `squadrant-${randomUUID3()}.sock`);
@@ -3826,6 +3921,12 @@ async function runCrewSpawn(input, config, deps) {
       name,
       messagingSocketPath
     });
+    const routerSettingsPath = Object.keys(routerEnv).length > 0 ? deps.writeRouterSettings({
+      stateRoot: STATE_ROOT,
+      project: input.project,
+      taskId: rec.id,
+      env: mergeClaudeEnvRouterSettings(routerEnv, config.defaults.claudeEnv)
+    }) : void 0;
     let hooksInstalled = false;
     try {
       deps.writeSettingsLocal(spawnCwd);
@@ -3841,18 +3942,25 @@ async function runCrewSpawn(input, config, deps) {
       messagingSocketPath,
       // Permission mode is config-driven so squadrant can default crews to 'auto'
       // or keep the semi-automatic 'acceptEdits' gate. Falls back to 'acceptEdits'.
-      permissionMode: config.defaults.permissions?.crew ?? "acceptEdits",
+      // #772: a router-backed crew MUST use 'default' — 'auto' makes the built-in
+      // Sonnet-5 classifier own PermissionRequest and the gate yields, which is
+      // exactly the fail-closed dead end U7 exists to fix. The rubric owns the
+      // permission mode for a routed spawn; the operator's config cannot override
+      // it back into the broken path.
+      permissionMode: backend !== "native" ? "default" : config.defaults.permissions?.crew ?? "acceptEdits",
       // #708: self-describing name so ListAgents/the registry can tell this
       // crew apart from an unrelated session instead of an auto-derived cwd
       // basename (only the claude driver reads this — other agents ignore it).
       sessionName: crewSessionName(input.project, name),
       ...crewModel ? { model: crewModel } : {},
-      ...crewThinking ? { thinking: crewThinking } : {}
+      ...crewThinking ? { thinking: crewThinking } : {},
+      ...routerSettingsPath ? { settingsPath: routerSettingsPath } : {}
     });
     const direction2 = input.direction ?? "tab";
     const title2 = titleFor(input.project, name);
     const pane2 = await deps.runtime.newPane({ workspaceId: captain.id, direction: direction2, title: title2 });
-    const envPrefix = `SQUADRANT_CREW_TASK_ID=${rec.id} SQUADRANT_CREW_PROJECT=${input.project}`;
+    const gateEnv = backend !== "native" ? " SQUADRANT_GATE=on" : "";
+    const envPrefix = `SQUADRANT_CREW_TASK_ID=${rec.id} SQUADRANT_CREW_PROJECT=${input.project}${gateEnv}`;
     const routerPrefix = Object.keys(routerEnv).length > 0 ? ` ${renderEnvAssignments(routerEnv)}` : "";
     await deps.runtime.sendToPane(pane2, `cd ${shellQuote(spawnCwd)} && ${envPrefix}${routerPrefix} ${niceCrewCommand(cliCommand2)}`);
     const preLaunchScreen = await deps.runtime.readPaneScreen(pane2) ?? "";
@@ -4631,8 +4739,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;
@@ -4644,7 +4753,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) {
@@ -5575,16 +5684,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";
     }
   };
 }
@@ -5621,16 +5740,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);
@@ -5685,6 +5807,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);
@@ -5696,8 +5838,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"]
+    ];
   }
 });
 
@@ -5720,6 +5873,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: {} };
@@ -5733,6 +5888,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;
 }
@@ -5746,6 +5914,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)) {
@@ -5768,17 +5972,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;
   }
@@ -5787,8 +5992,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 };
@@ -5811,6 +6016,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 });
     },
@@ -5819,11 +6027,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();
   }
 });
 
@@ -5911,8 +6349,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;
@@ -5928,6 +6368,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")
@@ -5954,9 +6473,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;
@@ -5966,12 +6493,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));
@@ -6158,10 +6681,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");
@@ -6211,21 +6737,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;
@@ -6234,13 +6755,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) {
@@ -6248,7 +6778,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;
@@ -6262,7 +6796,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;
@@ -6273,39 +6807,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) => {
@@ -6322,17 +6939,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"]);
@@ -6377,7 +7000,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";
@@ -6428,7 +7051,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)}`);
@@ -6467,94 +7090,6 @@ var init_setup = __esm({
   }
 });
 
-// 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 };
-}
-var init_notify = __esm({
-  "packages/core/dist/telegram/notify.js"() {
-    init_dist();
-    init_state();
-    init_format();
-  }
-});
-
 // packages/core/dist/telegram/index.js
 var init_telegram = __esm({
   "packages/core/dist/telegram/index.js"() {
@@ -6566,6 +7101,7 @@ var init_telegram = __esm({
     init_format();
     init_state();
     init_client();
+    init_inbound_lifecycle();
     init_bridge();
     init_setup();
     init_notify();
@@ -6760,6 +7296,26 @@ function writeJson(res, status, body) {
   res.writeHead(status, { "content-type": "application/json" });
   res.end(JSON.stringify(body));
 }
+function pathnameOf(url) {
+  if (!url)
+    return "";
+  const q = url.indexOf("?");
+  return q === -1 ? url : url.slice(0, q);
+}
+function modelsList(ids) {
+  const data = ids.map((id) => ({
+    type: "model",
+    id,
+    display_name: id,
+    created_at: "1970-01-01T00:00:00Z"
+  }));
+  return {
+    data,
+    has_more: false,
+    first_id: ids[0] ?? null,
+    last_id: ids[ids.length - 1] ?? null
+  };
+}
 function buildUpstreamHeaders(req, upstream, stream) {
   const headers = {
     "content-type": "application/json",
@@ -6788,6 +7344,7 @@ function createRouterShim(opts) {
   let lastError;
   let upstreamReachable = true;
   const upstreamUrl = joinUrl(opts.upstream.baseUrl, "/v1/messages");
+  const advertisedModels = new Set(opts.models ?? []);
   function emitUsage(u) {
     try {
       opts.onUsage?.(u);
@@ -6817,6 +7374,8 @@ function createRouterShim(opts) {
     const body = parsed;
     const wantsStream = body.stream === true;
     const model = typeof body.model === "string" ? body.model : void 0;
+    if (model)
+      advertisedModels.add(model);
     const sanitized = sanitizeRequest(body, opts.upstream);
     let upstreamRes;
     try {
@@ -6889,8 +7448,20 @@ function createRouterShim(opts) {
       emitUsage(usage2);
     writeJson(res, upstreamRes.status, upstreamBody);
   }
+  async function handleCountTokens(req, res) {
+    let text;
+    try {
+      text = await readBody(req);
+    } catch {
+      const e = anthropicError(400, "invalid_request_error", "malformed request body");
+      writeJson(res, e.status, e.body);
+      return;
+    }
+    writeJson(res, 200, { input_tokens: Math.max(1, Math.ceil(text.length / 4)) });
+  }
   function handler(req, res) {
-    if (req.method === "POST" && req.url === "/v1/messages") {
+    const path23 = pathnameOf(req.url);
+    if (req.method === "POST" && path23 === "/v1/messages") {
       void handleMessages(req, res).catch((err) => {
         log(`router internal error: ${err instanceof Error ? err.message : String(err)}`);
         if (!res.headersSent) {
@@ -6902,7 +7473,18 @@ function createRouterShim(opts) {
       });
       return;
     }
-    if (req.method === "GET" && req.url === "/healthz") {
+    if (req.method === "POST" && path23 === "/v1/messages/count_tokens") {
+      void handleCountTokens(req, res).catch(() => {
+        if (!res.headersSent)
+          writeJson(res, 502, anthropicError(502, "api_error", "router internal error").body);
+      });
+      return;
+    }
+    if (req.method === "GET" && path23 === "/v1/models") {
+      writeJson(res, 200, modelsList([...advertisedModels]));
+      return;
+    }
+    if (req.method === "GET" && path23 === "/healthz") {
       writeJson(res, 200, { ready: server?.listening === true, upstreamReachable, lastError });
       return;
     }
@@ -7027,12 +7609,17 @@ function createRouterService(router, projects, deps = {}) {
     tokenByProject.set(p, t);
     projectTokens.set(t, p);
   }
+  const models = [
+    ...deps.models ?? [],
+    ...Object.values(router.models ?? {}).map((m) => m.upstream)
+  ];
   const ledger = createUsageLedger();
   const shim = createRouterShim({
     upstream,
     projectTokens,
     port: router.port ?? 0,
     log,
+    models,
     onUsage: (u) => ledger.record(u),
     ...deps.fetch ? { fetch: deps.fetch } : {}
   });
@@ -7095,12 +7682,53 @@ var init_router = __esm({
   }
 });
 
+// packages/core/dist/captain-router.js
+async function prepareCaptainRoute(o) {
+  assertBackendUsable({ backend: o.backend, agent: o.agentName, router: o.config.defaults.router });
+  if (o.backend === "native") {
+    return { backend: "native", model: o.model, permissionMode: o.configuredPermissionMode, env: {} };
+  }
+  if (!o.deps.routerCredentials) {
+    throw new Error(`captain launch: backend '${o.backend}' requires router credentials from the daemon, but this launch path has no credentials provider`);
+  }
+  if (!o.deps.writeRouterSettings) {
+    throw new Error(`captain launch: backend '${o.backend}' requires a per-spawn --settings writer to outrank defaults.claudeEnv, but this launch path has none \u2014 refusing to launch a routed captain that would silently bypass the router shim`);
+  }
+  const model = resolveRouterModel(o.model, o.agentName, o.config.defaults.router);
+  const creds = await o.deps.routerCredentials({ project: o.project, backend: o.backend });
+  const routerEnv = buildRouterEnv(creds, model);
+  const shadowed = claudeEnvShadowsRouter(o.config.defaults.claudeEnv);
+  if (shadowed.length > 0) {
+    o.warn?.(`backend '${o.backend}' selected but defaults.claudeEnv sets ${shadowed.join(", ")} \u2014 these would shadow the router shim. Overriding via a per-spawn --settings env block (outranks ~/.claude/settings.json).`);
+  }
+  const settingsPath = o.deps.writeRouterSettings({
+    stateRoot: o.stateRoot,
+    project: o.project,
+    taskId: "captain",
+    env: mergeClaudeEnvRouterSettings(routerEnv, o.config.defaults.claudeEnv)
+  });
+  return {
+    backend: o.backend,
+    model,
+    permissionMode: "default",
+    env: { ...routerEnv, SQUADRANT_GATE: "on" },
+    settingsPath
+  };
+}
+var init_captain_router = __esm({
+  "packages/core/dist/captain-router.js"() {
+    init_dist();
+    init_router_resolution();
+    init_env();
+  }
+});
+
 // packages/core/dist/permission-gate.js
 import { createHash } from "crypto";
 import { mkdirSync as mkdirSync7, readFileSync as readFileSync11, renameSync as renameSync4, writeFileSync as writeFileSync10, unlinkSync as unlinkSync4 } from "fs";
 import { dirname as dirname5, join as join15 } from "path";
 function isGateSession(env) {
-  return Boolean(env.SQUADRANT_CREW_TASK_ID) || env[SIDE_SESSION_ENV] === "1";
+  return Boolean(env.SQUADRANT_CREW_TASK_ID) || env[SIDE_SESSION_ENV] === "1" || env.SQUADRANT_ROLE === "captain";
 }
 function resolveGateMode(env, gate) {
   const fromEnv = env.SQUADRANT_GATE;
@@ -7296,7 +7924,15 @@ async function callClassifier(o) {
       return "ask";
     }
     const data = await res.json();
+    if (data?.stop_reason === "max_tokens") {
+      o.log?.("gate: classifier exhausted max_tokens before a verdict \u2014 asking");
+      return "ask";
+    }
     const text = Array.isArray(data?.content) ? data.content.filter((b) => b?.type === "text" && typeof b.text === "string").map((b) => b.text).join(" ") : "";
+    if (!text.trim()) {
+      o.log?.("gate: classifier returned no text verdict \u2014 asking");
+      return "ask";
+    }
     return parseClassifierVerdict(text);
   } catch (e) {
     o.log?.(`gate: classifier unavailable (${e.message}) \u2014 asking`);
@@ -7315,7 +7951,7 @@ ${toolPayload}`).digest("hex");
 }
 async function evaluatePermissionRequest(input) {
   if (!isGateSession(input.env)) {
-    return { decision: "yield", reason: "not a squadrant crew/side session" };
+    return { decision: "yield", reason: "not a squadrant crew/side/captain session" };
   }
   const gate = input.config.defaults.gate;
   const mode = resolveGateMode(input.env, gate);
@@ -7401,7 +8037,7 @@ var init_permission_gate = __esm({
     DEFAULT_CACHE_TTL_MS = 10 * 60 * 1e3;
     DEFAULT_CACHE_MAX_ENTRIES = 500;
     DEFAULT_CLASSIFIER_TIMEOUT_MS = 5e3;
-    CLASSIFIER_MAX_TOKENS = 8;
+    CLASSIFIER_MAX_TOKENS = 256;
     MAX_PAYLOAD_CHARS = 2e3;
     DEFAULT_GATE_DENY_RULES = [
       // Flag-order-agnostic: both recursive and force must be present, in any order,
@@ -7731,7 +8367,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}`;
 }
@@ -7833,7 +8469,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) {
@@ -8270,8 +8906,10 @@ __export(dist_exports, {
   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,
@@ -8291,6 +8929,7 @@ __export(dist_exports, {
   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,
@@ -8303,6 +8942,10 @@ __export(dist_exports, {
   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,
@@ -8324,14 +8967,19 @@ __export(dist_exports, {
   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,
@@ -8340,6 +8988,7 @@ __export(dist_exports, {
   createDirectSurfaceLivenessProbe: () => createDirectSurfaceLivenessProbe,
   createEnsureCaptainAlive: () => createEnsureCaptainAlive,
   createEventsSource: () => createEventsSource,
+  createInboundLifecycle: () => createInboundLifecycle,
   createInteractiveProbe: () => createInteractiveProbe,
   createIsCaptainAlive: () => createIsCaptainAlive,
   createLaunch: () => createLaunch,
@@ -8395,12 +9044,16 @@ __export(dist_exports, {
   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,
@@ -8422,17 +9075,23 @@ __export(dist_exports, {
   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,
@@ -8441,12 +9100,15 @@ __export(dist_exports, {
   parseNotifyPref: () => parseNotifyPref,
   parseProgramArgs: () => parseProgramArgs,
   plistPath: () => plistPath,
+  pollBackoffMs: () => pollBackoffMs,
   pollNewestSessionInDirectory: () => pollNewestSessionInDirectory,
+  prepareCaptainRoute: () => prepareCaptainRoute,
   printForeignInstallError: () => printForeignInstallError,
   printVersionUpgradeNotice: () => printVersionUpgradeNotice,
   probeCaptainChannel: () => probeCaptainChannel,
   programArgsBlock: () => programArgsBlock,
   projectHealth: () => projectHealth,
+  pruneTopics: () => pruneTopics,
   purgeExpiredWorkItems: () => purgeExpiredWorkItems,
   readCaptainAddress: () => readCaptainAddress,
   readCursor: () => readCursor,
@@ -8513,9 +9175,11 @@ __export(dist_exports, {
   saveSessions: () => saveSessions,
   saveState: () => saveState,
   screenHasSplashMarker: () => screenHasSplashMarker,
+  screenHash: () => screenHash,
   sendRequest: () => sendRequest,
   setLastUserId: () => setLastUserId,
   setNotify: () => setNotify,
+  setPending: () => setPending,
   setTopic: () => setTopic,
   shellQuote: () => shellQuote,
   shouldBuildRouterService: () => shouldBuildRouterService,
@@ -8528,6 +9192,7 @@ __export(dist_exports, {
   startServer: () => startServer,
   stripBotMention: () => stripBotMention,
   surfaceVerdict: () => surfaceVerdict,
+  telegramPollLockPath: () => telegramPollLockPath,
   timeoutGate: () => timeoutGate,
   titleFor: () => titleFor,
   toControlEvent: () => toControlEvent,
@@ -8574,6 +9239,7 @@ var init_dist2 = __esm({
     init_router();
     init_crew_routing();
     init_router_resolution();
+    init_captain_router();
     init_permission_gate();
     init_restart_daemon();
     init_group_dispatch();
@@ -8620,7 +9286,7 @@ import { readdirSync as readdirSync4, readFileSync as readFileSync12 } from "fs"
 import { join as join18 } from "path";
 
 // 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";
 var CLAUDE_SESSIONS_DIR = join17(homedir7(), ".claude", "sessions");
@@ -8665,11 +9331,11 @@ function toLifecycleSnapshot(entry, taskId, alive, now) {
 function readClaudeStatusBySocketPath(socketPath) {
   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 === socketPath);
   if (!entry)
     return void 0;
@@ -8692,7 +9358,7 @@ import { homedir as homedir8 } from "os";
 var SQUADRANT_STATE_DIR = join19(homedir8(), ".config", "squadrant", "state");
 
 // packages/agents/dist/drivers/launch-cmd.js
-import fs14 from "fs";
+import fs15 from "fs";
 import path13 from "path";
 
 // packages/agents/dist/projection/cursor.js
@@ -8716,7 +9382,7 @@ import path17 from "path";
 import os9 from "os";
 
 // packages/agents/dist/projection/opencode-skills.js
-import fs15 from "fs";
+import fs16 from "fs";
 import os10 from "os";
 import path18 from "path";
 var OPENCODE_SKILL_MARKER = ".squadrant-managed";
@@ -8738,62 +9404,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);
     }
   }
@@ -9967,6 +10633,9 @@ var ClaudePeerChannel = class {
         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);
@@ -10105,7 +10774,7 @@ var ClaudeReceiptListener = class {
 };
 
 // packages/agents/dist/claude/api-key-approval.js
-import fs16 from "fs";
+import fs17 from "fs";
 import os12 from "os";
 import path20 from "path";
 
@@ -10347,11 +11016,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 {
@@ -10389,11 +11058,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 {
@@ -10406,15 +11075,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 {
@@ -10431,11 +11100,11 @@ function readInputBoxRaw(screen, opts) {
   if (!screen)
     return null;
   const lines = screen.split(/\r?\n/);
-  const HR_RE = /^\s*─{10,}\s*$/;
+  const HR_RE2 = /^\s*─{10,}\s*$/;
   let bottomHR = -1;
   let topHR = -1;
   for (let i = lines.length - 1; i >= 0; i--) {
-    if (HR_RE.test(lines[i])) {
+    if (HR_RE2.test(lines[i])) {
       if (bottomHR === -1)
         bottomHR = i;
       else {
@@ -10465,6 +11134,34 @@ function classifyStartupSurface(screen) {
     return "idle";
   return "loading";
 }
+var OC_BOX_BOTTOM_RE = /^\s*╹[▀]{6,}\s*$/;
+var OC_BOX_SIDE_RE = /^\s*┃/;
+var OC_BOX_STATUS_RE = /^Build\s*·/i;
+var OC_BUSY_RE = /esc\s+interrupt/i;
+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;
 }
@@ -10680,10 +11377,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();
@@ -10877,7 +11574,7 @@ var NotifierRegistry = class {
 };
 
 // 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";
 
@@ -11673,7 +12370,7 @@ async function settleInputBox(runtime, pane) {
 }
 async function confirmedSendToPane(runtime, pane, message) {
   const preSendScreen = await runtime.readPaneScreen(pane) ?? "";
-  if (hasModalOptionList(preSendScreen)) {
+  if (hasModalOptionList2(preSendScreen)) {
     return { delivered: false, blockedByModal: true };
   }
   await runtime.pasteToPane(pane, message);
@@ -11776,7 +12473,7 @@ async function maybeBroadcastDaemonRestart(opts) {
 
 // packages/cli/src/lib/captain-channel-factory.ts
 import { createServer as createServer4, connect as netConnect } from "net";
-import fs18 from "fs";
+import fs19 from "fs";
 import { join as join26 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 import chalk2 from "chalk";
@@ -11785,15 +12482,15 @@ var shared;
 var registryEntryPath = () => join26(CLAUDE_SESSIONS_DIR, `${process.pid}.json`);
 function unregisterSenderIdentity() {
   try {
-    fs18.unlinkSync(registryEntryPath());
+    fs19.unlinkSync(registryEntryPath());
   } catch {
   }
 }
 function registerSenderIdentity(socketPath) {
   try {
     unregisterSenderIdentity();
-    fs18.mkdirSync(CLAUDE_SESSIONS_DIR, { recursive: true });
-    fs18.writeFileSync(
+    fs19.mkdirSync(CLAUDE_SESSIONS_DIR, { recursive: true });
+    fs19.writeFileSync(
       registryEntryPath(),
       JSON.stringify({
         pid: process.pid,
@@ -11819,7 +12516,7 @@ async function sharedReceiptListener() {
     // must never be the reason we refuse to start.
     unlinkStale: (p) => {
       try {
-        fs18.unlinkSync(p);
+        fs19.unlinkSync(p);
       } catch {
       }
     },
@@ -11916,6 +12613,33 @@ function buildTelegramBridge(cfg, stateRoot, log, deliverInbound, usageFor) {
   });
   const runCommand = createRunCommand(CLI_BIN);
   const sendReply = (threadId, text, replyMarkup) => client.sendMessage(cfg.supergroupId, threadId, text, replyMarkup);
+  const lifecycle = createInboundLifecycle({
+    stateRoot,
+    cfg: { supergroupId: cfg.supergroupId },
+    sendChatAction: (chatId, threadId, action) => client.sendChatAction(chatId, threadId, action),
+    sendReply: async (threadId, text) => {
+      await client.sendMessage(cfg.supergroupId, threadId, text);
+    },
+    readPane: createCaptainPaneReader(
+      new DaemonCmux(createCmuxDriver()),
+      (project) => {
+        try {
+          return loadConfig().projects[project]?.captainName ?? `${project}-captain`;
+        } catch {
+          return `${project}-captain`;
+        }
+      },
+      {
+        log,
+        // #839 staleness, measured for real: cmux has no pane activity
+        // timestamp, so the reader hashes the screen and asks the persisted
+        // pending store how long that exact screen has been up. Persisted, so a
+        // daemon restart cannot hand a dead captain a fresh 15 minutes.
+        noteScreen: (project, hash) => notePaneScreen(stateRoot, project, hash, Date.now())
+      }
+    ),
+    log
+  });
   return createTelegramBridge({
     cfg,
     stateRoot,
@@ -11927,7 +12651,20 @@ function buildTelegramBridge(cfg, stateRoot, log, deliverInbound, usageFor) {
     runCommand,
     sendReply,
     deliverInbound,
-    usageFor
+    usageFor,
+    lifecycle,
+    // #321 registry prune. Read the file directly rather than via loadConfig():
+    // loadConfig swallows every failure and returns defaults, so an unreadable
+    // config would look like "no projects registered" and the prune would delete
+    // every link on the machine. `undefined` correctly means "don't prune".
+    registeredProjects: () => {
+      try {
+        const parsed = JSON.parse(readFileSync19(join27(dirname6(stateRoot), "config.json"), "utf8"));
+        return Object.keys(parsed.projects ?? {});
+      } catch {
+        return void 0;
+      }
+    }
   });
 }
 function buildNotifyFault(log) {