squadrant 0.14.3 → 0.15.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 path18 = opts.path ?? defaultCmuxConfigPath();
+  if (!existsSync(path18)) {
+    mkdirSync(dirname(path18), { recursive: true });
+    writeFileSync(path18, MINIMAL_TEMPLATE);
+    return { path: path18, changed: true, alreadySet: false };
   }
-  const text = readFileSync(path17, "utf-8");
+  const text = readFileSync(path18, "utf-8");
   const current = parse(text)?.automation?.socketControlMode;
   if (current === AUTOMATION_MODE) {
-    return { path: path17, changed: false, alreadySet: true };
+    return { path: path18, 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(path18, applyEdits(text, edits));
+  return { path: path18, 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(path18) {
   try {
-    return JSON.parse(readFileSync4(path17, "utf-8"));
+    return JSON.parse(readFileSync4(path18, "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,
@@ -1443,14 +1446,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 +1484,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 +1662,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 +1749,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 +1770,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 +2128,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 +2144,62 @@ 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();
+  for (const r of records) {
+    if (r.role !== "captain")
+      continue;
+    seen.add(r.project);
+    const entry = {
+      project: r.project,
+      role: "captain",
+      pid: r.pid,
+      sessionId: r.sessionId,
+      startedAt: now,
+      lastState: "start",
+      lastSeenAt: now,
+      pidAlive: r.pid != null ? deps.isPidAlive(r.pid) : true,
+      // pid:null hibernated → alive-unknown
+      source: "runtime"
+    };
+    const prev = deps.registry.get(r.project);
+    if (prev && prev.lastState === "start")
+      entry.startedAt = prev.startedAt;
+    deps.registry.apply(entry);
+    if (r.pid != null)
+      deps.registry.setPidAlive(r.project, deps.isPidAlive(r.pid), now);
+    logEntry(deps.log, r.project, deps.registry.get(r.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,6 +2225,21 @@ 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 ?? {}),
@@ -2091,34 +2251,14 @@ function createDelivery(ctx, daemonCmux) {
       const captainTitle = 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);
@@ -2240,7 +2380,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 +2389,10 @@ function distBuiltAt() {
     return 0;
   }
 }
-function gatherLogStats(path17, now, windowMs) {
+function gatherLogStats(path18, now, windowMs) {
   let sizeBytes = 0;
   try {
-    sizeBytes = statSync2(path17).size;
+    sizeBytes = statSync2(path18).size;
   } catch {
     return { errorCount: 0, sizeBytes: 0, windowMs };
   }
@@ -2263,7 +2403,7 @@ function gatherLogStats(path17, now, windowMs) {
   const len = sizeBytes - start;
   let text = "";
   try {
-    const fd = openSync2(path17, "r");
+    const fd = openSync2(path18, "r");
     try {
       const buf = Buffer.alloc(len);
       readSync(fd, buf, 0, len, start);
@@ -2304,7 +2444,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 +2529,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)
       }));
@@ -2753,21 +2892,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
@@ -3309,8 +3460,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}`);
       }
@@ -4237,7 +4391,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,6 +5017,38 @@ 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";
 
@@ -5005,6 +5191,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 +5307,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 +5349,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 +5411,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 +5477,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(path18) {
   try {
-    return readFileSync9(path17, "utf-8");
+    return readFileSync11(path18, "utf-8");
   } catch {
     return void 0;
   }
@@ -5232,9 +5499,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 +5513,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 +5659,16 @@ function extractDetail(sub, payload) {
   }
   return void 0;
 }
-function defaultReadFile2(path17) {
+function defaultReadFile2(path18) {
   try {
-    return readFileSync10(path17, "utf-8");
+    return readFileSync12(path18, "utf-8");
   } catch {
     return void 0;
   }
 }
-function defaultWriteFile(path17, content) {
-  mkdirSync6(path17.replace(/\/[^/]+$/, ""), { recursive: true });
-  writeFileSync7(path17, content, "utf-8");
+function defaultWriteFile(path18, content) {
+  mkdirSync6(path18.replace(/\/[^/]+$/, ""), { recursive: true });
+  writeFileSync8(path18, content, "utf-8");
 }
 
 // packages/workspaces/dist/crew-pane.js
@@ -5468,14 +5735,65 @@ async function resendCrewFirstTurn(runtime, captainName, project, name, message)
   return confirmedSendToPane(runtime, pane, message);
 }
 
+// packages/cli/src/lib/daemon-restart-broadcast.ts
+import fs15 from "fs";
+import path17 from "path";
+function statePath2(stateRoot) {
+  return path17.join(stateRoot, "daemon-restart-state.json");
+}
+function computeRestartSignature(version, buildMtimeMs) {
+  return `${version}::${buildMtimeMs}`;
+}
+function readPersistedRestartSignature(stateRoot) {
+  try {
+    const raw = fs15.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) {
+  fs15.mkdirSync(stateRoot, { recursive: true });
+  fs15.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) {
+  const notice = restartNotice(version, isDevRebuild);
+  for (const [, proj] of Object.entries(config.projects)) {
+    try {
+      const ref = await driver.status(proj.captainName);
+      if (ref) {
+        await driver.send(ref.id, notice);
+      }
+    } catch {
+    }
+  }
+}
+async function maybeBroadcastDaemonRestart(opts) {
+  try {
+    const { version, buildMtimeMs, stateRoot, config, driver } = 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);
+    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 +5808,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 +5876,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,6 +6031,22 @@ ${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)
+      });
+    } catch (e) {
+      log(`daemon-restart broadcast setup failed: ${e.message}`);
+    }
+  }
   const origStop = h.stop.bind(h);
   h.stop = async () => {
     try {
@@ -5738,7 +6072,7 @@ if (process.argv[1] && process.argv[1].endsWith("squadrantd.js")) {
       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}
 `);