squadrant 0.14.3 → 0.16.0

package/dist/squadrantd.js

@@ -60,10 +60,10 @@ var init_snapshot = __esm({
 });
 
 // packages/cli/src/squadrantd.ts
-import { join as join17, dirname as dirname5 } from "path";
-import { homedir as homedir12 } from "os";
+import { join as join18, dirname as dirname5 } from "path";
+import { homedir as homedir13 } from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync13, statSync as statSync3 } from "fs";
 
 // packages/shared/dist/config.js
 import fs from "fs";
@@ -154,6 +154,9 @@ function saveConfig(config, configPath = DEFAULT_CONFIG_PATH) {
   fs.mkdirSync(dir, { recursive: true });
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
 }
+function resolveHome(p) {
+  return p.startsWith("~") ? p.replace("~", os.homedir()) : p;
+}
 
 // packages/shared/dist/project-config.js
 import fs2 from "fs";
@@ -230,22 +233,22 @@ var MINIMAL_TEMPLATE = [
   ``
 ].join("\n");
 function ensureSocketAutomation(opts = {}) {
-  const path17 = opts.path ?? defaultCmuxConfigPath();
-  if (!existsSync(path17)) {
-    mkdirSync(dirname(path17), { recursive: true });
-    writeFileSync(path17, MINIMAL_TEMPLATE);
-    return { path: path17, changed: true, alreadySet: false };
+  const path19 = opts.path ?? defaultCmuxConfigPath();
+  if (!existsSync(path19)) {
+    mkdirSync(dirname(path19), { recursive: true });
+    writeFileSync(path19, MINIMAL_TEMPLATE);
+    return { path: path19, changed: true, alreadySet: false };
   }
-  const text = readFileSync(path17, "utf-8");
+  const text = readFileSync(path19, "utf-8");
   const current = parse(text)?.automation?.socketControlMode;
   if (current === AUTOMATION_MODE) {
-    return { path: path17, changed: false, alreadySet: true };
+    return { path: path19, changed: false, alreadySet: true };
   }
   const edits = modify(text, [...SOCKET_CONTROL_MODE_PATH], AUTOMATION_MODE, {
     formattingOptions: { insertSpaces: true, tabSize: 2 }
   });
-  writeFileSync(path17, applyEdits(text, edits));
-  return { path: path17, changed: true, alreadySet: false };
+  writeFileSync(path19, applyEdits(text, edits));
+  return { path: path19, changed: true, alreadySet: false };
 }
 
 // packages/shared/dist/lib/cmux-probe.js
@@ -367,15 +370,15 @@ function sleep(ms) {
 function defaultStatePath() {
   return join4(homedir3(), ".config", "squadrant", "state", "cmux-autoconfig.json");
 }
-function readState(path17) {
+function readState(path19) {
   try {
-    return JSON.parse(readFileSync4(path17, "utf-8"));
+    return JSON.parse(readFileSync4(path19, "utf-8"));
   } catch {
     return {};
   }
 }
 async function ensureCmuxAutoConfig(opts = {}) {
-  const statePath2 = opts.statePath ?? defaultStatePath();
+  const statePath3 = opts.statePath ?? defaultStatePath();
   const ensureConfig = opts.ensureConfig ?? ensureSocketAutomation;
   const probe = opts.probe ?? probeCmuxDaemonDirect;
   const cfg = ensureConfig({ path: opts.configPath });
@@ -383,15 +386,15 @@ async function ensureCmuxAutoConfig(opts = {}) {
   const needsRestart = verdict === "denied";
   let promptedThisRun = false;
   if (needsRestart) {
-    const already = readState(statePath2).promptedRestart === true;
+    const already = readState(statePath3).promptedRestart === true;
     if (!already) {
-      mkdirSync2(dirname2(statePath2), { recursive: true });
-      writeFileSync3(statePath2, JSON.stringify({ promptedRestart: true }));
+      mkdirSync2(dirname2(statePath3), { recursive: true });
+      writeFileSync3(statePath3, JSON.stringify({ promptedRestart: true }));
       promptedThisRun = true;
     }
   } else if (verdict === "reachable") {
-    if (existsSync4(statePath2))
-      rmSync2(statePath2, { force: true });
+    if (existsSync4(statePath3))
+      rmSync2(statePath3, { force: true });
   }
   return {
     configPath: cfg.path,
@@ -416,16 +419,25 @@ var compatManifest = {
   }
 };
 
+// packages/shared/dist/lib/update-check.js
+import fs3 from "fs";
+import path3 from "path";
+import os3 from "os";
+import https from "https";
+var UPDATE_CHECK_STATE_PATH = path3.join(os3.homedir(), ".config", "squadrant", "update-check.json");
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var FAILURE_RETRY_MS = 60 * 60 * 1e3;
+
 // packages/shared/dist/lib/git-worktree.js
 import { execFileSync as execFileSync2 } from "child_process";
-import path3 from "path";
+import path4 from "path";
 
 // packages/shared/dist/lib/resolve-text-input.js
-import fs3 from "fs";
+import fs4 from "fs";
 
 // packages/shared/dist/lib/runtime-sync.js
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 
 // packages/shared/dist/lib/tool-compat.js
 function parseSemVer(v) {
@@ -459,13 +471,13 @@ function checkToolCompat(name, rawVersion, entry) {
 }
 
 // packages/shared/dist/lib/canonical-source.js
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 
 // packages/shared/dist/lib/daily-logs.js
 import { execSync } from "child_process";
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 import matter from "gray-matter";
 
 // packages/core/dist/state-machine.js
@@ -626,7 +638,7 @@ function formatMessage(rec, event) {
       return `CREW STALLED ${tag}: no heartbeat in ${rec.heartbeatBudgetMs}ms`;
     }
     case "awaiting-input":
-      return `CREW IDLE ${tag}: turn ended / awaiting your input \u2014 review and reply or close.`;
+      return `CREW IDLE ${tag}: turn ended, awaiting your reply.`;
     default:
       return null;
   }
@@ -1007,7 +1019,7 @@ function createDaemon(deps) {
 }
 
 // packages/core/dist/mailbox.js
-import { promises as fs7 } from "fs";
+import { promises as fs8 } from "fs";
 import { join as join5 } from "path";
 import { randomUUID } from "crypto";
 function inboxDir(stateRoot) {
@@ -1024,7 +1036,7 @@ async function listRotatedOldestFirst(stateRoot, project) {
   const dir = inboxDir(stateRoot);
   let entries;
   try {
-    entries = await fs7.readdir(dir);
+    entries = await fs8.readdir(dir);
   } catch {
     return [];
   }
@@ -1033,7 +1045,7 @@ async function listRotatedOldestFirst(stateRoot, project) {
 }
 async function readMaxSeqFromFile(file) {
   try {
-    const buf = await fs7.readFile(file, "utf-8");
+    const buf = await fs8.readFile(file, "utf-8");
     if (!buf.trim())
       return 0;
     const lines = buf.trim().split("\n");
@@ -1075,12 +1087,12 @@ function withProjectLock(project, fn) {
 function appendEntry(stateRoot, project, build) {
   return withProjectLock(project, async () => {
     const dir = inboxDir(stateRoot);
-    await fs7.mkdir(dir, { recursive: true });
+    await fs8.mkdir(dir, { recursive: true });
     const file = logPath(stateRoot, project);
     const lastSeq = await readMaxSeq(stateRoot, project);
     const seq = lastSeq + 1;
     const entry = build(seq);
-    await fs7.appendFile(file, JSON.stringify(entry) + "\n", { encoding: "utf-8" });
+    await fs8.appendFile(file, JSON.stringify(entry) + "\n", { encoding: "utf-8" });
     return seq;
   });
 }
@@ -1111,7 +1123,7 @@ function cursorPath(stateRoot, project, subscriber) {
 async function readCursor(opts) {
   let buf;
   try {
-    buf = await fs7.readFile(cursorPath(opts.stateRoot, opts.project, opts.subscriber), "utf-8");
+    buf = await fs8.readFile(cursorPath(opts.stateRoot, opts.project, opts.subscriber), "utf-8");
   } catch (e) {
     if (e.code === "ENOENT")
       return null;
@@ -1126,7 +1138,7 @@ async function readCursor(opts) {
   }
 }
 async function writeCursor(opts) {
-  await fs7.mkdir(inboxDir(opts.stateRoot), { recursive: true });
+  await fs8.mkdir(inboxDir(opts.stateRoot), { recursive: true });
   const dest = cursorPath(opts.stateRoot, opts.project, opts.subscriber);
   const tmp = `${dest}.${process.pid}.${randomUUID()}.tmp`;
   const data = {
@@ -1134,7 +1146,7 @@ async function writeCursor(opts) {
     subscriber: opts.subscriber,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const handle = await fs7.open(tmp, "w");
+  const handle = await fs8.open(tmp, "w");
   try {
     await handle.writeFile(JSON.stringify(data), { encoding: "utf-8" });
     await handle.sync();
@@ -1142,9 +1154,9 @@ async function writeCursor(opts) {
     await handle.close();
   }
   try {
-    await fs7.rename(tmp, dest);
+    await fs8.rename(tmp, dest);
   } catch (e) {
-    await fs7.unlink(tmp).catch(() => {
+    await fs8.unlink(tmp).catch(() => {
     });
     throw e;
   }
@@ -1155,7 +1167,7 @@ async function* readFromCursor(opts) {
   for (const file of files) {
     let buf;
     try {
-      buf = await fs7.readFile(file, "utf-8");
+      buf = await fs8.readFile(file, "utf-8");
     } catch (e) {
       if (e.code === "ENOENT")
         continue;
@@ -1181,7 +1193,7 @@ async function mailboxStats(stateRoot, project) {
   let sizeBytes = 0;
   for (const f of [file, ...rotated]) {
     try {
-      sizeBytes += (await fs7.stat(f)).size;
+      sizeBytes += (await fs8.stat(f)).size;
     } catch (e) {
       if (e.code !== "ENOENT")
         throw e;
@@ -1197,7 +1209,7 @@ async function mailboxStats(stateRoot, project) {
 }
 async function oldestEntryAgeMs(file) {
   try {
-    const buf = await fs7.readFile(file, "utf-8");
+    const buf = await fs8.readFile(file, "utf-8");
     const firstLine = buf.split("\n").find((l) => l.trim());
     if (!firstLine)
       return 0;
@@ -1212,7 +1224,7 @@ async function rotateIfNeeded(opts) {
     const file = logPath(opts.stateRoot, opts.project);
     let size = 0;
     try {
-      size = (await fs7.stat(file)).size;
+      size = (await fs8.stat(file)).size;
     } catch (e) {
       if (e.code === "ENOENT")
         return { rotated: false };
@@ -1228,22 +1240,22 @@ async function rotateIfNeeded(opts) {
       const dst = `${file}.${n + 1}`;
       if (n + 1 > opts.keepCount) {
         try {
-          await fs7.unlink(src);
+          await fs8.unlink(src);
         } catch (e) {
           if (e.code !== "ENOENT")
             throw e;
         }
       } else {
         try {
-          await fs7.rename(src, dst);
+          await fs8.rename(src, dst);
         } catch (e) {
           if (e.code !== "ENOENT")
             throw e;
         }
       }
     }
-    await fs7.rename(file, `${file}.1`);
-    await fs7.writeFile(file, "", { encoding: "utf-8" });
+    await fs8.rename(file, `${file}.1`);
+    await fs8.writeFile(file, "", { encoding: "utf-8" });
     return { rotated: true, from: file, to: `${file}.1` };
   });
 }
@@ -1443,14 +1455,14 @@ var TERMINAL = /* @__PURE__ */ new Set(["done", "failed", "cancelled"]);
 function projectHealth(input) {
   const { project, now, captainName, captainStopped, commandPresent, crews } = input;
   const out = [];
-  const captainState = captainStopped === true ? "stopped" : captainStopped === false ? "alive" : "unknown";
+  const captainState = input.captainState ?? (captainStopped === true ? "stopped" : captainStopped === false ? "alive" : "unknown");
   out.push({
     kind: "captain",
     project,
     ref: captainName,
     state: captainState,
     lastSeenMs: null,
-    detail: captainState === "stopped" ? "captain workspace closed \u2014 crews reaped; delivery paused" : void 0
+    detail: captainState === "stopped" ? "captain workspace closed \u2014 crews reaped; delivery paused" : captainState === "gone" ? "captain process died (crash) \u2014 crews reaped" : void 0
   });
   if (commandPresent !== null) {
     out.push({
@@ -1481,6 +1493,26 @@ function presence(p) {
     return "unknown";
   return p ? "alive" : "gone";
 }
+function deriveCaptainState(e) {
+  if (!e)
+    return "unknown";
+  if (e.lastState === "end")
+    return "stopped";
+  if (!e.pidAlive)
+    return "gone";
+  return "alive";
+}
+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) };
+  }
+  if (next.startedAt >= prev.startedAt || next.lastState === "end")
+    return next;
+  return prev;
+}
 
 // packages/core/dist/store.js
 import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, readdirSync, renameSync, writeFileSync as writeFileSync4, existsSync as existsSync6, rmSync as rmSync3, statSync } from "fs";
@@ -1639,7 +1671,73 @@ function makeGate(opts) {
 import { homedir as homedir5 } from "os";
 import { join as join8 } from "path";
 import { spawn as realSpawn } from "child_process";
-import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync5 } from "fs";
+import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync5 } from "fs";
+
+// packages/core/dist/daemon/liveness-registry.js
+import { writeFileSync as writeFileSync6, readFileSync as readFileSync7, renameSync as renameSync2 } from "fs";
+var LivenessRegistry = class {
+  path;
+  readFile;
+  writeFile;
+  map = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.path = opts.path;
+    this.readFile = opts.readFile ?? ((p) => {
+      try {
+        return readFileSync7(p, "utf-8");
+      } catch {
+        return void 0;
+      }
+    });
+    this.writeFile = opts.writeFile ?? ((p, c) => {
+      writeFileSync6(`${p}.tmp`, c);
+      renameSync2(`${p}.tmp`, p);
+    });
+  }
+  load() {
+    const raw = this.readFile(this.path);
+    if (!raw)
+      return;
+    try {
+      const arr = JSON.parse(raw);
+      this.map = new Map(arr.map((e) => [e.project, e]));
+    } catch {
+      this.map = /* @__PURE__ */ new Map();
+    }
+  }
+  get(project) {
+    return this.map.get(project);
+  }
+  all() {
+    return [...this.map.values()];
+  }
+  apply(next) {
+    this.map.set(next.project, reconcileLiveness(this.map.get(next.project), next));
+    this.persist();
+  }
+  markEnded(project, at) {
+    const e = this.map.get(project);
+    if (!e)
+      return;
+    this.map.set(project, { ...e, lastState: "end", lastSeenAt: at });
+    this.persist();
+  }
+  setPidAlive(project, alive, at) {
+    const e = this.map.get(project);
+    if (!e)
+      return;
+    this.map.set(project, { ...e, pidAlive: alive, lastSeenAt: at });
+    this.persist();
+  }
+  persist() {
+    try {
+      this.writeFile(this.path, JSON.stringify(this.all(), null, 2));
+    } catch {
+    }
+  }
+};
+
+// packages/core/dist/daemon/context.js
 function defaultIsPidAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -1660,7 +1758,7 @@ function buildContext(opts) {
   mkdirSync5(resultsDir, { recursive: true });
   const writeResult = (id, payload) => {
     const p = join8(resultsDir, `${id}.txt`);
-    writeFileSync6(p, payload);
+    writeFileSync7(p, payload);
     return p;
   };
   const log = (m) => process.stderr.write(`[squadrantd] ${(/* @__PURE__ */ new Date()).toISOString()} ${m}
@@ -1681,8 +1779,11 @@ function buildContext(opts) {
     attachConns: /* @__PURE__ */ new Map(),
     inFlightHeadlessIds: /* @__PURE__ */ new Set(),
     activeHeadlessKills: /* @__PURE__ */ new Set(),
-    captainMissingStreak: /* @__PURE__ */ new Map(),
-    stoppedProjects: /* @__PURE__ */ new Set(),
+    livenessRegistry: (() => {
+      const r = new LivenessRegistry({ path: join8(stateRoot, "liveness.json") });
+      r.load();
+      return r;
+    })(),
     resendFirstTurn: opts.resendFirstTurn,
     // Late-bound — start.ts fills these before first use:
     d: null,
@@ -2036,7 +2137,6 @@ var CaptainDelivery = class {
 
 // packages/core/dist/daemon/delivery-loop.js
 var CURSOR_SUBSCRIBER = "captain";
-var CAPTAIN_GONE_STREAK_K = 3;
 var TERMINAL_KINDS = /* @__PURE__ */ new Set(["task.done", "task.failed", "task.cancelled", "task.blocked"]);
 function discoverCaptainSurface(surfaces, captainTitle) {
   return surfaces.find((s) => s.title === captainTitle) ?? null;
@@ -2053,8 +2153,71 @@ function reapOrphanedCrews(store, project) {
   }
   return reaped;
 }
+function logEntry(log, project, e) {
+  if (!log || !e)
+    return;
+  log(`[${e.role}/${e.source}] ${project} pid=${e.pid} \u2192 ${deriveCaptainState(e)}`);
+}
+async function runLivenessTick(deps) {
+  const now = deps.now();
+  let records = [];
+  try {
+    records = await deps.liveness();
+  } catch {
+    return;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const byProject = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    if (r.role !== "captain")
+      continue;
+    let arr = byProject.get(r.project);
+    if (!arr) {
+      arr = [];
+      byProject.set(r.project, arr);
+    }
+    arr.push(r);
+  }
+  for (const [project, recs] of byProject) {
+    seen.add(project);
+    const winner = recs.find((r) => r.pid == null || deps.isPidAlive(r.pid)) ?? recs[0];
+    const entry = {
+      project,
+      role: "captain",
+      pid: winner.pid,
+      sessionId: winner.sessionId,
+      startedAt: now,
+      lastState: "start",
+      lastSeenAt: now,
+      pidAlive: winner.pid != null ? deps.isPidAlive(winner.pid) : true,
+      source: "runtime"
+    };
+    const prev = deps.registry.get(project);
+    if (prev && prev.lastState === "start")
+      entry.startedAt = prev.startedAt;
+    deps.registry.apply(entry);
+    if (winner.pid != null)
+      deps.registry.setPidAlive(project, deps.isPidAlive(winner.pid), now);
+    logEntry(deps.log, project, deps.registry.get(project));
+  }
+  for (const e of deps.registry.all()) {
+    if (e.role === "captain" && e.lastState === "start" && !seen.has(e.project)) {
+      deps.registry.markEnded(e.project, now);
+      logEntry(deps.log, e.project, deps.registry.get(e.project));
+    }
+  }
+  if (deps.reap) {
+    for (const e of deps.registry.all()) {
+      if (e.role !== "captain")
+        continue;
+      const state = deriveCaptainState(e);
+      if (state === "stopped" || state === "gone")
+        deps.reap(e.project);
+    }
+  }
+}
 function createDelivery(ctx, daemonCmux) {
-  const { stateRoot, store, log, captainMissingStreak, stoppedProjects, opts } = ctx;
+  const { stateRoot, store, log, livenessRegistry, isPidAlive, opts } = ctx;
   const defaultNotify = async (args) => {
     try {
       await appendToMailbox({
@@ -2080,45 +2243,41 @@ function createDelivery(ctx, daemonCmux) {
   const sessionStartMs = Date.now();
   let delivering = false;
   const deliveryCore = async () => {
+    await runLivenessTick({
+      registry: livenessRegistry,
+      liveness: () => cmux2.liveness ? cmux2.liveness() : Promise.resolve([]),
+      isPidAlive,
+      now: () => Date.now(),
+      log,
+      reap: (project) => {
+        const reaped = reapOrphanedCrews(store, project);
+        if (reaped > 0) {
+          const title = cfg.projects?.[project]?.captainName ?? `${project}-captain`;
+          log(`captain ${title}: reaped ${reaped} orphaned crew(s)`);
+        }
+        return reaped;
+      }
+    });
     const injectedSurfaces = opts.captainSurfaces ?? {};
     const allProjects = [.../* @__PURE__ */ new Set([
       ...Object.keys(cfg.projects ?? {}),
       ...Object.keys(injectedSurfaces),
-      ...store.listAll().map((t) => t.project)
+      ...store.listAll().map((t) => t.project),
+      cfg.commandName
     ])];
     for (const project of allProjects) {
       const projCfg = cfg.projects?.[project];
-      const captainTitle = projCfg?.captainName ?? `${project}-captain`;
+      const captainTitle = project === cfg.commandName ? cfg.commandName : projCfg?.captainName ?? `${project}-captain`;
       const wsId = cmux2.findWorkspaceId ? await cmux2.findWorkspaceId(captainTitle) : null;
       let surface = null;
-      let surfacesLength = 0;
       if (wsId) {
         const surfaces = await cmux2.listSurfaces(wsId);
-        surfacesLength = surfaces.length;
         surface = discoverCaptainSurface(surfaces, captainTitle);
       }
       if (!surface)
         surface = injectedSurfaces[project] ?? null;
-      if (surface) {
-        if (stoppedProjects.has(project)) {
-          stoppedProjects.delete(project);
-          captainMissingStreak.set(project, 0);
-        }
-        captainMissingStreak.set(project, 0);
-      } else {
-        if (surfacesLength > 0) {
-          const streak = (captainMissingStreak.get(project) ?? 0) + 1;
-          captainMissingStreak.set(project, streak);
-          if (streak >= CAPTAIN_GONE_STREAK_K) {
-            if (!stoppedProjects.has(project)) {
-              stoppedProjects.add(project);
-              const reaped = reapOrphanedCrews(store, project);
-              log(`captain ${captainTitle}: surface gone for ${CAPTAIN_GONE_STREAK_K} sweeps \u2014 stopping delivery${reaped > 0 ? `, reaped ${reaped} orphaned crew(s)` : ""}`);
-            }
-          }
-        }
+      if (!surface)
         continue;
-      }
       const cursor = await readCursor({ stateRoot, project, subscriber: CURSOR_SUBSCRIBER });
       const lastAcked = cursor?.lastAckedSeq ?? 0;
       let d = deliveries.get(project);
@@ -2132,11 +2291,16 @@ function createDelivery(ctx, daemonCmux) {
       for await (const entry of readFromCursor({ stateRoot, project, fromSeq: lastAcked + 1 })) {
         if (new Date(entry.ts).getTime() < sessionStartMs - STALE_THRESHOLD_MS) {
           if (!TERMINAL_KINDS.has(entry.kind)) {
-            log(`delivery seq=${entry.seq} kind=${entry.kind} outcome=stale-skipped`);
-            await writeCursor({ stateRoot, project, subscriber: CURSOR_SUBSCRIBER, lastAckedSeq: entry.seq });
-            continue;
+            const isExemptMessage = entry.kind === "captain.message" && entry.payload?.source !== "daemon";
+            if (!isExemptMessage) {
+              log(`delivery seq=${entry.seq} kind=${entry.kind} outcome=stale-skipped`);
+              await writeCursor({ stateRoot, project, subscriber: CURSOR_SUBSCRIBER, lastAckedSeq: entry.seq });
+              continue;
+            }
+            log(`delivery seq=${entry.seq} kind=${entry.kind} outcome=stale-exempt-deliver`);
+          } else {
+            log(`delivery seq=${entry.seq} kind=${entry.kind} outcome=stale-terminal-deliver`);
           }
-          log(`delivery seq=${entry.seq} kind=${entry.kind} outcome=stale-terminal-deliver`);
         }
         const result = await d.deliver(entry, (text, sendOpts) => cmux2.send(surface, text, sendOpts));
         if ("delivered" in result) {
@@ -2240,7 +2404,7 @@ function createServer2(ctx, handlers) {
 // packages/core/dist/daemon/snapshot-gather.js
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { join as join9 } from "path";
-import { statSync as statSync2, openSync as openSync2, readSync, closeSync as closeSync2, readdirSync as readdirSync2, readFileSync as readFileSync7 } from "fs";
+import { statSync as statSync2, openSync as openSync2, readSync, closeSync as closeSync2, readdirSync as readdirSync2, readFileSync as readFileSync8 } from "fs";
 var SELF_PATH = fileURLToPath2(import.meta.url);
 function distBuiltAt() {
   try {
@@ -2249,10 +2413,10 @@ function distBuiltAt() {
     return 0;
   }
 }
-function gatherLogStats(path17, now, windowMs) {
+function gatherLogStats(path19, now, windowMs) {
   let sizeBytes = 0;
   try {
-    sizeBytes = statSync2(path17).size;
+    sizeBytes = statSync2(path19).size;
   } catch {
     return { errorCount: 0, sizeBytes: 0, windowMs };
   }
@@ -2263,7 +2427,7 @@ function gatherLogStats(path17, now, windowMs) {
   const len = sizeBytes - start;
   let text = "";
   try {
-    const fd = openSync2(path17, "r");
+    const fd = openSync2(path19, "r");
     try {
       const buf = Buffer.alloc(len);
       readSync(fd, buf, 0, len, start);
@@ -2304,7 +2468,7 @@ function gatherStoreStats(store, stateRoot, project) {
       if (!n.endsWith(".json"))
         continue;
       try {
-        JSON.parse(readFileSync7(join9(dir, n), "utf-8"));
+        JSON.parse(readFileSync8(join9(dir, n), "utf-8"));
       } catch {
         corruptCount++;
       }
@@ -2389,14 +2553,13 @@ function startDaemon(ctx, opts, pkgVersion) {
     for (const project of names) {
       const proj = config.projects[project];
       const captainName = proj?.captainName ?? `${project}-captain`;
-      const stopped = ctx.stoppedProjects.has(project);
-      const streak = ctx.captainMissingStreak.get(project);
-      const captainStopped = stopped ? true : streak === 0 ? false : null;
+      const capEntry = ctx.livenessRegistry.get(project);
       out.push(...projectHealth({
         project,
         now,
         captainName,
-        captainStopped,
+        captainStopped: null,
+        captainState: deriveCaptainState(capEntry),
         commandPresent: null,
         crews: store.list(project)
       }));
@@ -2496,7 +2659,7 @@ function startDaemon(ctx, opts, pkgVersion) {
     }
   })();
   const server = createServer2(ctx, { buildHealth, gatherSnapshotInputs, cancelPromotionsFor, broadcast });
-  log(`started pid=${process.pid} sock=${ctx.sockPath} stateRoot=${stateRoot}`);
+  log(`boot pid=${process.pid} version=${pkgVersion} socket=${ctx.sockPath} stateRoot=${stateRoot}`);
   let deliveryTick = initialDeliveryTick;
   let probeTick;
   if (daemonCmux) {
@@ -2557,7 +2720,8 @@ function startDaemon(ctx, opts, pkgVersion) {
     rotationTimer.unref?.();
   }
   return {
-    stop() {
+    stop(reason = "requested") {
+      log(`exit pid=${process.pid} reason=${reason}`);
       if (deliveryTimer)
         clearInterval(deliveryTimer);
       if (probeTimer)
@@ -2581,7 +2745,7 @@ function startDaemon(ctx, opts, pkgVersion) {
       for (const kill of ctx.activeHeadlessKills)
         kill();
       return new Promise((resolve2) => server.close(() => {
-        log("stopped");
+        log(`exit-complete pid=${process.pid}`);
         resolve2();
       }));
     },
@@ -2592,8 +2756,8 @@ function startDaemon(ctx, opts, pkgVersion) {
 
 // packages/core/dist/session-freshness.js
 import crypto from "crypto";
-import fs8 from "fs";
-import path7 from "path";
+import fs9 from "fs";
+import path8 from "path";
 
 // packages/core/dist/crew-protocol.js
 function buildCompletionProtocol(taskId, project) {
@@ -2753,21 +2917,33 @@ function createRunCommand(cliBin) {
     }
   };
 }
+function isCaptainAliveFromHealth(rows, project) {
+  return rows.some((h) => h.kind === "captain" && h.project === project && h.state === "alive");
+}
 function createIsCaptainAlive(sock) {
   return async (project) => {
     try {
       const health = await sendRequest(sock, { kind: "health", project }, 5e3);
-      const captain = health?.find((h) => h.kind === "captain" && h.project === project);
-      return captain != null && captain.state !== "gone" && captain.state !== "unknown";
+      return isCaptainAliveFromHealth(health ?? [], project);
     } catch {
       return false;
     }
   };
 }
-function createLaunch(cliBin) {
-  return async (project) => {
-    await pExecFile(process.execPath, [cliBin, "launch", project], { timeout: 3e4 });
-  };
+function createLaunch(cliBin, log) {
+  return (project) => new Promise((resolve2, reject) => {
+    execFile(process.execPath, [cliBin, "launch", project, "--headless"], { timeout: 3e4 }, (err, stdout, stderr) => {
+      const output = capOutput(stdout ?? "", stderr ?? "");
+      if (err) {
+        log?.(`launch ${project} failed: ${output}`);
+        reject(err);
+        return;
+      }
+      if (output !== "(no output)")
+        log?.(`launch ${project}: ${output}`);
+      resolve2();
+    });
+  });
 }
 
 // packages/core/dist/telegram/ensure-captain.js
@@ -2836,17 +3012,17 @@ function formatInbound(text) {
 }
 
 // packages/core/dist/telegram/state.js
-import fs9 from "fs";
-import path8 from "path";
+import fs10 from "fs";
+import path9 from "path";
 function statePath(stateRoot) {
-  return path8.join(stateRoot, "telegram-state.json");
+  return path9.join(stateRoot, "telegram-state.json");
 }
 function topicKey(project, scope = "project") {
   return `${project}::${scope}`;
 }
 function loadState(stateRoot) {
   try {
-    const raw = fs9.readFileSync(statePath(stateRoot), "utf-8");
+    const raw = fs10.readFileSync(statePath(stateRoot), "utf-8");
     const data = JSON.parse(raw);
     const result = {
       offset: typeof data.offset === "number" ? data.offset : 0,
@@ -2861,8 +3037,8 @@ function loadState(stateRoot) {
   }
 }
 function saveState(stateRoot, s) {
-  fs9.mkdirSync(stateRoot, { recursive: true });
-  fs9.writeFileSync(statePath(stateRoot), JSON.stringify(s, null, 2) + "\n");
+  fs10.mkdirSync(stateRoot, { recursive: true });
+  fs10.writeFileSync(statePath(stateRoot), JSON.stringify(s, null, 2) + "\n");
 }
 function setTopic(stateRoot, project, topicId, scope = "project") {
   const s = loadState(stateRoot);
@@ -2952,8 +3128,8 @@ function createTelegramClient(opts) {
 }
 
 // packages/core/dist/telegram/bridge.js
-import os3 from "os";
-import path9 from "path";
+import os4 from "os";
+import path10 from "path";
 
 // packages/core/dist/telegram/panels.js
 var mark = (on, label) => on ? `\u2022 ${label}` : label;
@@ -3058,7 +3234,7 @@ function notifyToggle(text) {
 }
 function createTelegramBridge(opts) {
   const { cfg, stateRoot, client, appendCaptainMessage: appendCaptainMessage2, log, ensureCaptainAlive, runCommand, sendReply } = opts;
-  const configRoot = opts.configRoot ?? path9.join(os3.homedir(), ".config", "squadrant");
+  const configRoot = opts.configRoot ?? path10.join(os4.homedir(), ".config", "squadrant");
   const pollMs = cfg.pollMs ?? 1e3;
   let running = false;
   let lastSuccessfulPollAt = null;
@@ -3183,14 +3359,14 @@ function createTelegramBridge(opts) {
   }
   function currentEffort() {
     try {
-      return loadConfig(path9.join(configRoot, "config.json")).defaults.effort ?? "balance";
+      return loadConfig(path10.join(configRoot, "config.json")).defaults.effort ?? "balance";
     } catch {
       return "balance";
     }
   }
   function projectNames() {
     try {
-      return Object.keys(loadConfig(path9.join(configRoot, "config.json")).projects);
+      return Object.keys(loadConfig(path10.join(configRoot, "config.json")).projects);
     } catch {
       return [];
     }
@@ -3309,8 +3485,11 @@ function createTelegramBridge(opts) {
     if (ensureCaptainAlive && isControlEnabled(cfg) && isAuthorized(fromId, cfg)) {
       try {
         const r = await ensureCaptainAlive(resolved.project);
-        if (r === "timeout")
-          await reply(threadId, "\u26A0\uFE0F captain didn't warm up; message queued.");
+        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`);
+        }
       } catch (e) {
         log(`telegram auto-launch failed project=${resolved.project}: ${e.message}`);
       }
@@ -3394,7 +3573,7 @@ function createTelegramBridge(opts) {
 }
 
 // packages/core/dist/telegram/setup.js
-import fs10 from "fs";
+import fs11 from "fs";
 
 // packages/core/dist/restart-daemon.js
 import { execFileSync as execFileSync4 } from "child_process";
@@ -3410,14 +3589,14 @@ import { join as join12 } from "path";
 var DEFAULT_SOCK_PATH2 = join12(homedir7(), ".config", "squadrant", "squadrant.sock");
 
 // packages/core/dist/side-session.js
-import fs11 from "fs";
+import fs12 from "fs";
 
 // packages/core/dist/crew-spawn.js
-import fs12 from "fs";
-import os4 from "os";
-import path10 from "path";
-var TEMPLATES_DIR = path10.join(os4.homedir(), ".config", "squadrant", "templates");
-var STATE_ROOT = path10.join(os4.homedir(), ".config", "squadrant", "state");
+import fs13 from "fs";
+import os5 from "os";
+import path11 from "path";
+var TEMPLATES_DIR = path11.join(os5.homedir(), ".config", "squadrant", "templates");
+var STATE_ROOT = path11.join(os5.homedir(), ".config", "squadrant", "state");
 
 // packages/core/dist/lifecycle-source.js
 function reduceLifecycle(prev, next) {
@@ -3449,28 +3628,28 @@ import { execSync as execSync4 } from "child_process";
 import { execSync as execSync5 } from "child_process";
 
 // packages/agents/dist/drivers/launch-cmd.js
-import fs13 from "fs";
-import path11 from "path";
+import fs14 from "fs";
+import path12 from "path";
 
 // packages/agents/dist/projection/cursor.js
 import { mkdir, readFile, writeFile } from "fs/promises";
-import path12 from "path";
-import os5 from "os";
+import path13 from "path";
+import os6 from "os";
 
 // packages/agents/dist/projection/codex.js
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import path13 from "path";
-import os6 from "os";
+import path14 from "path";
+import os7 from "os";
 
 // packages/agents/dist/projection/gemini.js
 import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import path14 from "path";
-import os7 from "os";
+import path15 from "path";
+import os8 from "os";
 
 // packages/agents/dist/projection/opencode.js
 import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import path15 from "path";
-import os8 from "os";
+import path16 from "path";
+import os9 from "os";
 
 // packages/agents/dist/codex/app-server-client.js
 import { EventEmitter } from "events";
@@ -4237,7 +4416,7 @@ var OpencodeSseBridge = class {
 
 // packages/agents/dist/interactive/claude.js
 import { execSync as execSync6 } from "child_process";
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import { homedir as homedir9 } from "os";
 import { join as join14 } from "path";
 
@@ -4863,13 +5042,45 @@ function createCmuxDriver() {
   };
 }
 
+// packages/workspaces/dist/runtimes/registry.js
+var DEFAULT_RUNTIME = "cmux";
+var RuntimeRegistry = class {
+  drivers;
+  constructor(drivers) {
+    this.drivers = drivers;
+  }
+  forProject(projectName, config) {
+    const projectRuntime = config.projects[projectName]?.runtime;
+    const runtimeName = projectRuntime ?? config.runtime ?? DEFAULT_RUNTIME;
+    return this.get(runtimeName);
+  }
+  global(config) {
+    const runtimeName = config.runtime ?? DEFAULT_RUNTIME;
+    return this.get(runtimeName);
+  }
+  get(name) {
+    const driver = this.drivers[name];
+    if (!driver) {
+      throw new Error(`Unknown runtime '${name}' \u2014 no driver registered`);
+    }
+    return driver;
+  }
+  async probeAll() {
+    const results = {};
+    for (const [name, driver] of Object.entries(this.drivers)) {
+      results[name] = await driver.probe();
+    }
+    return results;
+  }
+};
+
 // packages/workspaces/dist/notifiers/cmux.js
 import { execFileSync as execFileSync6, execSync as execSync7 } from "child_process";
 
 // packages/workspaces/dist/workspaces/obsidian.js
-import fs14 from "fs/promises";
+import fs15 from "fs/promises";
 import { existsSync as existsSync9 } from "fs";
-import path16 from "path";
+import path17 from "path";
 
 // packages/workspaces/dist/cmux-daemon/events-bridge.js
 import { spawn as nodeSpawn2 } from "child_process";
@@ -5005,6 +5216,71 @@ var CmuxEventsBridge = class {
   }
 };
 
+// packages/workspaces/dist/cmux-daemon/daemon-cmux.js
+import { readdirSync as readdirSync3, readFileSync as readFileSync10 } from "fs";
+import { join as join15 } from "path";
+import { homedir as homedir10 } from "os";
+
+// packages/workspaces/dist/cmux-daemon/store-fingerprint.js
+function roleFromTemplate(args) {
+  const i = args?.indexOf("--append-system-prompt-file") ?? -1;
+  const tmpl = i >= 0 && args ? (args[i + 1] ?? "").split("/").pop() ?? "" : "";
+  if (tmpl.startsWith("captain"))
+    return "captain";
+  if (tmpl.startsWith("crew"))
+    return "crew";
+  if (tmpl.startsWith("command"))
+    return "command";
+  return "unknown";
+}
+function projectFromCwd(cwd, projects) {
+  for (const [name, p] of Object.entries(projects)) {
+    const projPath = resolveHome(p.path);
+    if (cwd === projPath || cwd.startsWith(`${projPath}/`))
+      return name;
+  }
+  return void 0;
+}
+function parseStoreRecords(fileContent, projects) {
+  let parsed;
+  try {
+    parsed = JSON.parse(fileContent);
+  } catch (e) {
+    throw new Error(`parseStoreRecords: invalid JSON: ${e.message}`);
+  }
+  const out = [];
+  for (const s of Object.values(parsed.sessions ?? {})) {
+    const cwd = s.cwd ?? s.launchCommand?.workingDirectory ?? "";
+    const project = projectFromCwd(cwd, projects);
+    if (!project || !s.sessionId)
+      continue;
+    out.push({
+      role: roleFromTemplate(s.launchCommand?.arguments),
+      project,
+      pid: typeof s.pid === "number" ? s.pid : null,
+      sessionId: s.sessionId,
+      present: true,
+      isRestorable: s.isRestorable
+    });
+  }
+  return out;
+}
+function readLivenessSnapshot(files, readFile6, projects) {
+  const out = [];
+  let successes = 0;
+  for (const f of files) {
+    try {
+      out.push(...parseStoreRecords(readFile6(f), projects));
+      successes++;
+    } catch {
+    }
+  }
+  if (files.length > 0 && successes === 0) {
+    throw new Error(`readLivenessSnapshot: all ${files.length} store file(s) unreadable/corrupt this tick`);
+  }
+  return out;
+}
+
 // packages/workspaces/dist/cmux-daemon/daemon-cmux.js
 var DaemonCmux = class {
   driver;
@@ -5056,12 +5332,28 @@ var DaemonCmux = class {
       return false;
     }
   }
+  /**
+   * Ground-truth liveness from cmux's own hook-sessions store (§5.4).
+   * THROWS (does not return []) when the dir can't be listed, or every store
+   * file failed to read/parse — see the class doc above.
+   */
+  async liveness() {
+    const dir = process.env.CMUX_AGENT_HOOK_STATE_DIR ?? join15(homedir10(), ".cmuxterm");
+    const projects = loadConfig().projects;
+    let files;
+    try {
+      files = readdirSync3(dir).filter((f) => f.endsWith("-hook-sessions.json") && !f.endsWith(".lock"));
+    } catch (e) {
+      throw new Error(`liveness: could not read cmux state dir ${dir}: ${e.message}`);
+    }
+    return readLivenessSnapshot(files, (f) => readFileSync10(join15(dir, f), "utf-8"), projects);
+  }
 };
 
 // packages/workspaces/dist/cmux-daemon/cmux-store-source.js
-import { join as join15 } from "path";
-import { homedir as homedir10 } from "os";
-import { watch, readdirSync as readdirSync3, readFileSync as readFileSync9, existsSync as existsSync10 } from "fs";
+import { join as join16 } from "path";
+import { homedir as homedir11 } from "os";
+import { watch, readdirSync as readdirSync4, readFileSync as readFileSync11, existsSync as existsSync10 } from "fs";
 var CmuxStoreSource = class {
   name = "cmux-store";
   stateDir;
@@ -5082,7 +5374,7 @@ var CmuxStoreSource = class {
   active = false;
   lastError = null;
   constructor(opts = {}) {
-    this.stateDir = opts.stateDir ?? process.env.CMUX_AGENT_HOOK_STATE_DIR ?? join15(homedir10(), ".cmuxterm");
+    this.stateDir = opts.stateDir ?? process.env.CMUX_AGENT_HOOK_STATE_DIR ?? join16(homedir11(), ".cmuxterm");
     this.debounceMs = opts.debounceMs ?? 50;
     this.isPidAlive = opts.isPidAlive ?? defaultIsPidAlive2;
     this.listFiles = opts.listFiles ?? defaultListFiles;
@@ -5144,7 +5436,7 @@ var CmuxStoreSource = class {
   }
   scanFile(filename) {
     const deps = this.deps;
-    const filePath = join15(this.stateDir, filename);
+    const filePath = join16(this.stateDir, filename);
     const lockPath = `${filePath}.lock`;
     if (this.fileExists(lockPath)) {
       this.log(`cmux-store: skipping ${filename} (locked)`);
@@ -5210,14 +5502,14 @@ function defaultIsPidAlive2(pid) {
 }
 function defaultListFiles(dir) {
   try {
-    return readdirSync3(dir).filter((f) => f.endsWith("-hook-sessions.json") && !f.endsWith(".lock"));
+    return readdirSync4(dir).filter((f) => f.endsWith("-hook-sessions.json") && !f.endsWith(".lock"));
   } catch {
     return [];
   }
 }
-function defaultReadFile(path17) {
+function defaultReadFile(path19) {
   try {
-    return readFileSync9(path17, "utf-8");
+    return readFileSync11(path19, "utf-8");
   } catch {
     return void 0;
   }
@@ -5232,9 +5524,9 @@ function defaultWatchDir(dir, cb) {
 }
 
 // packages/workspaces/dist/native-hooks/native-hook-source.js
-import { join as join16 } from "path";
-import { homedir as homedir11 } from "os";
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
+import { join as join17 } from "path";
+import { homedir as homedir12 } from "os";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "fs";
 var CLAUDE_HOOK_EVENTS = [
   ["SessionStart", "session-start"],
   ["UserPromptSubmit", "prompt-submit"],
@@ -5246,7 +5538,7 @@ var CLAUDE_HOOK_EVENTS = [
 ];
 var DEFAULT_HOOK_CMD = "squadrant hooks";
 function installClaudeHooks(opts = {}) {
-  const settingsPath = opts.settingsPath ?? join16(homedir11(), ".claude", "settings.json");
+  const settingsPath = opts.settingsPath ?? join17(homedir12(), ".claude", "settings.json");
   const hookCmd = opts.hookCmd ?? DEFAULT_HOOK_CMD;
   const readFile6 = opts.readFile ?? defaultReadFile2;
   const writeFile5 = opts.writeFile ?? defaultWriteFile;
@@ -5392,16 +5684,16 @@ function extractDetail(sub, payload) {
   }
   return void 0;
 }
-function defaultReadFile2(path17) {
+function defaultReadFile2(path19) {
   try {
-    return readFileSync10(path17, "utf-8");
+    return readFileSync12(path19, "utf-8");
   } catch {
     return void 0;
   }
 }
-function defaultWriteFile(path17, content) {
-  mkdirSync6(path17.replace(/\/[^/]+$/, ""), { recursive: true });
-  writeFileSync7(path17, content, "utf-8");
+function defaultWriteFile(path19, content) {
+  mkdirSync6(path19.replace(/\/[^/]+$/, ""), { recursive: true });
+  writeFileSync8(path19, content, "utf-8");
 }
 
 // packages/workspaces/dist/crew-pane.js
@@ -5427,6 +5719,9 @@ async function settleInputBox(runtime, pane) {
 }
 async function confirmedSendToPane(runtime, pane, message) {
   const preSendScreen = await runtime.readPaneScreen(pane) ?? "";
+  if (hasModalOptionList(preSendScreen)) {
+    return { delivered: false, blockedByModal: true };
+  }
   await runtime.pasteToPane(pane, message);
   let sawDraft = await settleInputBox(runtime, pane);
   await runtime.sendKeyToPane(pane, "Enter");
@@ -5468,14 +5763,66 @@ async function resendCrewFirstTurn(runtime, captainName, project, name, message)
   return confirmedSendToPane(runtime, pane, message);
 }
 
+// packages/cli/src/lib/daemon-restart-broadcast.ts
+import fs16 from "fs";
+import path18 from "path";
+function statePath2(stateRoot) {
+  return path18.join(stateRoot, "daemon-restart-state.json");
+}
+function computeRestartSignature(version, buildMtimeMs) {
+  return `${version}::${buildMtimeMs}`;
+}
+function readPersistedRestartSignature(stateRoot) {
+  try {
+    const raw = fs16.readFileSync(statePath2(stateRoot), "utf-8");
+    const data = JSON.parse(raw);
+    return typeof data.signature === "string" ? data.signature : null;
+  } catch {
+    return null;
+  }
+}
+function writePersistedRestartSignature(stateRoot, signature) {
+  fs16.mkdirSync(stateRoot, { recursive: true });
+  fs16.writeFileSync(statePath2(stateRoot), JSON.stringify({ signature }, null, 2) + "\n");
+}
+function restartNotice(version, isDevRebuild) {
+  const suffix = isDevRebuild ? " (dev build)" : "";
+  return `\u26A0\uFE0F Daemon restarted \u2192 v${version}${suffix} (control-plane bounced). Re-verify in-flight crews \u2014 a crew mid-first-turn may need a crew send.`;
+}
+async function notifyCaptainsOfDaemonRestart(version, config, driver, isDevRebuild = false, appendCaptainMessage2) {
+  const notice = restartNotice(version, isDevRebuild);
+  for (const [projName] of Object.entries(config.projects)) {
+    try {
+      const proj = config.projects[projName];
+      const ref = await driver.status(proj.captainName);
+      if (ref) {
+        await appendCaptainMessage2(projName, notice);
+      }
+    } catch {
+    }
+  }
+}
+async function maybeBroadcastDaemonRestart(opts) {
+  try {
+    const { version, buildMtimeMs, stateRoot, config, driver, appendCaptainMessage: appendCaptainMessage2 } = opts;
+    const signature = computeRestartSignature(version, buildMtimeMs);
+    const previous = readPersistedRestartSignature(stateRoot);
+    if (previous === signature) return;
+    const isDevRebuild = previous !== null && previous.split("::")[0] === version;
+    await notifyCaptainsOfDaemonRestart(version, config, driver, isDevRebuild, appendCaptainMessage2);
+    writePersistedRestartSignature(stateRoot, signature);
+  } catch {
+  }
+}
+
 // packages/cli/src/squadrantd.ts
 var SELF_PATH2 = fileURLToPath3(import.meta.url);
-var CLI_BIN = join17(dirname5(SELF_PATH2), "index.js");
-var DAEMON_SOCK = join17(homedir12(), ".config", "squadrant", "squadrant.sock");
+var CLI_BIN = join18(dirname5(SELF_PATH2), "index.js");
+var DAEMON_SOCK = join18(homedir13(), ".config", "squadrant", "squadrant.sock");
 function readPkgVersion() {
   try {
-    const pkgPath = join17(dirname5(SELF_PATH2), "..", "package.json");
-    return JSON.parse(readFileSync11(pkgPath, "utf-8")).version ?? "unknown";
+    const pkgPath = join18(dirname5(SELF_PATH2), "..", "package.json");
+    return JSON.parse(readFileSync13(pkgPath, "utf-8")).version ?? "unknown";
   } catch {
     return "unknown";
   }
@@ -5490,7 +5837,7 @@ function buildTelegramBridge(cfg, stateRoot, log) {
   const client = createTelegramClient({ token });
   const ensureCaptainAlive = createEnsureCaptainAlive({
     isAlive: createIsCaptainAlive(DAEMON_SOCK),
-    launch: createLaunch(CLI_BIN)
+    launch: createLaunch(CLI_BIN, log)
   });
   const runCommand = createRunCommand(CLI_BIN);
   const sendReply = (threadId, text, replyMarkup) => client.sendMessage(cfg.supergroupId, threadId, text, replyMarkup);
@@ -5558,7 +5905,7 @@ function startSquadrantd(opts = {}) {
         (r) => r.mode === "interactive" && !TERMINAL_STATES.has(r.state) && r.cwd === hook.cwd
       );
     },
-    cursorFile: join17(stateRoot, "cmux-events.seq"),
+    cursorFile: join18(stateRoot, "cmux-events.seq"),
     log
   });
   const cmuxStoreSource = new CmuxStoreSource({ log });
@@ -5713,8 +6060,25 @@ ${buildCompletionProtocol(rec.id, rec.project)}`;
       log(`codex app-server source start failed: ${e.message}`);
     }
   }
+  if (!process.env.VITEST) {
+    try {
+      const buildMtimeMs = statSync3(SELF_PATH2).mtimeMs;
+      const restartConfig = loadConfig();
+      const registry = new RuntimeRegistry({ cmux: createCmuxDriver() });
+      void maybeBroadcastDaemonRestart({
+        version: PKG_VERSION,
+        buildMtimeMs,
+        stateRoot,
+        config: restartConfig,
+        driver: registry.global(restartConfig),
+        appendCaptainMessage: (project, text) => appendCaptainMessage({ stateRoot, project, text, source: "daemon" })
+      });
+    } catch (e) {
+      log(`daemon-restart broadcast setup failed: ${e.message}`);
+    }
+  }
   const origStop = h.stop.bind(h);
-  h.stop = async () => {
+  h.stop = async (reason) => {
     try {
       cmuxStoreSource.stop();
     } catch {
@@ -5727,28 +6091,42 @@ ${buildCompletionProtocol(rec.id, rec.project)}`;
       codexAppServerSource.stop();
     } catch {
     }
-    return origStop();
+    return origStop(reason);
   };
   return h;
 }
+function logCrashMarker(kind, err) {
+  const message = err instanceof Error ? err.stack ?? err.message : String(err);
+  process.stderr.write(`[squadrantd] ${(/* @__PURE__ */ new Date()).toISOString()} ${kind} pid=${process.pid} error=${message}
+`);
+}
 if (process.argv[1] && process.argv[1].endsWith("squadrantd.js")) {
+  process.on("uncaughtException", (err) => {
+    logCrashMarker("uncaughtException", err);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    logCrashMarker("unhandledRejection", reason);
+    process.exit(1);
+  });
   void (async () => {
     const arg = process.argv[2];
     if (arg === "--help" || arg === "-h" || arg === "--version" || arg === "-v") {
       process.stdout.write("squadrantd: launchd-managed daemon entry (no CLI args). Use `squadrant` for commands.\n");
       process.exit(0);
     }
-    const sock = join17(homedir12(), ".config", "squadrant", "squadrant.sock");
+    const sock = join18(homedir13(), ".config", "squadrant", "squadrant.sock");
     if (await isDaemonSocketLive(sock)) {
       process.stderr.write(`[squadrantd] refusing to start: a live daemon already owns ${sock}
 `);
       process.exit(0);
     }
     const h = startSquadrantd({ sweepMs: 3e4 });
-    process.on("SIGTERM", () => {
-      h.stop();
-      process.exit(0);
-    });
+    const shutdown = (signal) => {
+      void h.stop(signal).finally(() => process.exit(0));
+    };
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    process.on("SIGINT", () => shutdown("SIGINT"));
   })();
 }
 export {