@sema-agent/cli 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/cli",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Sema — your own Claude Code-grade coding agent, in the terminal.",
   "license": "BUSL-1.1",
   "bin": {
@@ -21,7 +21,7 @@
   ],
   "dependencies": {
     "@sema-agent/sdk": "^0.0.46",
-    "@sema-agent/server": "^1.185.0"
+    "@sema-agent/server": "^1.186.0"
   },
   "engines": {
     "node": ">=18"

package/sema.js

@@ -103078,7 +103078,7 @@ var init_ErrorOverview = __esm({
 var import_react9, TerminalSizeContext;
 var init_TerminalSizeContext = __esm({
   "build-src/src/ink/components/TerminalSizeContext.tsx"() {
-    import_react9 = __toESM(require_react(), 1);
+    import_react9 = __toESM(require_react());
     TerminalSizeContext = (0, import_react9.createContext)(null);
   }
 });
@@ -162088,6 +162088,13 @@ var init_engineTaskListSync = __esm({
 });
 
 // build-src/src/sema/upstreamBridge.ts
+function engineTaskNotificationDedupKey(n2) {
+  const taskId = typeof n2.task_id === "string" ? n2.task_id : "";
+  const rawStatus = typeof n2.status === "string" ? n2.status : "completed";
+  const seq = typeof n2.seq === "number" || typeof n2.seq === "string" ? String(n2.seq) : "";
+  const lane = n2.task_type === "external" ? "external:" : "";
+  return `${lane}${taskId}:${rawStatus}${seq ? `:${seq}` : ""}`;
+}
 function deriveNotificationResidualLines(n2) {
   const out6 = [];
   if (Array.isArray(n2.recentSteps)) {
@@ -163161,8 +163168,7 @@ async function* sdkMessagesToCcEvents(sdk, meta4) {
         const taskId = typeof n2.task_id === "string" ? n2.task_id : void 0;
         if (taskId === void 0) break;
         const rawStatus = typeof n2.status === "string" ? n2.status : "completed";
-        const seq = typeof n2.seq === "number" || typeof n2.seq === "string" ? String(n2.seq) : "";
-        const dedupKey = `${taskId}:${rawStatus}${seq ? `:${seq}` : ""}`;
+        const dedupKey = engineTaskNotificationDedupKey(n2);
         if (renderedEngineTaskNotifications.has(dedupKey)) break;
         renderedEngineTaskNotifications.add(dedupKey);
         markEngineWorkflowNotified(taskId);
@@ -362347,7 +362353,13 @@ function mapResponse(r) {
 }
 async function dispatchJob(job) {
   let info = await ensureDaemonRunning();
-  if (!info) return { ok: false, code: "daemon-unreachable" };
+  if (!info) {
+    return {
+      ok: false,
+      code: "daemon-unreachable",
+      message: "the daemon was spawned but never came up (it likely crashed on boot)"
+    };
+  }
   const nonce = randomUUID17();
   for (let attempt = 0; attempt < 3; attempt++) {
     try {
@@ -363585,7 +363597,15 @@ async function handleBgFlagDaemon(rest, head) {
     } else if (result.code === "stale-short") {
       process.stderr.write("Previous session is still shutting down \u2014 try again in a moment\n");
     } else {
+      const { getDaemonLogPath: getDaemonLogPath2 } = await Promise.resolve().then(() => (init_state2(), state_exports2));
       process.stderr.write("Couldn't reach the daemon (not running)\n");
+      if (result.message) process.stderr.write(`  cause: ${result.message}
+`);
+      process.stderr.write(
+        `  The task was NOT started. Check ${getDaemonLogPath2()} for the daemon's crash log,
+  or run \`sema daemon run\` in a terminal to see the failure live, then retry \`sema --bg\`.
+`
+      );
     }
     process.exitCode = 1;
     return;
@@ -409348,33 +409368,44 @@ function drainPendingMessages(taskId, getAppState, setAppState) {
   }));
   return drained;
 }
-function enqueueAgentNotification({
+function agentHasLiveBackgroundChildren(agentId, tasks3) {
+  for (const t2 of Object.values(tasks3)) {
+    if (isLocalAgentTask(t2) && t2.ownerAgentId === agentId && (t2.status === "running" || t2.status === "pending")) {
+      return true;
+    }
+  }
+  return false;
+}
+function flushDeferredOwnerNotification(ownerAgentId, setAppState) {
+  if (!ownerAgentId || !deferredOwnerNotifications.has(ownerAgentId)) {
+    return;
+  }
+  let tasksSnapshot;
+  setAppState((prev) => {
+    tasksSnapshot = prev.tasks;
+    return prev;
+  });
+  if (!tasksSnapshot) return;
+  if (agentHasLiveBackgroundChildren(ownerAgentId, tasksSnapshot)) return;
+  const message = deferredOwnerNotifications.get(ownerAgentId);
+  if (!message) return;
+  deferredOwnerNotifications.delete(ownerAgentId);
+  enqueuePendingNotification({
+    value: message,
+    mode: "task-notification"
+  });
+}
+function buildAgentNotificationMessage({
   taskId,
   description,
   status: status3,
   error: error52,
-  setAppState,
   finalMessage,
   usage,
   toolUseId,
   worktreePath,
   worktreeBranch
 }) {
-  let shouldEnqueue = false;
-  updateTaskState(taskId, setAppState, (task) => {
-    if (task.notified) {
-      return task;
-    }
-    shouldEnqueue = true;
-    return {
-      ...task,
-      notified: true
-    };
-  });
-  if (!shouldEnqueue) {
-    return;
-  }
-  abortSpeculation(setAppState);
   const summary = status3 === "completed" ? `Agent "${description}" completed` : status3 === "failed" ? `Agent "${description}" failed: ${error52 || "Unknown error"}` : `Agent "${description}" was stopped`;
   const outputPath = getTaskOutputPath(taskId);
   const toolUseIdLine = toolUseId ? `
@@ -409385,12 +409416,65 @@ function enqueueAgentNotification({
 <usage><total_tokens>${usage.totalTokens}</total_tokens><tool_uses>${usage.toolUses}</tool_uses><duration_ms>${usage.durationMs}</duration_ms></usage>` : "";
   const worktreeSection = worktreePath ? `
 <${WORKTREE_TAG}><${WORKTREE_PATH_TAG}>${worktreePath}</${WORKTREE_PATH_TAG}>${worktreeBranch ? `<${WORKTREE_BRANCH_TAG}>${worktreeBranch}</${WORKTREE_BRANCH_TAG}>` : ""}</${WORKTREE_TAG}>` : "";
-  const message = `<${TASK_NOTIFICATION_TAG}>
+  return `<${TASK_NOTIFICATION_TAG}>
 <${TASK_ID_TAG}>${taskId}</${TASK_ID_TAG}>${toolUseIdLine}
 <${OUTPUT_FILE_TAG}>${outputPath}</${OUTPUT_FILE_TAG}>
 <${STATUS_TAG}>${status3}</${STATUS_TAG}>
-<${SUMMARY_TAG}>${summary}</${SUMMARY_TAG}>${resultSection}${usageSection}${worktreeSection}
+<${SUMMARY_TAG}>${summary}</${SUMMARY_TAG}>
+<note>${TASK_NOTIFICATION_NOTE}</note>${resultSection}${usageSection}${worktreeSection}
 </${TASK_NOTIFICATION_TAG}>`;
+}
+function enqueueAgentNotification({
+  taskId,
+  description,
+  status: status3,
+  error: error52,
+  setAppState,
+  finalMessage,
+  usage,
+  toolUseId,
+  worktreePath,
+  worktreeBranch
+}) {
+  let decision = "skip";
+  setAppState((prev) => {
+    const task = prev.tasks?.[taskId];
+    if (!isLocalAgentTask(task)) {
+      return prev;
+    }
+    if (task.notified) {
+      decision = "skip";
+      return prev;
+    }
+    const parkOnChildren = status3 === "completed" && agentHasLiveBackgroundChildren(taskId, prev.tasks);
+    decision = parkOnChildren ? "defer" : "enqueue";
+    return {
+      ...prev,
+      tasks: {
+        ...prev.tasks,
+        [taskId]: { ...task, notified: true }
+      }
+    };
+  });
+  if (decision === "skip") {
+    return;
+  }
+  abortSpeculation(setAppState);
+  const message = buildAgentNotificationMessage({
+    taskId,
+    description,
+    status: status3,
+    error: error52,
+    finalMessage,
+    usage,
+    toolUseId,
+    worktreePath,
+    worktreeBranch
+  });
+  if (decision === "defer") {
+    deferredOwnerNotifications.set(taskId, message);
+    return;
+  }
   enqueuePendingNotification({
     value: message,
     mode: "task-notification"
@@ -409398,11 +409482,13 @@ function enqueueAgentNotification({
 }
 function killAsyncAgent(taskId, setAppState) {
   let killed = false;
+  let ownerAgentId;
   updateTaskState(taskId, setAppState, (task) => {
     if (task.status !== "running") {
       return task;
     }
     killed = true;
+    ownerAgentId = task.ownerAgentId;
     task.abortController?.abort();
     task.unregisterCleanup?.();
     return {
@@ -409417,6 +409503,7 @@ function killAsyncAgent(taskId, setAppState) {
   });
   if (killed) {
     void evictTaskOutput(taskId);
+    flushDeferredOwnerNotification(ownerAgentId, setAppState);
   }
 }
 function killAllRunningAgentTasks(tasks3, setAppState) {
@@ -409494,10 +409581,12 @@ function updateAgentSummary(taskId, summary, setAppState) {
 }
 function completeAgentTask(result, setAppState) {
   const taskId = result.agentId;
+  let ownerAgentId;
   updateTaskState(taskId, setAppState, (task) => {
     if (task.status !== "running") {
       return task;
     }
+    ownerAgentId = task.ownerAgentId;
     task.unregisterCleanup?.();
     return {
       ...task,
@@ -409511,12 +409600,15 @@ function completeAgentTask(result, setAppState) {
     };
   });
   void evictTaskOutput(taskId);
+  flushDeferredOwnerNotification(ownerAgentId, setAppState);
 }
 function failAgentTask(taskId, error52, setAppState) {
+  let ownerAgentId;
   updateTaskState(taskId, setAppState, (task) => {
     if (task.status !== "running") {
       return task;
     }
+    ownerAgentId = task.ownerAgentId;
     task.unregisterCleanup?.();
     return {
       ...task,
@@ -409530,6 +409622,7 @@ function failAgentTask(taskId, error52, setAppState) {
     };
   });
   void evictTaskOutput(taskId);
+  flushDeferredOwnerNotification(ownerAgentId, setAppState);
 }
 function registerAsyncAgent({
   agentId,
@@ -409542,11 +409635,13 @@ function registerAsyncAgent({
 }) {
   void initTaskOutputAsSymlink(agentId, getAgentTranscriptPath(asAgentId(agentId)));
   const abortController = parentAbortController ? createChildAbortController(parentAbortController) : createAbortController();
+  const ownerAgentId = getAgentContext()?.agentId;
   const taskState = {
     ...createTaskStateBase(agentId, "local_agent", description, toolUseId),
     type: "local_agent",
     status: "running",
     agentId,
+    ownerAgentId,
     prompt,
     selectedAgent,
     agentType: selectedAgent.agentType ?? "general-purpose",
@@ -409581,11 +409676,13 @@ function registerAgentForeground({
   const unregisterCleanup2 = registerCleanup(async () => {
     killAsyncAgent(agentId, setAppState);
   });
+  const ownerAgentId = getAgentContext()?.agentId;
   const taskState = {
     ...createTaskStateBase(agentId, "local_agent", description, toolUseId),
     type: "local_agent",
     status: "running",
     agentId,
+    ownerAgentId,
     prompt,
     selectedAgent,
     agentType: selectedAgent.agentType ?? "general-purpose",
@@ -409688,7 +409785,7 @@ function unregisterAgentForeground(taskId, setAppState) {
   });
   cleanupFn?.();
 }
-var MAX_RECENT_ACTIVITIES2, LocalAgentTask, backgroundSignalResolvers;
+var MAX_RECENT_ACTIVITIES2, TASK_NOTIFICATION_NOTE, deferredOwnerNotifications, LocalAgentTask, backgroundSignalResolvers;
 var init_LocalAgentTask = __esm({
   "build-src/src/tasks/LocalAgentTask/LocalAgentTask.tsx"() {
     init_state();
@@ -409699,6 +409796,7 @@ var init_LocalAgentTask = __esm({
     init_SyntheticOutputTool();
     init_ids();
     init_abortController();
+    init_agentContext();
     init_cleanupRegistry();
     init_collapseReadSearch();
     init_messageQueueManager();
@@ -409707,6 +409805,8 @@ var init_LocalAgentTask = __esm({
     init_framework();
     init_sdkProgress();
     MAX_RECENT_ACTIVITIES2 = 5;
+    TASK_NOTIFICATION_NOTE = "A task-notification fires each time this agent stops with no live background children of its own. The user can send it another message and resume it, so the same task-id may notify more than once.";
+    deferredOwnerNotifications = /* @__PURE__ */ new Map();
     LocalAgentTask = {
       name: "LocalAgentTask",
       type: "local_agent",
@@ -428073,22 +428173,28 @@ __export(engineLifecycleManager_exports, {
   getServiceAuthToken: () => getServiceAuthToken,
   hasManageableLocalEngine: () => hasManageableLocalEngine,
   initEngineLifecycle: () => initEngineLifecycle,
+  installEngineExitTeardown: () => installEngineExitTeardown,
   isLocalEngineActive: () => isLocalEngineActive,
   isProcessAlive: () => isProcessAlive,
+  isShellHostDead: () => isShellHostDead,
   pickFreeEnginePort: () => pickFreeEnginePort,
   pinnedEnginePort: () => pinnedEnginePort,
   probeHealth: () => probeHealth,
   probeLocalEngineHealth: () => probeLocalEngineHealth,
   readMemorySyncSettings: () => readMemorySyncSettings,
   readWorkflowSizeGuidelineSetting: () => readWorkflowSizeGuidelineSetting,
+  requestEngineRetryNow: () => requestEngineRetryNow,
   resetDeadRespawnStateForTests: () => resetDeadRespawnStateForTests,
+  resetEngineExitTeardownForTests: () => resetEngineExitTeardownForTests,
   resolveEngineEntry: () => resolveEngineEntry,
   respawnOnConfigDrift: () => respawnOnConfigDrift,
   restartEngine: () => restartEngine,
   runEngineDeadRespawn: () => runEngineDeadRespawn,
+  setLocalEngineActiveForTests: () => setLocalEngineActiveForTests,
   setOnOwnedEngineExit: () => setOnOwnedEngineExit,
   shutdownEngine: () => shutdownEngine,
-  startHealthCheckLoop: () => startHealthCheckLoop
+  startHealthCheckLoop: () => startHealthCheckLoop,
+  teardownOwnedEngineSync: () => teardownOwnedEngineSync
 });
 import { spawn as spawn10 } from "child_process";
 import { createServer as createServer7 } from "net";
@@ -428918,12 +429024,28 @@ function resetDeadRespawnStateForTests() {
   recentDeathTimestamps = [];
   cooldownRetryPending = false;
   cooldownRetryLevel = 0;
+  cooldownRetryFire = void 0;
+  cooldownRetryAt = 0;
+  if (cooldownRetryTimer) clearTimeout(cooldownRetryTimer);
+  cooldownRetryTimer = void 0;
 }
 function nextCooldownDelayMs() {
   return Math.min(CRASH_LOOP_COOLDOWN_BASE_MS * 2 ** cooldownRetryLevel, CRASH_LOOP_COOLDOWN_CAP_MS);
 }
+function stampFailedNextRetryAt() {
+  try {
+    const cur = getEngineRuntimeStatus();
+    if (cur.phase === "failed" && cooldownRetryAt > Date.now()) {
+      setEngineRuntimeStatus({ phase: "failed", detail: cur.detail, nextRetryAt: cooldownRetryAt });
+    }
+  } catch {
+  }
+}
 function scheduleCooldownRetry(deps2) {
-  if (cooldownRetryPending) return;
+  if (cooldownRetryPending) {
+    stampFailedNextRetryAt();
+    return;
+  }
   cooldownRetryPending = true;
   const delay = nextCooldownDelayMs();
   cooldownRetryLevel++;
@@ -428932,18 +429054,41 @@ function scheduleCooldownRetry(deps2) {
   );
   const fire = () => {
     cooldownRetryPending = false;
+    cooldownRetryFire = void 0;
+    cooldownRetryAt = 0;
+    if (cooldownRetryTimer) {
+      clearTimeout(cooldownRetryTimer);
+      cooldownRetryTimer = void 0;
+    }
     recentDeathTimestamps = [];
     void runEngineDeadRespawn(deps2).catch(() => {
     });
   };
+  cooldownRetryFire = fire;
+  cooldownRetryAt = Date.now() + delay;
+  stampFailedNextRetryAt();
   if (deps2.scheduleRetry) {
     deps2.scheduleRetry(fire, delay);
     return;
   }
-  const t2 = setTimeout(fire, delay);
-  if (typeof t2.unref === "function") t2.unref();
+  cooldownRetryTimer = setTimeout(fire, delay);
+  if (typeof cooldownRetryTimer.unref === "function") cooldownRetryTimer.unref();
+}
+function requestEngineRetryNow() {
+  if (!cooldownRetryPending || !cooldownRetryFire) return false;
+  if (deadRespawnInFlight) return false;
+  logForDebugging("[engine-lifecycle] manual retry-now requested \u2014 firing the parked cooldown retry immediately");
+  cooldownRetryFire();
+  return true;
 }
 async function runEngineDeadRespawn(deps2) {
+  if (isShellHostDead()) {
+    logForDebugging(
+      "[engine-lifecycle] host terminal is gone \u2014 refusing engine respawn, shutting down the orphaned shell"
+    );
+    teardownOwnedEngineSync("orphan-respawn-guard");
+    process.exit(129);
+  }
   if (deadRespawnInFlight) return false;
   deadRespawnInFlight = true;
   const now2 = deps2.now ?? Date.now;
@@ -428960,7 +429105,9 @@ async function runEngineDeadRespawn(deps2) {
       );
       setEngineRuntimeStatus({
         phase: "failed",
-        detail: `engine crashed ${recentDeathTimestamps.length} times in ${CRASH_LOOP_WINDOW_MS / 6e4} minutes \u2014 auto-restart paused; retrying automatically in ${retryInS}s (or run sema doctor)`
+        // detail 保留「retrying automatically in ~Ns」静态估计(headless bg 的 state.json 只见 detail);
+        // 交互 footer 另有 nextRetryAt 活倒计时(渲染时剥掉这里的静态估计,不双报)。
+        detail: `engine crashed ${recentDeathTimestamps.length} times in ${CRASH_LOOP_WINDOW_MS / 6e4} minutes \u2014 auto-restart paused; retrying automatically in ~${retryInS}s (or run sema doctor)`
       });
       scheduleCooldownRetry(deps2);
       return false;
@@ -428994,6 +429141,138 @@ async function runEngineDeadRespawn(deps2) {
     deadRespawnInFlight = false;
   }
 }
+function orphanWatchEligible() {
+  if (process.env.SEMA_CODE_SESSION_KIND) return false;
+  if (process.env.SEMA_JOB_DIR) return false;
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function isShellHostDead() {
+  if (!orphanWatchEligible()) return false;
+  return !process.stdout.writable || !process.stdin.readable;
+}
+function otherLiveSemaSessions() {
+  const dir = join118(getClaudeConfigHomeDir(), "sessions");
+  let files2;
+  try {
+    files2 = readdirSync7(dir);
+  } catch {
+    return 0;
+  }
+  let live = 0;
+  for (const f of files2) {
+    if (!/^\d+\.json$/.test(f)) continue;
+    const pid = Number.parseInt(f.slice(0, -5), 10);
+    if (pid === process.pid || !isProcessAlive(pid)) continue;
+    try {
+      const rec = JSON.parse(readFileSync25(join118(dir, f), "utf8"));
+      if (rec.kind === "daemon") continue;
+      if (rec.startedAt !== void 0 && processStartedAfter(pid, rec.startedAt + 15e3) === true) {
+        continue;
+      }
+      live++;
+    } catch {
+    }
+  }
+  return live;
+}
+function pickTeardownTarget() {
+  const inst = teardownGetInstance ? teardownGetInstance() : null;
+  if (inst && inst.ownedByThisShell && isProcessAlive(inst.pid)) {
+    return { pid: inst.pid, why: "owned" };
+  }
+  if (!localEngineActive) return null;
+  const anchor = readPortFile(getEnginePortFilePath());
+  if (!anchor || !isProcessAlive(anchor.pid)) return null;
+  if (anchor.startedAt && processStartedAfter(anchor.pid, anchor.startedAt + 15e3) === true) {
+    return null;
+  }
+  return { pid: anchor.pid, why: "anchor(last-session)" };
+}
+function cleanupAnchorForPid(pid) {
+  try {
+    const portPath = getEnginePortFilePath();
+    const current3 = readPortFile(portPath);
+    if (current3 && current3.pid === pid) {
+      unlinkSync6(portPath);
+      removeEngineTokenFile(getClaudeConfigHomeDir());
+    }
+  } catch {
+  }
+}
+function teardownOwnedEngineSync(reason) {
+  if (teardownDone) return;
+  teardownDone = true;
+  try {
+    const target = pickTeardownTarget();
+    if (!target) return;
+    const peers = otherLiveSemaSessions();
+    if (peers > 0) {
+      logForDebugging(
+        `[engine-lifecycle] exit teardown (${reason}): ${peers} other live sema session(s) still use the engine \u2014 leaving pid=${target.pid} running`
+      );
+      return;
+    }
+    logForDebugging(
+      `[engine-lifecycle] exit teardown (${reason}): reaping ${target.why} engine pid=${target.pid} (no other live sessions)`
+    );
+    markEngineExitExpected(target.pid);
+    try {
+      process.kill(target.pid, "SIGTERM");
+    } catch {
+    }
+    cleanupAnchorForPid(target.pid);
+  } catch (e) {
+    logForDebugging(`[engine-lifecycle] exit teardown (${reason}) error: ${String(e)}`);
+  }
+}
+function resetEngineExitTeardownForTests() {
+  teardownDone = false;
+}
+function setLocalEngineActiveForTests(v2) {
+  localEngineActive = v2;
+}
+function installEngineExitTeardown(getInstance2) {
+  teardownGetInstance = getInstance2;
+  if (teardownInstalled) return;
+  teardownInstalled = true;
+  process.once("exit", () => teardownOwnedEngineSync("process-exit"));
+  const onSignal = (sig, code2) => {
+    let fired2 = false;
+    process.on(sig, () => {
+      if (fired2) return;
+      fired2 = true;
+      teardownOwnedEngineSync(`signal:${sig}`);
+      setImmediate(() => {
+        try {
+          process.removeAllListeners(sig);
+          process.kill(process.pid, sig);
+        } catch {
+        }
+        setTimeout(() => {
+          process.exit(code2);
+        }, 200);
+      });
+    });
+  };
+  onSignal("SIGTERM", 143);
+  onSignal("SIGHUP", 129);
+  onSignal("SIGINT", 130);
+  if (orphanWatchEligible()) {
+    const pollMs = (() => {
+      const v2 = Number.parseInt(process.env.SEMA_ORPHAN_POLL_MS ?? "", 10);
+      return Number.isInteger(v2) && v2 >= 200 ? v2 : 15e3;
+    })();
+    const orphanTimer = setInterval(() => {
+      if (isShellHostDead()) {
+        clearInterval(orphanTimer);
+        logForDebugging("[engine-lifecycle] TTY revoked (terminal closed) \u2014 teardown + exit");
+        teardownOwnedEngineSync("tty-orphan");
+        process.exit(129);
+      }
+    }, pollMs);
+    if (typeof orphanTimer.unref === "function") orphanTimer.unref();
+  }
+}
 async function shutdownEngine(instance) {
   if (!instance) return;
   if (!instance.ownedByThisShell) {
@@ -429089,7 +429368,7 @@ async function waitForExit(pid, timeoutMs) {
   }
   return !isProcessAlive(pid);
 }
-var PORT_FILE_VERSION, HEALTH_POLL_INTERVAL_MS, HEALTH_POLL_MAX_ATTEMPTS, HEALTH_FETCH_TIMEOUT_MS, HEARTBEAT_INTERVAL_MS2, HEARTBEAT_MAX_MISSES, SHUTDOWN_GRACE_MS, SHUTDOWN_SECOND_TERM_GRACE_MS, LOCK_OPTS3, WORKFLOW_SIZE_GUIDELINE_VALUES, lastServiceAuthToken, lastInitFailureReason, lastInitFailureDetail, localEngineActive, DERIVED_PORT_PROBE_MAX, expectedExitPids, onOwnedEngineExitCb, deadRespawnInFlight, CRASH_LOOP_WINDOW_MS, CRASH_LOOP_MAX_DEATHS, recentDeathTimestamps, CRASH_LOOP_COOLDOWN_BASE_MS, CRASH_LOOP_COOLDOWN_CAP_MS, cooldownRetryPending, cooldownRetryLevel;
+var PORT_FILE_VERSION, HEALTH_POLL_INTERVAL_MS, HEALTH_POLL_MAX_ATTEMPTS, HEALTH_FETCH_TIMEOUT_MS, HEARTBEAT_INTERVAL_MS2, HEARTBEAT_MAX_MISSES, SHUTDOWN_GRACE_MS, SHUTDOWN_SECOND_TERM_GRACE_MS, LOCK_OPTS3, WORKFLOW_SIZE_GUIDELINE_VALUES, lastServiceAuthToken, lastInitFailureReason, lastInitFailureDetail, localEngineActive, DERIVED_PORT_PROBE_MAX, expectedExitPids, onOwnedEngineExitCb, deadRespawnInFlight, CRASH_LOOP_WINDOW_MS, CRASH_LOOP_MAX_DEATHS, recentDeathTimestamps, CRASH_LOOP_COOLDOWN_BASE_MS, CRASH_LOOP_COOLDOWN_CAP_MS, cooldownRetryPending, cooldownRetryLevel, cooldownRetryFire, cooldownRetryTimer, cooldownRetryAt, teardownGetInstance, teardownInstalled, teardownDone;
 var init_engineLifecycleManager = __esm({
   "build-src/src/sema/engineLifecycleManager.ts"() {
     init_state2();
@@ -429121,6 +429400,10 @@ var init_engineLifecycleManager = __esm({
     CRASH_LOOP_COOLDOWN_CAP_MS = 10 * 6e4;
     cooldownRetryPending = false;
     cooldownRetryLevel = 0;
+    cooldownRetryAt = 0;
+    teardownGetInstance = null;
+    teardownInstalled = false;
+    teardownDone = false;
   }
 });
 
@@ -430588,6 +430871,13 @@ ${sandboxHint}`;
   return `${API_ERROR_PREFIX}: ${detail} \xB7 the engine is unreachable \u2014 your message did not run; check the engine is up, then send it again.`;
 }
 async function* query(params) {
+  try {
+    if (getEngineRuntimeStatus().phase === "failed") {
+      const { requestEngineRetryNow: requestEngineRetryNow2 } = await Promise.resolve().then(() => (init_engineLifecycleManager(), engineLifecycleManager_exports));
+      requestEngineRetryNow2();
+    }
+  } catch {
+  }
   if (!clientExplicitlySet && !process.env.SEMA_LIVE_BASEURL && !process.env.SEMA_SCENARIO) {
     let why = "engine autostart did not run";
     try {
@@ -447701,7 +447991,7 @@ function Settings({
 var import_react112, import_jsx_runtime190;
 var init_cmd_config = __esm({
   "build-src/src/sema/overrides/cmd-config.tsx"() {
-    import_react112 = __toESM(require_react());
+    import_react112 = __toESM(require_react(), 1);
     init_useKeybinding();
     init_useExitOnCtrlCDWithKeybindings();
     init_useTerminalSize();
@@ -447712,7 +448002,7 @@ var init_cmd_config = __esm({
     init_Config();
     init_settings_usage();
     init_Stats();
-    import_jsx_runtime190 = __toESM(require_jsx_runtime());
+    import_jsx_runtime190 = __toESM(require_jsx_runtime(), 1);
   }
 });
 
@@ -476546,8 +476836,8 @@ var init_sema_brand = __esm({
           "Slash-command gating wired to the fleet capability handshake"
         ]
       },
-      productVersion: "1.0.2",
-      announcement: "sema 1.0.2 \u2014 background tasks survive your ssh session, engines stop fighting over ports, and long sessions stay lean"
+      productVersion: "1.0.3",
+      announcement: "sema 1.0.3 \u2014 honest --bg failures with a cause, daemon crash logs you can find, clean engine teardown on every exit path, and background agents you can wake again"
     };
   }
 });
@@ -604439,6 +604729,14 @@ function PromptInputFooterWithFleet(props) {
   useEngineAgentPanelBridge(store.setState);
   const upgrade2 = React151.useSyncExternalStore(subscribeUpgradeState, getUpgradeState);
   const engineRt = React151.useSyncExternalStore(subscribeEngineRuntimeStatus, getEngineRuntimeStatus);
+  const [nowTick, setNowTick] = React151.useState(() => Date.now());
+  const wantCountdown = engineRt.phase === "failed" && typeof engineRt.nextRetryAt === "number";
+  React151.useEffect(() => {
+    if (!wantCountdown) return;
+    const t2 = setInterval(() => setNowTick(Date.now()), 1e3);
+    return () => clearInterval(t2);
+  }, [wantCountdown]);
+  const retryInS = wantCountdown ? Math.max(0, Math.ceil(((engineRt.nextRetryAt ?? 0) - nowTick) / 1e3)) : null;
   return /* @__PURE__ */ (0, import_jsx_runtime450.jsxs)(import_jsx_runtime450.Fragment, { children: [
     /* @__PURE__ */ (0, import_jsx_runtime450.jsx)(PromptInputFooter_default, { ...props }),
     engineRt.phase === "down" ? /* @__PURE__ */ (0, import_jsx_runtime450.jsx)(ThemedText, { color: "warning", italic: true, children: " engine not responding \u2014 restarting\u2026" }) : engineRt.phase === "respawning" ? /* @__PURE__ */ (0, import_jsx_runtime450.jsxs)(ThemedText, { color: "warning", italic: true, children: [
@@ -604449,7 +604747,11 @@ function PromptInputFooterWithFleet(props) {
       ")\u2026"
     ] }) : engineRt.phase === "recovered" ? /* @__PURE__ */ (0, import_jsx_runtime450.jsx)(ThemedText, { dimColor: true, italic: true, children: " engine restarted \u2713 \u2014 press \u2191 then enter to resend the interrupted prompt" }) : engineRt.phase === "failed" ? /* @__PURE__ */ (0, import_jsx_runtime450.jsxs)(ThemedText, { color: "error", italic: true, children: [
       " engine down \u2014 ",
-      engineRt.detail ?? "automatic restart failed; run sema doctor or restart sema"
+      (() => {
+        const detail = engineRt.detail ?? "automatic restart failed; run sema doctor or restart sema";
+        return retryInS !== null ? detail.replace(/\s*[—;]?\s*retrying automatically in ~?\d+s\s*/, " ") : detail;
+      })(),
+      retryInS !== null ? ` \xB7 auto-retry in ${retryInS}s \xB7 send a message to retry now` : ""
     ] }) : null,
     upgrade2.phase === "ready" ? /* @__PURE__ */ (0, import_jsx_runtime450.jsx)(ThemedText, { dimColor: true, italic: true, children: " engine update ready \xB7 applies between turns" }) : upgrade2.phase === "applying" ? /* @__PURE__ */ (0, import_jsx_runtime450.jsx)(ThemedText, { dimColor: true, italic: true, children: " updating engine\u2026" }) : upgrade2.phase === "done" ? /* @__PURE__ */ (0, import_jsx_runtime450.jsxs)(ThemedText, { dimColor: true, italic: true, children: [
       " engine updated \u2713",
@@ -609591,10 +609893,12 @@ var init_autoDream = __esm({
 import * as fs14 from "fs/promises";
 import { homedir as homedir46 } from "os";
 import { join as join169 } from "path";
-function getCutoffDate() {
+function getCleanupPeriodDays() {
   const settings2 = getSettings_DEPRECATED() || {};
-  const cleanupPeriodDays = settings2.cleanupPeriodDays ?? DEFAULT_CLEANUP_PERIOD_DAYS;
-  const cleanupPeriodMs = cleanupPeriodDays * 24 * 60 * 60 * 1e3;
+  return settings2.cleanupPeriodDays ?? DEFAULT_CLEANUP_PERIOD_DAYS;
+}
+function getCutoffDate() {
+  const cleanupPeriodMs = getCleanupPeriodDays() * 24 * 60 * 60 * 1e3;
   return new Date(Date.now() - cleanupPeriodMs);
 }
 function addCleanupResults(a, b3) {
@@ -609679,7 +609983,7 @@ async function tryRmdir(dirPath, fsImpl) {
 }
 async function cleanupOldSessionFiles() {
   const cutoffDate = getCutoffDate();
-  const result = { messages: 0, errors: 0 };
+  let result = { messages: 0, errors: 0 };
   const projectsDir = getProjectsDir2();
   const fsImpl = getFsImplementation();
   let projectDirents;
@@ -609712,58 +610016,131 @@ async function cleanupOldSessionFiles() {
         }
       } else if (entry.isDirectory()) {
         const sessionDir = join169(projectDir2, entry.name);
-        const toolResultsDir = join169(sessionDir, TOOL_RESULTS_SUBDIR);
-        let toolDirs;
+        result = addCleanupResults(
+          result,
+          await cleanupToolResultsUnderSession(sessionDir, cutoffDate, fsImpl)
+        );
+        result = addCleanupResults(
+          result,
+          await cleanupSubagentsUnderSession(sessionDir, cutoffDate, fsImpl)
+        );
+        await tryRmdir(sessionDir, fsImpl);
+      }
+    }
+    await tryRmdir(projectDir2, fsImpl);
+  }
+  return result;
+}
+async function cleanupToolResultsUnderSession(sessionDir, cutoffDate, fsImpl) {
+  const result = { messages: 0, errors: 0 };
+  const toolResultsDir = join169(sessionDir, TOOL_RESULTS_SUBDIR);
+  let toolDirs;
+  try {
+    toolDirs = await fsImpl.readdir(toolResultsDir);
+  } catch {
+    return result;
+  }
+  for (const toolEntry of toolDirs) {
+    if (toolEntry.isFile()) {
+      try {
+        if (await unlinkIfOld(
+          join169(toolResultsDir, toolEntry.name),
+          cutoffDate,
+          fsImpl
+        )) {
+          result.messages++;
+        }
+      } catch {
+        result.errors++;
+      }
+    } else if (toolEntry.isDirectory()) {
+      const toolDirPath = join169(toolResultsDir, toolEntry.name);
+      let toolFiles;
+      try {
+        toolFiles = await fsImpl.readdir(toolDirPath);
+      } catch {
+        continue;
+      }
+      for (const tf of toolFiles) {
+        if (!tf.isFile()) continue;
         try {
-          toolDirs = await fsImpl.readdir(toolResultsDir);
+          if (await unlinkIfOld(join169(toolDirPath, tf.name), cutoffDate, fsImpl)) {
+            result.messages++;
+          }
         } catch {
-          await tryRmdir(sessionDir, fsImpl);
-          continue;
+          result.errors++;
+        }
+      }
+      await tryRmdir(toolDirPath, fsImpl);
+    }
+  }
+  await tryRmdir(toolResultsDir, fsImpl);
+  return result;
+}
+async function cleanupSubagentsUnderSession(sessionDir, cutoffDate, fsImpl) {
+  const result = { messages: 0, errors: 0 };
+  const subagentsDir = join169(sessionDir, "subagents");
+  let entries;
+  try {
+    entries = await fsImpl.readdir(subagentsDir);
+  } catch {
+    return result;
+  }
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      try {
+        if (await unlinkIfOld(join169(subagentsDir, entry.name), cutoffDate, fsImpl)) {
+          result.messages++;
         }
-        for (const toolEntry of toolDirs) {
-          if (toolEntry.isFile()) {
+      } catch {
+        result.errors++;
+      }
+    } else if (entry.isDirectory()) {
+      const subDir = join169(subagentsDir, entry.name);
+      let subEntries;
+      try {
+        subEntries = await fsImpl.readdir(subDir);
+      } catch {
+        continue;
+      }
+      for (const subEntry of subEntries) {
+        if (subEntry.isFile()) {
+          try {
+            if (await unlinkIfOld(
+              join169(subDir, subEntry.name),
+              cutoffDate,
+              fsImpl
+            )) {
+              result.messages++;
+            }
+          } catch {
+            result.errors++;
+          }
+        } else if (subEntry.isDirectory()) {
+          const runDir = join169(subDir, subEntry.name);
+          let runFiles;
+          try {
+            runFiles = await fsImpl.readdir(runDir);
+          } catch {
+            continue;
+          }
+          for (const rf of runFiles) {
+            if (!rf.isFile()) continue;
             try {
-              if (await unlinkIfOld(
-                join169(toolResultsDir, toolEntry.name),
-                cutoffDate,
-                fsImpl
-              )) {
+              if (await unlinkIfOld(join169(runDir, rf.name), cutoffDate, fsImpl)) {
                 result.messages++;
               }
             } catch {
               result.errors++;
             }
-          } else if (toolEntry.isDirectory()) {
-            const toolDirPath = join169(toolResultsDir, toolEntry.name);
-            let toolFiles;
-            try {
-              toolFiles = await fsImpl.readdir(toolDirPath);
-            } catch {
-              continue;
-            }
-            for (const tf of toolFiles) {
-              if (!tf.isFile()) continue;
-              try {
-                if (await unlinkIfOld(
-                  join169(toolDirPath, tf.name),
-                  cutoffDate,
-                  fsImpl
-                )) {
-                  result.messages++;
-                }
-              } catch {
-                result.errors++;
-              }
-            }
-            await tryRmdir(toolDirPath, fsImpl);
           }
+          await tryRmdir(runDir, fsImpl);
         }
-        await tryRmdir(toolResultsDir, fsImpl);
-        await tryRmdir(sessionDir, fsImpl);
       }
+      await tryRmdir(subDir, fsImpl);
     }
-    await tryRmdir(projectDir2, fsImpl);
   }
+  await tryRmdir(subagentsDir, fsImpl);
   return result;
 }
 async function cleanupSingleDirectory(dirPath, extension2, removeEmptyDir = true) {
@@ -609862,6 +610239,36 @@ async function cleanupOldSessionEnvDirs() {
   }
   return result;
 }
+async function cleanupOldJobDirs() {
+  const result = { messages: 0, errors: 0 };
+  const fsImpl = getFsImplementation();
+  const periodDays = JOB_GC_PERIOD_DAYS ?? getCleanupPeriodDays();
+  const cutoffDate = new Date(Date.now() - periodDays * 24 * 60 * 60 * 1e3);
+  let shorts;
+  try {
+    shorts = await listJobShorts();
+  } catch {
+    return result;
+  }
+  for (const short of shorts) {
+    try {
+      const state3 = await readJobState(short);
+      if (!state3) continue;
+      if (!isTerminalJobState(state3.state)) continue;
+      if (isJobWorkerAlive(state3)) continue;
+      const stats3 = await fsImpl.stat(getJobStatePath(short));
+      if (stats3.mtime >= cutoffDate) continue;
+      await fsImpl.rm(getJobDir(short), { recursive: true, force: true });
+      logForDebugging(
+        `job GC: removed terminal job dir ${short} (state=${state3.state}, mtime=${stats3.mtime.toISOString()} < ${cutoffDate.toISOString()})`
+      );
+      result.messages++;
+    } catch {
+      result.errors++;
+    }
+  }
+  return result;
+}
 async function cleanupOldDebugLogs() {
   const cutoffDate = getCutoffDate();
   const result = { messages: 0, errors: 0 };
@@ -610003,6 +610410,7 @@ async function cleanupOldMessageFilesInBackground() {
   await cleanupOldPlanFiles();
   await cleanupOldFileHistoryBackups();
   await cleanupOldSessionEnvDirs();
+  await cleanupOldJobDirs();
   await cleanupOldDebugLogs();
   await cleanupOldImageCaches();
   await cleanupOldPastes(getCutoffDate());
@@ -610014,10 +610422,11 @@ async function cleanupOldMessageFilesInBackground() {
     await cleanupNpmCacheForAnthropicPackages();
   }
 }
-var DEFAULT_CLEANUP_PERIOD_DAYS, ONE_DAY_MS2;
+var DEFAULT_CLEANUP_PERIOD_DAYS, JOB_GC_PERIOD_DAYS, ONE_DAY_MS2;
 var init_cleanup = __esm({
   "build-src/src/utils/cleanup.ts"() {
     init_analytics_index();
+    init_state2();
     init_cachePaths();
     init_debug();
     init_envUtils();
@@ -610033,6 +610442,7 @@ var init_cleanup = __esm({
     init_toolResultStorage();
     init_worktree();
     DEFAULT_CLEANUP_PERIOD_DAYS = 30;
+    JOB_GC_PERIOD_DAYS = null;
     ONE_DAY_MS2 = 24 * 60 * 60 * 1e3;
   }
 });
@@ -614645,8 +615055,8 @@ async function processResumedConversation(result, opts, context3) {
           const { bindSessionPersistencePaths: bindSessionPersistencePaths2, reconcileResumeJournal: reconcileResumeJournal2 } = await Promise.resolve().then(() => (init_sessionPersistenceWire(), sessionPersistenceWire_exports));
           bindSessionPersistencePaths2();
           if (process.env.SEMA_RECONCILE_DIAG) {
-            const { appendFileSync: appendFileSync7 } = await import("fs");
-            appendFileSync7(
+            const { appendFileSync: appendFileSync8 } = await import("fs");
+            appendFileSync8(
               process.env.SEMA_RECONCILE_DIAG,
               `[entry] sid=${sid} baseUrl=${process.env.SEMA_LIVE_BASEURL ?? "UNSET"}
 `
@@ -614656,8 +615066,8 @@ async function processResumedConversation(result, opts, context3) {
             const { cancelEngineRun: cancelEngineRun2 } = await Promise.resolve().then(() => (init_seamQuery(), seamQuery_exports));
             const r = await reconcileResumeJournal2(void 0, (taskId) => cancelEngineRun2(taskId));
             if (process.env.SEMA_RECONCILE_DIAG) {
-              const { appendFileSync: appendFileSync7 } = await import("fs");
-              appendFileSync7(
+              const { appendFileSync: appendFileSync8 } = await import("fs");
+              appendFileSync8(
                 process.env.SEMA_RECONCILE_DIAG,
                 `[done] ${r.decision.lastState} -> ${r.recovery}
 `
@@ -614669,8 +615079,8 @@ async function processResumedConversation(result, opts, context3) {
               );
             }
           } else if (process.env.SEMA_RECONCILE_DIAG) {
-            const { appendFileSync: appendFileSync7 } = await import("fs");
-            appendFileSync7(process.env.SEMA_RECONCILE_DIAG, `[skip] baseUrl UNSET
+            const { appendFileSync: appendFileSync8 } = await import("fs");
+            appendFileSync8(process.env.SEMA_RECONCILE_DIAG, `[skip] baseUrl UNSET
 `);
           }
         } catch (ePw) {
@@ -640016,6 +640426,10 @@ function toLiveRequest(req, capturedSessionId) {
     ;
     out6.forwardSubagentEvents = true;
   }
+  if (out6.retainSubagentSessions === void 0) {
+    ;
+    out6.retainSubagentSessions = true;
+  }
   if (typeof out6.scenario === "string" && SEMA_MOCK_SCENARIO_KEYS.has(out6.scenario)) {
     delete out6.scenario;
   }
@@ -640545,6 +640959,7 @@ __export(seamQueryEngine_exports, {
   makeAdapterQuery: () => makeAdapterQuery,
   makeCanUseTool: () => makeCanUseTool,
   makeHitlCanUseTool: () => makeHitlCanUseTool,
+  printTaskNotificationDedupKey: () => printTaskNotificationDedupKey,
   runStream: () => runStream,
   setQueryEngineClient: () => setQueryEngineClient
 });
@@ -640597,6 +641012,10 @@ function notifiedOnce(key) {
   printNotifiedKeys.add(key);
   return false;
 }
+function printTaskNotificationDedupKey(n2) {
+  const lane = n2.task_type === "external" ? "external:" : "";
+  return `${lane}${String(n2.task_id)}:${String(n2.status)}${n2.seq !== void 0 ? `:${String(n2.seq)}` : ""}`;
+}
 async function* ask(params) {
   const activeClient = await resolveClient();
   if (!clientExplicitlySet2 && !process.env.SEMA_LIVE_BASEURL && !process.env.SEMA_SCENARIO) {
@@ -640724,7 +641143,7 @@ async function* ask(params) {
       }
       if (t2 === "task_notification") {
         const n2 = msg.notification;
-        if (n2 && typeof n2.task_id === "string" && !notifiedOnce(`${n2.task_id}:${String(n2.status)}${n2.seq !== void 0 ? `:${String(n2.seq)}` : ""}`)) {
+        if (n2 && typeof n2.task_id === "string" && !notifiedOnce(printTaskNotificationDedupKey(n2))) {
           const s = n2.status;
           yield {
             type: "system",
@@ -664464,7 +664883,7 @@ Auth: unix socket -R \u2192 local proxy`, "info");
         pendingHookMessages
       }, renderAndRun);
     }
-  }).version("sema 1.0.2", "-v, --version", "Output the version number");
+  }).version("sema 1.0.3", "-v, --version", "Output the version number");
   program2.option("-w, --worktree [name]", "Create a new git worktree for this session (optionally specify a name)");
   program2.option("--tmux", "Create a tmux session for the worktree (requires --worktree). Uses iTerm2 native panes when available; use --tmux=classic for traditional tmux.");
   if (canUserConfigureAdvisor()) {
@@ -670061,7 +670480,7 @@ __export(main_exports2, {
   daemonMain: () => daemonMain
 });
 import { spawn as spawn16 } from "child_process";
-import { createWriteStream as createWriteStream5 } from "fs";
+import { appendFileSync as appendFileSync7, createWriteStream as createWriteStream5 } from "fs";
 import { chmod as chmod13, mkdir as mkdir50, readFile as readFile58, readdir as readdir33, rename as rename15, stat as stat54, unlink as unlink28 } from "fs/promises";
 import { createConnection as createConnection4, createServer as createServer9 } from "net";
 import { dirname as dirname88, join as join201 } from "path";
@@ -670103,6 +670522,31 @@ function parseOrigin(args) {
   const v2 = i >= 0 ? args[i + 1] : void 0;
   return v2 === "service" ? "service" : "transient";
 }
+function appendDaemonCrashLine(kind, err8) {
+  const detail = err8 instanceof Error ? err8.stack ?? err8.message : String(err8);
+  const line = `${(/* @__PURE__ */ new Date()).toISOString()} [daemon] FATAL ${kind} (pid ${process.pid}): ${detail}
+`;
+  try {
+    appendFileSync7(getDaemonLogPath(), line, { mode: 384 });
+  } catch {
+    try {
+      process.stderr.write(line);
+    } catch {
+    }
+  }
+}
+function installDaemonCrashHandlers() {
+  if (crashHandlersInstalled) return;
+  crashHandlersInstalled = true;
+  process.on("uncaughtException", (err8) => {
+    appendDaemonCrashLine("uncaughtException", err8);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    appendDaemonCrashLine("unhandledRejection", reason);
+    process.exit(1);
+  });
+}
 async function daemonMain(args) {
   const cdIdx = args.indexOf("--config-dir");
   if (cdIdx >= 0 && args[cdIdx + 1]) {
@@ -670111,8 +670555,20 @@ async function daemonMain(args) {
   const sub = args[0];
   switch (sub) {
     case "run": {
+      installDaemonCrashHandlers();
       const supervisor = new Supervisor(parseOrigin(args.slice(1)));
-      const started = await supervisor.run();
+      let started = false;
+      try {
+        started = await supervisor.run();
+      } catch (e) {
+        appendDaemonCrashLine("boot", e);
+        process.stderr.write(
+          `daemon failed to start \u2014 ${e instanceof Error ? e.message : String(e)} (details: ${getDaemonLogPath()})
+`
+        );
+        process.exitCode = 1;
+        return;
+      }
       if (!started) return;
       return;
     }
@@ -670182,7 +670638,7 @@ async function daemonMain(args) {
     }
   }
 }
-var IDLE_EXIT_MS, DISPATCH_SCAN_MS, DAEMON_LOG_ROTATE_BYTES, ADOPTED_SWEEP_MS, CRASH_RESPAWN_MAX, CRASH_BACKOFF_BASE_MS, CRASH_BACKOFF_CAP_MS, CRASH_STABLE_UPTIME_MS, CRASH_WINDOW_MS, CRASH_WINDOW_MAX, Supervisor;
+var IDLE_EXIT_MS, DISPATCH_SCAN_MS, DAEMON_LOG_ROTATE_BYTES, ADOPTED_SWEEP_MS, CRASH_RESPAWN_MAX, CRASH_BACKOFF_BASE_MS, CRASH_BACKOFF_CAP_MS, CRASH_STABLE_UPTIME_MS, CRASH_WINDOW_MS, CRASH_WINDOW_MAX, Supervisor, crashHandlersInstalled;
 var init_main4 = __esm({
   "build-src/src/daemon/main.ts"() {
     init_envUtils();
@@ -670293,17 +670749,25 @@ var init_main4 = __esm({
         }
         await chmod13(sockPath, 384).catch(() => {
         });
-        await writeDaemonInfo({
-          pid: process.pid,
-          procStart: this.procStart,
-          writtenAt: Date.now(),
-          socketPath: sockPath,
-          authToken: this.authToken,
-          origin: this.origin
-        });
-        this.logLine(`[daemon] supervisor up pid=${process.pid} origin=${this.origin}`);
-        await this.recoverJobs();
-        await mkdir50(join201(getDispatchDir(), "rejected"), { recursive: true, mode: 448 });
+        try {
+          await writeDaemonInfo({
+            pid: process.pid,
+            procStart: this.procStart,
+            writtenAt: Date.now(),
+            socketPath: sockPath,
+            authToken: this.authToken,
+            origin: this.origin
+          });
+          this.logLine(`[daemon] supervisor up pid=${process.pid} origin=${this.origin}`);
+          await this.recoverJobs();
+          await mkdir50(join201(getDispatchDir(), "rejected"), { recursive: true, mode: 448 });
+        } catch (e) {
+          this.server?.close();
+          this.server = null;
+          await unlink28(sockPath).catch(() => {
+          });
+          throw e;
+        }
         const scanTimer = setInterval(() => void this.scanDispatchDir(), DISPATCH_SCAN_MS);
         const idleTimer2 = setInterval(() => this.maybeIdleExit(), 3e4);
         const nonceTimer = setInterval(() => this.seenNonces.clear(), 6e4);
@@ -670958,6 +671422,7 @@ var init_main4 = __esm({
         }
       }
     };
+    crashHandlersInstalled = false;
   }
 });
 
@@ -671851,6 +672316,11 @@ function toWireSettings(eff, cfg) {
 async function launchReplProduction() {
   const { installSemaProcessBackstop: installSemaProcessBackstop2 } = await Promise.resolve().then(() => (init_processBackstop(), processBackstop_exports));
   installSemaProcessBackstop2();
+  try {
+    const { installEngineExitTeardown: installEngineExitTeardown2 } = await Promise.resolve().then(() => (init_engineLifecycleManager(), engineLifecycleManager_exports));
+    installEngineExitTeardown2(() => null);
+  } catch {
+  }
   const { applyFullscreenDefault: applyFullscreenDefault2 } = await Promise.resolve().then(() => (init_fullscreenDefault(), fullscreenDefault_exports));
   const fullscreenAction = applyFullscreenDefault2();
   if (process.env.SEMA_DEBUG) {
@@ -672022,9 +672492,10 @@ async function launchReplProduction() {
   }
   if (!process.env.SEMA_LIVE_BASEURL && process.env.SEMA_TOC_ENGINE !== "0") {
     try {
-      const { initEngineLifecycle: initEngineLifecycle2, startHealthCheckLoop: startHealthCheckLoop2, getServiceAuthToken: getServiceAuthToken2, respawnOnConfigDrift: respawnOnConfigDrift2, runEngineDeadRespawn: runEngineDeadRespawn2, setOnOwnedEngineExit: setOnOwnedEngineExit2 } = await Promise.resolve().then(() => (init_engineLifecycleManager(), engineLifecycleManager_exports));
+      const { initEngineLifecycle: initEngineLifecycle2, startHealthCheckLoop: startHealthCheckLoop2, getServiceAuthToken: getServiceAuthToken2, respawnOnConfigDrift: respawnOnConfigDrift2, runEngineDeadRespawn: runEngineDeadRespawn2, setOnOwnedEngineExit: setOnOwnedEngineExit2, installEngineExitTeardown: installEngineExitTeardown2 } = await Promise.resolve().then(() => (init_engineLifecycleManager(), engineLifecycleManager_exports));
       let engineHealthLoop = null;
       let currentEngineInstance = null;
+      installEngineExitTeardown2(() => currentEngineInstance);
       const doEngineRespawn = async (label) => {
         console.error(`[sema] local engine ${label} \u2014 restarting (stop-then-start serialize), session preserved`);
         try {