squadrant 0.21.1 → 0.23.0

package/dist/squadrantd.js

@@ -94,6 +94,9 @@ function isGateMode(v2) {
 function isGatePolicy(v2) {
   return GATE_POLICIES.includes(v2);
 }
+function isGateEngine(v2) {
+  return GATE_ENGINES.includes(v2);
+}
 function getDefaultConfig() {
   return {
     commandName: "\u{1F3DB}\uFE0F command",
@@ -135,12 +138,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,15 +180,29 @@ 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, GATE_ENGINES, DEFAULT_CONFIG_PATH, CONFIG_DIR, DAEMON_SOCK_PATH, DEFAULT_CREW_ROUTING_RULES;
 var init_config = __esm({
   "packages/shared/dist/config.js"() {
     init_config_io();
     GATE_MODES = ["on", "off", "auto"];
     GATE_POLICIES = ["deny-dangerous", "ask-on-doubt"];
+    GATE_ENGINES = ["router", "auto-gate"];
     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 +802,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();
@@ -1061,10 +1074,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;
@@ -1102,6 +1116,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;
@@ -1122,7 +1137,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;
   }
@@ -1274,6 +1289,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;
@@ -1336,6 +1353,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) {
@@ -1425,7 +1463,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();
@@ -1433,6 +1471,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;
@@ -2027,8 +2066,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 +2813,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 +2897,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;
   }
 });
 
@@ -3498,8 +3602,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) {
@@ -4665,8 +4772,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;
@@ -4678,7 +4786,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) {
@@ -5609,16 +5717,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";
     }
   };
 }
@@ -5655,16 +5773,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);
@@ -5719,6 +5840,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);
@@ -5730,8 +5871,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"]
+    ];
   }
 });
 
@@ -5754,6 +5906,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: {} };
@@ -5767,6 +5921,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;
 }
@@ -5780,6 +5947,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)) {
@@ -5802,17 +6005,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;
   }
@@ -5821,8 +6025,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 };
@@ -5845,6 +6049,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 });
     },
@@ -5853,11 +6060,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();
   }
 });
 
@@ -5945,8 +6382,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;
@@ -5962,6 +6401,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")
@@ -5988,9 +6506,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;
@@ -6000,12 +6526,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));
@@ -6192,10 +6714,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");
@@ -6245,21 +6770,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;
@@ -6268,13 +6788,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) {
@@ -6282,7 +6811,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;
@@ -6296,7 +6829,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;
@@ -6307,39 +6840,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) => {
@@ -6356,17 +6972,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"]);
@@ -6411,7 +7033,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";
@@ -6462,7 +7084,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)}`);
@@ -6501,94 +7123,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"() {
@@ -6600,6 +7134,7 @@ var init_telegram = __esm({
     init_format();
     init_state();
     init_client();
+    init_inbound_lifecycle();
     init_bridge();
     init_setup();
     init_notify();
@@ -7234,6 +7769,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))
@@ -7618,6 +8159,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";
@@ -7865,7 +8459,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}`;
 }
@@ -7967,7 +8561,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) {
@@ -8024,10 +8618,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}'.
@@ -8039,7 +8634,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);
   }
