squadrant 0.14.2 → 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,
@@ -588,6 +591,8 @@ function recoverStall(rec, now) {
 }
 
 // packages/core/dist/daemon/reduce.js
+var DEFAULT_FIRST_TURN_UNDELIVERED_BUDGET_MS = 12e4;
+var DEFAULT_FIRST_TURN_RESEND_COOLDOWN_MS = 6e4;
 var DEFAULT_TASK_TIMEOUT_MS = 8 * 60 * 60 * 1e3;
 var TERMINAL_RECORD_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 var TERMINAL_RECORD_KEEP_PER_PROJECT = 20;
@@ -708,6 +713,71 @@ function createDaemon(deps) {
   const { store, now } = deps;
   const lastCaptainTurnAt = /* @__PURE__ */ new Map();
   const quietNotifiedAt = /* @__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;
+  async function applyEvent(project, event) {
+    if (!KNOWN_EVENT_TYPES.has(event.type)) {
+      throw new Error(`unknown event type '${event.type}' \u2014 not a valid ControlEvent`);
+    }
+    const cur = store.get(project, event.id);
+    if (!cur)
+      throw new Error(`unknown task ${event.id}`);
+    if (event.type === "task.started")
+      lastCaptainTurnAt.set(event.id, now());
+    if (event.type === "task.session.ended" && !TERMINAL_STATES.has(cur.state)) {
+      const liveness = deps.isSurfaceAlive ? await deps.isSurfaceAlive(cur) : "unknown";
+      if (liveness !== "gone")
+        return cur;
+    }
+    const next = reduce(cur, event, now());
+    if (next !== cur) {
+      store.put(next);
+      firePush(deps, project, cur.state, next, event, lastCaptainTurnAt.get(next.id));
+    }
+    return next;
+  }
+  async function attemptFirstTurnRecovery(r, undeliveredMs) {
+    const lastAttempt = resendAttemptedAt.get(r.id);
+    if (lastAttempt != null && now() - lastAttempt < firstTurnResendCooldownMs)
+      return;
+    resendAttemptedAt.set(r.id, now());
+    const fresh = store.get(r.project, r.id);
+    if (!fresh || fresh.firstTurnConfirmedAt)
+      return;
+    const tag = crewTag(fresh);
+    const fireNotify = (message) => {
+      if (!deps.notify)
+        return;
+      const synthEvent = { type: "task.quiet", id: fresh.id, quietMs: undeliveredMs };
+      try {
+        const p = deps.notify({ project: fresh.project, message, record: store.get(fresh.project, fresh.id) ?? fresh, event: synthEvent });
+        if (p && typeof p.catch === "function")
+          p.catch(() => {
+          });
+      } catch {
+      }
+    };
+    if (!deps.resendFirstTurn) {
+      fireNotify(`\u26A0\uFE0F CREW UNDELIVERED ${tag}: first turn may not have landed (0 activity) \u2014 re-send the task or check the spawn.`);
+      return;
+    }
+    let result;
+    try {
+      result = await deps.resendFirstTurn(fresh);
+    } catch {
+      result = { delivered: false };
+    }
+    if (result.delivered) {
+      try {
+        await applyEvent(fresh.project, { type: "task.first-turn.confirmed", id: fresh.id });
+      } catch {
+      }
+      fireNotify(`\u{1F501} CREW FIRST-TURN AUTO-RESENT ${tag}: first turn had not landed after ${Math.round(undeliveredMs / 1e3)}s \u2014 re-sent automatically.`);
+    } else {
+      fireNotify(`\u26A0\uFE0F CREW UNDELIVERED ${tag}: first turn may not have landed \u2014 auto-resend attempted but the pane wasn't ready; will retry.`);
+    }
+  }
   return {
     async handle(req) {
       switch (req.kind) {
@@ -754,22 +824,7 @@ function createDaemon(deps) {
           if (!KNOWN_EVENT_TYPES.has(req.event.type)) {
             throw new Error(`unknown event type '${req.event.type}' \u2014 not a valid ControlEvent`);
           }
-          const cur = store.get(req.project, req.event.id);
-          if (!cur)
-            throw new Error(`unknown task ${req.event.id}`);
-          if (req.event.type === "task.started")
-            lastCaptainTurnAt.set(req.event.id, now());
-          if (req.event.type === "task.session.ended" && !TERMINAL_STATES.has(cur.state)) {
-            const liveness = deps.isSurfaceAlive ? await deps.isSurfaceAlive(cur) : "unknown";
-            if (liveness !== "gone")
-              return cur;
-          }
-          const next = reduce(cur, req.event, now());
-          if (next !== cur) {
-            store.put(next);
-            firePush(deps, req.project, cur.state, next, req.event, lastCaptainTurnAt.get(next.id));
-          }
-          return next;
+          return applyEvent(req.project, req.event);
         }
         case "status": {
           const r = store.get(req.project, req.id);
@@ -828,6 +883,7 @@ function createDaemon(deps) {
           store.delete(r.project, r.id);
         }
       }
+      const recoveryPromises = [];
       for (const r of store.listAll()) {
         if (TERMINAL_STATES.has(r.state) && t - r.lastHeartbeat > TERMINAL_RECORD_TTL_MS) {
           store.delete(r.project, r.id);
@@ -869,21 +925,9 @@ function createDaemon(deps) {
           }
         }
         if (r.mode === "interactive" && r.state === "submitted" && !r.firstTurnConfirmedAt) {
-          const elapsed = t - r.lastHeartbeat;
-          if (elapsed > r.heartbeatBudgetMs) {
-            if (deps.notify && quietNotifiedAt.get(r.id) !== r.lastHeartbeat) {
-              quietNotifiedAt.set(r.id, r.lastHeartbeat);
-              const tag = crewTag(r);
-              const synthEvent = { type: "task.quiet", id: r.id, quietMs: elapsed };
-              const message = `\u26A0\uFE0F CREW UNDELIVERED ${tag}: first turn may not have landed (crew never started) \u2014 re-send the task or check the spawn.`;
-              try {
-                const p = deps.notify({ project: r.project, message, record: r, event: synthEvent });
-                if (p && typeof p.catch === "function")
-                  p.catch(() => {
-                  });
-              } catch {
-              }
-            }
+          const undeliveredMs = t - r.createdAt;
+          if (undeliveredMs > firstTurnUndeliveredBudgetMs) {
+            recoveryPromises.push(attemptFirstTurnRecovery(r, undeliveredMs));
             continue;
           }
         }
@@ -894,7 +938,14 @@ function createDaemon(deps) {
           firePush(deps, r.project, r.state, idle, synthEvent, lastCaptainTurnAt.get(r.id));
           continue;
         }
-        if (r.mode === "interactive" && r.state === "working" && !r.pendingTool) {
+        if (r.mode === "interactive" && r.state === "working" && !r.pendingTool && !r.firstTurnConfirmedAt) {
+          const undeliveredMs = t - r.createdAt;
+          if (undeliveredMs > firstTurnUndeliveredBudgetMs) {
+            recoveryPromises.push(attemptFirstTurnRecovery(r, undeliveredMs));
+            continue;
+          }
+        }
+        if (r.mode === "interactive" && r.state === "working" && !r.pendingTool && r.firstTurnConfirmedAt) {
           const liveness = r.attempts.at(-1)?.lastHeartbeatAt ?? r.lastHeartbeat;
           const quiet = t - liveness;
           if (quiet > r.heartbeatBudgetMs) {
@@ -902,13 +953,8 @@ function createDaemon(deps) {
               quietNotifiedAt.set(r.id, liveness);
               const tag = crewTag(r);
               const synthEvent = { type: "task.quiet", id: r.id, quietMs: quiet };
-              let message;
-              if (!r.firstTurnConfirmedAt) {
-                message = `\u26A0\uFE0F CREW UNDELIVERED ${tag}: first turn may not have landed (0 activity) \u2014 re-send the task or check the spawn.`;
-              } else {
-                const mins = Math.max(1, Math.round(quiet / 6e4));
-                message = `CREW QUIET ${tag}: working ~${mins}min with no tool activity \u2014 likely deep thinking (no reply expected yet).`;
-              }
+              const mins = Math.max(1, Math.round(quiet / 6e4));
+              const message = `CREW QUIET ${tag}: working ~${mins}min with no tool activity \u2014 likely deep thinking (no reply expected yet).`;
               try {
                 const p = deps.notify({ project: r.project, message, record: r, event: synthEvent });
                 if (p && typeof p.catch === "function")
@@ -926,6 +972,7 @@ function createDaemon(deps) {
         if (recovered && t - r.lastHeartbeat <= r.heartbeatBudgetMs)
           store.put(recovered);
       }
+      await Promise.all(recoveryPromises);
     },
     async reconcile() {
       const alive = deps.isPidAlive ?? (() => true);
@@ -1399,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({
@@ -1437,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";
@@ -1595,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);
@@ -1616,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}
@@ -1637,8 +1770,12 @@ 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,
     notify: null,
@@ -1991,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;
@@ -2008,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({
@@ -2035,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 ?? {}),
@@ -2046,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);
@@ -2195,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 {
@@ -2204,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 };
   }
@@ -2218,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);
@@ -2259,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++;
       }
@@ -2309,6 +2494,7 @@ function startDaemon(ctx, opts, pkgVersion) {
     notify,
     taskTimeoutMs,
     isSurfaceAlive: surfaceProbe,
+    resendFirstTurn: ctx.resendFirstTurn,
     launchHeadless: opts.launchHeadless,
     isHeadlessInFlight: (id) => inFlightHeadlessIds.has(id),
     launchInteractive: async (rec) => {
@@ -2343,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)
       }));
@@ -2549,6 +2734,21 @@ import crypto from "crypto";
 import fs8 from "fs";
 import path7 from "path";
 
+// packages/core/dist/crew-protocol.js
+function buildCompletionProtocol(taskId, project) {
+  return [
+    "---",
+    "COMPLETION PROTOCOL (required): When this task is fully complete, your FINAL action MUST be to run exactly:",
+    `  squadrant crew signal done --task-id ${taskId} --project ${project} --message "<one-line summary>"`,
+    "Run it as a discrete final step AFTER you report your results. If you are blocked or need a decision, instead run:",
+    `  squadrant crew signal blocked --task-id ${taskId} --project ${project} --question "<your question>"`,
+    "If this task failed because of a defect in squadrant itself (not an API/infra blip, a config/user error, or an expected failure), say so in your signal done/blocked message so the captain can check tu11aa/squadrant and file it. Don't file issues from the crew."
+  ].join("\n");
+}
+function titleFor(project, name) {
+  return `\u{1F527} ${project}:${name}`;
+}
+
 // packages/core/dist/crew-lifecycle.js
 import { exec as nodeExec } from "child_process";
 
@@ -2692,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
@@ -3248,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}`);
       }
@@ -4079,7 +4294,7 @@ var OpencodeSseBridge = class {
     const fetchImpl = this.deps.fetchImpl ?? fetch;
     const sleep3 = this.deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
     const reconnectMs = this.deps.reconnectMs ?? 500;
-    const maxBoot = this.deps.maxBootAttempts ?? 60;
+    const maxBoot = this.deps.maxBootAttempts ?? 240;
     const url = `http://127.0.0.1:${port}/event`;
     let booted = false;
     let bootAttempts = 0;
@@ -4176,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";
 
@@ -4433,6 +4648,27 @@ function parseDraftFromScreen(screen) {
   }
   return "";
 }
+function hasCCInputBox(screen) {
+  if (!screen)
+    return false;
+  const lines = screen.split(/\r?\n/);
+  const HR_RE = /^\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 (bottomHR === -1)
+        bottomHR = i;
+      else {
+        topHR = i;
+        break;
+      }
+    }
+  }
+  if (topHR === -1)
+    return false;
+  return lines.slice(topHR + 1, bottomHR).some((l) => /[>❯]/.test(l));
+}
 function hasModalOptionList(screen) {
   if (!screen)
     return false;
@@ -4483,6 +4719,15 @@ function readInputBoxRaw(screen, opts) {
   const joined = parts.join("");
   return opts?.trim === false ? joined : joined.replace(/\s+$/, "");
 }
+var CC_INITIALIZED_RE = /⏵⏵|Ctx Used|for shortcuts|accept edits/i;
+var CC_WORKING_RE = /↓\s*[\d.]+\s*k?\s*tokens?\b|esc to interrupt|\bshell still running\b|·\s*\d+\s*shell\b|\(\d+m?\s*\d*s\b/i;
+function classifyStartupSurface(screen) {
+  if (CC_WORKING_RE.test(screen))
+    return "working";
+  if (CC_INITIALIZED_RE.test(screen))
+    return "idle";
+  return "loading";
+}
 function sendDebugEnabled() {
   return !!process.env.SQUADRANT_DEBUG_SEND;
 }
@@ -4772,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";
 
@@ -4914,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;
@@ -4965,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;
@@ -4991,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;
@@ -5053,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)`);
@@ -5119,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;
   }
@@ -5141,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"],
@@ -5155,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;
@@ -5301,29 +5659,141 @@ 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
 import net from "net";
+var POST_SEND_CHECK_MS = 750;
+var SETTLE_POLL_MS = 400;
+var SETTLE_MAX_POLLS = 8;
+var SUBMIT_RETRY_LIMIT = 4;
+async function settleInputBox(runtime, pane) {
+  let prev = await runtime.readPaneScreen(pane) ?? "";
+  let sawContent = parseDraftFromScreen(prev) !== "" && parseDraftFromScreen(prev) !== null;
+  for (let i = 0; i < SETTLE_MAX_POLLS; i++) {
+    await new Promise((r) => setTimeout(r, SETTLE_POLL_MS));
+    const cur = await runtime.readPaneScreen(pane) ?? "";
+    const draft = parseDraftFromScreen(cur);
+    if (draft !== "" && draft !== null)
+      sawContent = true;
+    if (cur === prev)
+      return sawContent;
+    prev = cur;
+  }
+  return sawContent;
+}
+async function confirmedSendToPane(runtime, pane, message) {
+  const preSendScreen = await runtime.readPaneScreen(pane) ?? "";
+  await runtime.pasteToPane(pane, message);
+  let sawDraft = await settleInputBox(runtime, pane);
+  await runtime.sendKeyToPane(pane, "Enter");
+  let repasted = false;
+  for (let attempt = 0; attempt < SUBMIT_RETRY_LIMIT; attempt++) {
+    await new Promise((r) => setTimeout(r, POST_SEND_CHECK_MS));
+    const afterScreen = await runtime.readPaneScreen(pane) ?? "";
+    const draft = parseDraftFromScreen(afterScreen);
+    if (draft !== "" && draft !== null)
+      sawDraft = true;
+    if (draft === "" && sawDraft)
+      return { delivered: true };
+    if (draft === null && afterScreen !== preSendScreen && sawDraft)
+      return { delivered: true };
+    const settled = await settleInputBox(runtime, pane);
+    if (settled)
+      sawDraft = true;
+    if (!sawDraft && !repasted) {
+      repasted = true;
+      await runtime.pasteToPane(pane, message);
+    }
+    await runtime.sendKeyToPane(pane, "Enter");
+  }
+  return { delivered: false };
+}
+async function resendCrewFirstTurn(runtime, captainName, project, name, message) {
+  const captain = await runtime.status(captainName);
+  if (!captain)
+    return { delivered: false };
+  const surfaces = await runtime.listSurfaces(captain.id);
+  const want = titleFor(project, name);
+  const pane = surfaces.find((s) => s.title === want);
+  if (!pane)
+    return { delivered: false };
+  const screen = await runtime.readPaneScreen(pane) ?? "";
+  if (!hasCCInputBox(screen) || classifyStartupSurface(screen) !== "idle") {
+    return { delivered: false };
+  }
+  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";
   }
@@ -5338,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);
@@ -5406,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 });
@@ -5418,6 +5888,16 @@ function startSquadrantd(opts = {}) {
   const tgCfg = loadConfig().telegram;
   ctx.telegramBridge = opts.telegramBridge ?? (tgCfg && !process.env.VITEST ? buildTelegramBridge(tgCfg, stateRoot, log) : void 0);
   ctx.daemonCmux = opts.daemonCmux ?? (opts.makeDaemonCmux ?? (() => new DaemonCmux(createCmuxDriver())))();
+  const resendRuntime = createCmuxDriver();
+  ctx.resendFirstTurn = opts.resendFirstTurn ?? (async (rec) => {
+    if (rec.provider !== "claude" || !rec.name) return { delivered: false };
+    const proj = loadConfig().projects[rec.project];
+    const captainName = proj?.captainName ?? `${rec.project}-captain`;
+    const message = `${rec.task}
+
+${buildCompletionProtocol(rec.id, rec.project)}`;
+    return resendCrewFirstTurn(resendRuntime, captainName, rec.project, rec.name, message);
+  });
   const launchHeadless = opts.launchHeadless ?? (async (rec) => {
     const ingest = (e) => void ctx.d.handle({ kind: "event", project: rec.project, event: e });
     const handle = runHeadless({
@@ -5551,6 +6031,22 @@ function startSquadrantd(opts = {}) {
       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 {
@@ -5576,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}
 `);