@@ -8404,11 +9001,14 @@ __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,
+  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,
@@ -8425,6 +9025,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,
@@ -8437,6 +9038,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,
@@ -8458,15 +9063,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,
@@ -8475,12 +9084,14 @@ __export(dist_exports, {
   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,
@@ -8530,12 +9141,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,
@@ -8557,18 +9172,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,
@@ -8577,6 +9197,7 @@ __export(dist_exports, {
   parseNotifyPref: () => parseNotifyPref,
   parseProgramArgs: () => parseProgramArgs,
   plistPath: () => plistPath,
+  pollBackoffMs: () => pollBackoffMs,
   pollNewestSessionInDirectory: () => pollNewestSessionInDirectory,
   prepareCaptainRoute: () => prepareCaptainRoute,
   printForeignInstallError: () => printForeignInstallError,
@@ -8584,6 +9205,7 @@ __export(dist_exports, {
   probeCaptainChannel: () => probeCaptainChannel,
   programArgsBlock: () => programArgsBlock,
   projectHealth: () => projectHealth,
+  pruneTopics: () => pruneTopics,
   purgeExpiredWorkItems: () => purgeExpiredWorkItems,
   readCaptainAddress: () => readCaptainAddress,
   readCursor: () => readCursor,
@@ -8611,6 +9233,7 @@ __export(dist_exports, {
   resolveCurrentProject: () => resolveCurrentProject,
   resolveGate: () => resolveGate,
   resolveGateDenyRules: () => resolveGateDenyRules,
+  resolveGateEngine: () => resolveGateEngine,
   resolveGateMode: () => resolveGateMode,
   resolveGatePolicy: () => resolveGatePolicy,
   resolveGateTools: () => resolveGateTools,
@@ -8650,9 +9273,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,
@@ -8665,6 +9290,7 @@ __export(dist_exports, {
   startServer: () => startServer,
   stripBotMention: () => stripBotMention,
   surfaceVerdict: () => surfaceVerdict,
+  telegramPollLockPath: () => telegramPollLockPath,
   timeoutGate: () => timeoutGate,
   titleFor: () => titleFor,
   toControlEvent: () => toControlEvent,
@@ -8713,6 +9339,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();
@@ -8758,7 +9385,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");
@@ -8803,11 +9430,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;
@@ -8830,7 +9457,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
@@ -8854,7 +9481,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";
@@ -8876,62 +9503,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);
     }
   }
@@ -10105,6 +10732,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);
@@ -10243,7 +10873,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";
 
@@ -10485,11 +11115,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 {
@@ -10527,11 +11157,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 {
@@ -10544,15 +11174,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 {
@@ -10569,11 +11199,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 {
@@ -10603,6 +11233,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;
 }
@@ -10818,10 +11476,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();
@@ -11015,7 +11673,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";
 
@@ -11590,6 +12248,48 @@ function removeCommandHandlers(entries, command) {
   }
   return removed;
 }
+var FOREIGN_AUTO_GATE_MARKER = "auto-gate-managed";
+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;
@@ -11627,6 +12327,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) {
@@ -11657,11 +12374,57 @@ 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;
 }
+var SUBAGENT_MODEL_KEY = "CLAUDE_CODE_SUBAGENT_MODEL";
+var SMALL_FAST_MODEL_KEY = "ANTHROPIC_SMALL_FAST_MODEL";
+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":
@@ -11811,7 +12574,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);
@@ -11914,7 +12677,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";
@@ -11923,15 +12686,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,
@@ -11957,7 +12720,7 @@ async function sharedReceiptListener() {
     // must never be the reason we refuse to start.
     unlinkStale: (p) => {
       try {
-        fs18.unlinkSync(p);
+        fs19.unlinkSync(p);
       } catch {
       }
     },
@@ -12054,6 +12817,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,
@@ -12065,7 +12855,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) {
@@ -12187,7 +12990,15 @@ function startSquadrantd(opts = {}) {
     log
   });
   const cmuxStoreSource = new CmuxStoreSource({ log });
-  const nativeHookSource = new NativeHookSource({ log, hookInstall: { claudeEnv: loadConfig().defaults.claudeEnv } });
+  const nativeHookSource = new NativeHookSource({
+    log,
+    hookInstall: {
+      claudeEnv: loadConfig().defaults.claudeEnv,
+      // #P6 (§15#5): only an explicit gate mode "on" lets squadrant remove a
+      // foreign auto-gate PermissionRequest handler; auto/absent leaves it alone.
+      gateMode: loadConfig().defaults.gate?.mode
+    }
+  });
   ctx.codexDriver = codexDriver;
   ctx.opencodeBridge = opencodeBridge;
   ctx.cmuxEventsBridge = cmuxEventsBridge;