@threadbase-sh/streamer 1.41.2 → 1.43.0

package/dist/index.cjs

@@ -1201,7 +1201,10 @@ var CodexPtyRunner = class {
     const projectName = options.projectName ?? (0, import_path5.basename)(options.projectPath);
     const proc = nodePty.spawn(
       resolveCodexExe(),
-      ["resume", sessionId, "--cd", options.projectPath, "--no-alt-screen"],
+      // `sessionId` stays the runner's map key — only argv carries the
+      // provider-side id, so a resumed Codex session keeps the placeholder id
+      // its client already navigated to.
+      ["resume", options.resumeId ?? sessionId, "--cd", options.projectPath, "--no-alt-screen"],
       {
         name: "xterm-256color",
         cols: PTY_COLS,
@@ -4140,6 +4143,86 @@ function redactValue(value) {
   return value;
 }
 
+// src/services/sessions/resumeIdentity.ts
+function resumeIdForRow(row) {
+  if (row.provider !== CODEX_CLI_PROVIDER) return row.session_id;
+  return row.bound_conversation_id;
+}
+
+// src/services/sessions/rehydrateSessions.ts
+var REHYDRATE_MAX = 25;
+var REHYDRATE_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
+var AGENT_EXIT_SOURCES = /* @__PURE__ */ new Set(["exit", "process-exit"]);
+function rehydrateSkipReason(row, opts) {
+  if (resumeIdForRow(row) == null) return "codex_unbound";
+  if (!opts.projectExists(row.project_path)) return "project_missing";
+  if (opts.now - row.status_updated_at > REHYDRATE_WINDOW_MS) return "too_old";
+  if (AGENT_EXIT_SOURCES.has(row.status_source) && row.failure_reason == null) {
+    return "agent_exited";
+  }
+  return null;
+}
+function rowToStubSession(row) {
+  return {
+    id: row.session_id,
+    provider: row.provider,
+    projectPath: row.project_path,
+    projectName: row.project_name,
+    branch: row.branch,
+    // No PTY exists for a stub, so this is the only truthful status.
+    status: "idle",
+    startedAt: new Date(row.started_at),
+    completedAt: row.completed_at != null ? new Date(row.completed_at) : null,
+    promptCount: row.prompt_count,
+    lastOutput: "",
+    rehydrated: true,
+    ...row.session_name != null && { sessionName: row.session_name },
+    ...row.project_id != null && { projectId: row.project_id },
+    ...row.bound_conversation_id != null && { boundConversationId: row.bound_conversation_id },
+    ...row.resumed_from_conversation_id != null && {
+      resumedFromConversationId: row.resumed_from_conversation_id
+    },
+    ...row.failure_reason != null && { failureReason: row.failure_reason },
+    ...row.last_activity_at != null && { lastActivityAt: new Date(row.last_activity_at) },
+    // Only `shutdown` crosses over. It is the one registry source that is also a
+    // wire StatusSource *and* that genuinely describes the `idle` above — the
+    // streamer stopped this session. A crashed row still says `transition` over
+    // a `running` status, and copying that here would attach observed-confidence
+    // provenance to a status we derived at boot, so leave it unset instead.
+    ...row.status_source === "shutdown" && {
+      statusSource: "shutdown",
+      statusUpdatedAt: new Date(row.status_updated_at),
+      // `status` above had to flatten to `idle`, which erases whether the agent
+      // was mid-answer when we stopped it. Carried separately so a client can
+      // say "interrupted mid-response" without a novel SessionStatus value.
+      // Gated on the same `shutdown` source: a crashed row's `running` is a
+      // frozen value nobody confirmed, not an observation.
+      ...(row.status === "running" || row.status === "waiting_input") && {
+        interruptedStatus: row.status
+      }
+    }
+  };
+}
+
+// src/utils/bootToken.ts
+var import_node_fs3 = require("fs");
+var import_node_os = __toESM(require("os"), 1);
+var cached2;
+function currentBootToken() {
+  if (cached2 === void 0) cached2 = computeBootToken();
+  return cached2;
+}
+function computeBootToken() {
+  if (process.platform === "linux") {
+    try {
+      const bootId = (0, import_node_fs3.readFileSync)("/proc/sys/kernel/random/boot_id", "utf8").trim();
+      if (bootId) return bootId;
+    } catch {
+    }
+  }
+  return String(Math.round((Date.now() - import_node_os.default.uptime() * 1e3) / 1e4));
+}
+
 // src/api/routes/diagnostics.routes.ts
 function providerCheck(name, resolve2) {
   try {
@@ -4219,6 +4302,49 @@ var createDiagnosticsRoutes = (deps) => {
     );
     return c.json(redactValue(buildReport(checks)));
   });
+  app.get("/sessions", (c) => {
+    const repo = deps.managedSessionsRepo();
+    if (!repo) {
+      return c.json(
+        { error: "Session registry is unavailable", code: "REGISTRY_UNAVAILABLE" },
+        503
+      );
+    }
+    const rows = repo.listAll();
+    const verdicts = deps.sessionVerdicts();
+    const bootToken = currentBootToken();
+    const now = Date.now();
+    const sessions = rows.map((row) => {
+      const verdict = verdicts.get(row.session_id);
+      const skip = rehydrateSkipReason(row, { now, projectExists: import_fs7.existsSync });
+      return {
+        sessionId: row.session_id,
+        provider: row.provider,
+        status: row.status,
+        statusSource: row.status_source,
+        statusUpdatedAt: new Date(row.status_updated_at).toISOString(),
+        // Whether the recorded pid is probeable at all this boot, not whether
+        // it is alive — a mismatch means the question was never asked.
+        //
+        // NOT named for the boot token it derives from: `redactValue`'s
+        // SECRET_KEY_RE matches any key containing "token", so `bootTokenMatches`
+        // was scrubbed to the string "[redacted]" and the field shipped useless.
+        // The regex is deliberately over-broad for a payload meant to be pasted
+        // into bug reports, so the field moved rather than the guard.
+        recordedThisBoot: row.boot_token != null && row.boot_token === bootToken,
+        // Absent when this boot never classified the row: a clean restart
+        // stamps completed_at on the way out, which takes it out of the probe
+        // set entirely. That absence is itself the answer.
+        lifecycle: verdict?.lifecycle ?? null,
+        lifecycleReason: verdict?.reason ?? null,
+        rehydrated: skip == null,
+        rehydrateSkipReason: skip,
+        projectExists: (0, import_fs7.existsSync)(row.project_path),
+        projectPath: redactPath(row.project_path)
+      };
+    });
+    return c.json(redactValue({ generatedAt: (/* @__PURE__ */ new Date()).toISOString(), sessions }));
+  });
   return app;
 };
 
@@ -4234,16 +4360,16 @@ var createHealthRoutes = (deps) => {
 };
 
 // src/api/routes/logs.routes.ts
-var import_node_fs3 = require("fs");
+var import_node_fs4 = require("fs");
 var import_node_path5 = require("path");
 var import_hono10 = require("hono");
 
 // src/lifecycle/constants.ts
-var import_node_os = require("os");
+var import_node_os2 = require("os");
 var import_node_path4 = require("path");
 var TASK_NAME = process.env.THREADBASE_TASK_NAME ?? "Threadbase";
 function installDir() {
-  return process.env.THREADBASE_INSTALL_DIR ?? (0, import_node_path4.join)((0, import_node_os.homedir)(), ".threadbase");
+  return process.env.THREADBASE_INSTALL_DIR ?? (0, import_node_path4.join)((0, import_node_os2.homedir)(), ".threadbase");
 }
 
 // src/api/routes/logs.routes.ts
@@ -4254,22 +4380,22 @@ function resolveLogPath(source) {
 function pickDefaultSource() {
   for (const source of ["stdout", "stderr", "dev"]) {
     const p = resolveLogPath(source);
-    if ((0, import_node_fs3.existsSync)(p) && (0, import_node_fs3.statSync)(p).size > 0) return source;
+    if ((0, import_node_fs4.existsSync)(p) && (0, import_node_fs4.statSync)(p).size > 0) return source;
   }
   return "stdout";
 }
 function readLogLines(filePath, sinceOffset, limit) {
-  if (!(0, import_node_fs3.existsSync)(filePath)) {
+  if (!(0, import_node_fs4.existsSync)(filePath)) {
     return { lines: [], offset: 0, total: 0 };
   }
-  const fd = (0, import_node_fs3.openSync)(filePath, "r");
+  const fd = (0, import_node_fs4.openSync)(filePath, "r");
   try {
-    const { size } = (0, import_node_fs3.fstatSync)(fd);
+    const { size } = (0, import_node_fs4.fstatSync)(fd);
     if (size === 0) return { lines: [], offset: 0, total: 0 };
     const maxBytes = Math.min(size, 2 * 1024 * 1024);
     const start = size - maxBytes;
     const buf = Buffer.alloc(maxBytes);
-    (0, import_node_fs3.readSync)(fd, buf, 0, maxBytes, start);
+    (0, import_node_fs4.readSync)(fd, buf, 0, maxBytes, start);
     let text = buf.toString("utf8");
     if (start > 0) {
       const firstNl = text.indexOf("\n");
@@ -4290,7 +4416,7 @@ function readLogLines(filePath, sinceOffset, limit) {
     }
     return { lines, offset: newOffset, total: allLines.length };
   } finally {
-    (0, import_node_fs3.closeSync)(fd);
+    (0, import_node_fs4.closeSync)(fd);
   }
 }
 function createLogsRoutes() {
@@ -4302,7 +4428,7 @@ function createLogsRoutes() {
       const logPath = resolveLogPath(source);
       const sinceOffset = parseInt(c.req.query("since") || "0", 10);
       const limit = Math.min(parseInt(c.req.query("limit") || "100", 10) || 100, 1e3);
-      if (!(0, import_node_fs3.existsSync)(logPath)) {
+      if (!(0, import_node_fs4.existsSync)(logPath)) {
         return c.json({
           logs: [],
           message: `No log file found for source=${source}`,
@@ -4312,7 +4438,7 @@ function createLogsRoutes() {
         });
       }
       const { lines, offset, total } = readLogLines(logPath, sinceOffset, limit);
-      const stats = (0, import_node_fs3.statSync)(logPath);
+      const stats = (0, import_node_fs4.statSync)(logPath);
       return c.json({
         logs: lines,
         offset,
@@ -4339,10 +4465,10 @@ function createLogsRoutes() {
     try {
       const sources = ["stdout", "stderr", "dev"].map((source) => {
         const logPath = resolveLogPath(source);
-        if (!(0, import_node_fs3.existsSync)(logPath)) {
+        if (!(0, import_node_fs4.existsSync)(logPath)) {
           return { source, exists: false, total: 0, fileSize: 0 };
         }
-        const stats = (0, import_node_fs3.statSync)(logPath);
+        const stats = (0, import_node_fs4.statSync)(logPath);
         return {
           source,
           exists: true,
@@ -4369,8 +4495,8 @@ var import_hono11 = require("hono");
 var import_os6 = require("os");
 
 // src/config/update-config.ts
-var import_node_fs4 = require("fs");
-var import_node_os2 = require("os");
+var import_node_fs5 = require("fs");
+var import_node_os3 = require("os");
 var import_node_path6 = require("path");
 var import_yaml = require("yaml");
 
@@ -4387,12 +4513,12 @@ var UpdateConfigSchema = import_zod3.z.object({
 }).strict();
 
 // src/config/update-config.ts
-var DEFAULT_CONFIG_PATH = (0, import_node_path6.join)((0, import_node_os2.homedir)(), ".threadbase", "update.yaml");
+var DEFAULT_CONFIG_PATH = (0, import_node_path6.join)((0, import_node_os3.homedir)(), ".threadbase", "update.yaml");
 function loadUpdateConfig(opts = {}) {
   const path = opts.path ?? DEFAULT_CONFIG_PATH;
   let raw;
   try {
-    raw = (0, import_node_fs4.readFileSync)(path, "utf-8");
+    raw = (0, import_node_fs5.readFileSync)(path, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw err;
@@ -5284,8 +5410,8 @@ function isAgentLine(line, entrypoints = DEFAULT_AGENT_ENTRYPOINTS) {
 function isAgentFile(filePath, entrypoints = DEFAULT_AGENT_ENTRYPOINTS) {
   if (entrypoints.size === 0) return false;
   const key = cacheKey(filePath, entrypoints);
-  const cached2 = fileDecisionCache.get(key);
-  if (cached2 !== void 0) return cached2;
+  const cached3 = fileDecisionCache.get(key);
+  if (cached3 !== void 0) return cached3;
   let fd;
   try {
     fd = (0, import_fs9.openSync)(filePath, "r");
@@ -5941,9 +6067,9 @@ var ConversationCache = class _ConversationCache {
   classifyAgentFile(filePath, mtimeMs, fileSize) {
     if (this.agentEntrypoints.size === 0) return false;
     const entrypointsKey = this.agentEntrypointsKey();
-    const cached2 = this.stmts.getFileMetadata.get(filePath);
-    if (cached2 && cached2.mtime_ms === mtimeMs && cached2.file_size === fileSize && cached2.agent_entrypoints_key === entrypointsKey) {
-      return cached2.is_agent === 1;
+    const cached3 = this.stmts.getFileMetadata.get(filePath);
+    if (cached3 && cached3.mtime_ms === mtimeMs && cached3.file_size === fileSize && cached3.agent_entrypoints_key === entrypointsKey) {
+      return cached3.is_agent === 1;
     }
     const isAgent = isAgentFile(filePath, this.agentEntrypoints);
     this.stmts.upsertFileMetadata.run({
@@ -6648,11 +6774,17 @@ var ConversationsRepository = class {
 };
 
 // src/db/repositories/managed-sessions.repository.ts
+var PROBE_SET_MAX = 200;
+var DIAGNOSTICS_MAX = 200;
+var TERMINAL_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
 var ManagedSessionsRepository = class {
   upsertStmt;
   updateStatusStmt;
+  bindStmt;
   getStmt;
   listNonTerminalStmt;
+  listAllStmt;
+  pruneTerminalStmt;
   listRecoverableStmt;
   deleteStmt;
   constructor(db) {
@@ -6662,13 +6794,13 @@ var ManagedSessionsRepository = class {
         status, status_source, status_updated_at, started_at, completed_at,
         last_activity_at, prompt_count, session_name, project_id,
         bound_conversation_id, resumed_from_conversation_id, failure_reason,
-        streamer_instance_id
+        streamer_instance_id, boot_token
       ) VALUES (
         @session_id, @provider, @pid, @cmdline, @project_path, @project_name, @branch,
         @status, @status_source, @status_updated_at, @started_at, @completed_at,
         @last_activity_at, @prompt_count, @session_name, @project_id,
         @bound_conversation_id, @resumed_from_conversation_id, @failure_reason,
-        @streamer_instance_id
+        @streamer_instance_id, @boot_token
       )
       ON CONFLICT(session_id) DO UPDATE SET
         pid = excluded.pid,
@@ -6687,7 +6819,8 @@ var ManagedSessionsRepository = class {
         bound_conversation_id = excluded.bound_conversation_id,
         resumed_from_conversation_id = excluded.resumed_from_conversation_id,
         failure_reason = excluded.failure_reason,
-        streamer_instance_id = excluded.streamer_instance_id
+        streamer_instance_id = excluded.streamer_instance_id,
+        boot_token = excluded.boot_token
     `);
     this.updateStatusStmt = db.prepare(`
       UPDATE managed_sessions
@@ -6701,11 +6834,27 @@ var ManagedSessionsRepository = class {
              session_name = COALESCE(@session_name, session_name)
        WHERE session_id = @session_id
     `);
+    this.bindStmt = db.prepare(`
+      UPDATE managed_sessions
+         SET bound_conversation_id = @bound_conversation_id
+       WHERE session_id = @session_id
+    `);
     this.getStmt = db.prepare("SELECT * FROM managed_sessions WHERE session_id = ?");
     this.listNonTerminalStmt = db.prepare(`
       SELECT * FROM managed_sessions
        WHERE completed_at IS NULL
        ORDER BY started_at ASC
+       LIMIT @limit
+    `);
+    this.listAllStmt = db.prepare(`
+      SELECT * FROM managed_sessions
+       ORDER BY status_updated_at DESC
+       LIMIT @limit
+    `);
+    this.pruneTerminalStmt = db.prepare(`
+      DELETE FROM managed_sessions
+       WHERE completed_at IS NOT NULL
+         AND completed_at < @before
     `);
     this.listRecoverableStmt = db.prepare(`
       SELECT * FROM managed_sessions
@@ -6738,7 +6887,10 @@ var ManagedSessionsRepository = class {
       bound_conversation_id: session.boundConversationId ?? null,
       resumed_from_conversation_id: session.resumedFromConversationId ?? null,
       failure_reason: session.failureReason ?? null,
-      streamer_instance_id: streamerInstanceId
+      streamer_instance_id: streamerInstanceId,
+      // Recorded, never backfilled: the pid above is only probeable while this
+      // token still matches the running machine.
+      boot_token: currentBootToken()
     });
   }
   /**
@@ -6759,12 +6911,48 @@ var ManagedSessionsRepository = class {
       session_name: fields.sessionName ?? null
     });
   }
+  /**
+   * Persist the Codex rollout id discovered after spawn.
+   *
+   * Its own statement rather than a `recordSpawn` re-run: the binding arrives
+   * while the session is live, and re-upserting would also rewrite `cmdline`
+   * with an id that is *not* in a fresh Codex process's argv, turning the
+   * reconciler's identity check into a false `orphaned`. Without this write the
+   * binding lives only in memory and dies with the streamer — which is the
+   * whole reason a restarted Codex session could not be resumed (G6).
+   */
+  recordBinding(sessionId, boundConversationId) {
+    this.bindStmt.run({
+      session_id: sessionId,
+      bound_conversation_id: boundConversationId
+    });
+  }
   get(sessionId) {
     return this.getStmt.get(sessionId) ?? null;
   }
-  /** Rows with no recorded completion — the reconciler's probe set. */
-  listNonTerminal() {
-    return this.listNonTerminalStmt.all();
+  /**
+   * Rows with no recorded completion — the reconciler's probe set.
+   *
+   * Capped. Callers must compare the result length against the limit and say so
+   * when it clips: a silently truncated probe set reads as "we checked
+   * everything" when it did not.
+   */
+  listNonTerminal(limit = PROBE_SET_MAX) {
+    return this.listNonTerminalStmt.all({ limit });
+  }
+  /** Every row, most recently touched first, for the diagnostics surface. */
+  listAll(limit = DIAGNOSTICS_MAX) {
+    return this.listAllStmt.all({ limit });
+  }
+  /**
+   * Delete terminal rows older than `olderThanMs`, returning how many went.
+   *
+   * Only rows carrying a `completed_at` are eligible, so nothing the reconciler
+   * or rehydrator might still want is reachable from here — a row without one
+   * is by definition unfinished business, however old it looks.
+   */
+  pruneTerminal(olderThanMs = TERMINAL_RETENTION_MS) {
+    return this.pruneTerminalStmt.run({ before: Date.now() - olderThanMs }).changes;
   }
   /**
    * Rows a restart could bring back: still open, or closed by our own shutdown,
@@ -8630,6 +8818,34 @@ function paginate(results, offset, limit) {
   };
 }
 
+// src/services/sessions/autoResumeOnBoot.ts
+var AUTO_RESUME_WINDOW_MS = 15 * 60 * 1e3;
+var AUTO_RESUME_MAX = 5;
+var AUTO_RESUME_CONCURRENCY = 2;
+var AUTO_RESUME_STAGGER_MS = 500;
+function autoResumeSkipReason(row, opts) {
+  if (row.status_source !== "shutdown") return "not_shutdown";
+  if (row.status !== "running" && row.status !== "waiting_input") return "not_interrupted";
+  if (opts.now - row.status_updated_at > AUTO_RESUME_WINDOW_MS) return "too_old";
+  if (!opts.projectExists(row.project_path)) return "project_missing";
+  if (resumeIdForRow(row) == null) return "resume_identity_missing";
+  return null;
+}
+function planAutoResume(rows, opts) {
+  const eligible = [];
+  const skipped = [];
+  for (const row of rows) {
+    const reason = autoResumeSkipReason(row, opts);
+    if (reason) skipped.push({ row, reason });
+    else eligible.push(row);
+  }
+  return {
+    attempts: eligible.slice(0, AUTO_RESUME_MAX),
+    skipped,
+    overflow: eligible.slice(AUTO_RESUME_MAX)
+  };
+}
+
 // src/services/sessions/conversationBusy.ts
 var import_fs18 = require("fs");
 var RESUME_BUSY_WINDOW_MS = 12e4;
@@ -8733,8 +8949,14 @@ function readIdempotencyKey(body) {
 }
 
 // src/services/sessions/reconcileSessions.ts
-async function classifySession(row, probe, currentInstanceId) {
+var PRE_BOOT_REASON = "recorded before this machine boot";
+async function classifySession(row, probe, currentInstanceId, currentBootToken2 = null) {
   const { session_id: sessionId } = row;
+  const resumable = (reason) => resumeIdForRow(row) == null ? {
+    sessionId,
+    lifecycle: "failed",
+    reason: "Codex session ended before its rollout id was known"
+  } : { sessionId, lifecycle: "resumable", reason };
   if (row.completed_at != null) {
     const clean = probe.endedCleanly?.(row) ?? row.failure_reason == null;
     return {
@@ -8744,18 +8966,19 @@ async function classifySession(row, probe, currentInstanceId) {
     };
   }
   if (row.pid == null) {
-    return { sessionId, lifecycle: "resumable", reason: "no pid recorded" };
+    return resumable("no pid recorded");
+  }
+  if (currentBootToken2 != null && row.boot_token !== currentBootToken2) {
+    return resumable(PRE_BOOT_REASON);
   }
   if (!probe.isPidAlive(row.pid)) {
-    const clean = probe.endedCleanly?.(row) ?? false;
-    if (clean) {
+    if (probe.endedCleanly?.(row)) {
       return { sessionId, lifecycle: "completed", reason: "process gone, history ended cleanly" };
     }
-    return {
-      sessionId,
-      lifecycle: "resumable",
-      reason: "process gone, resumable from provider history"
-    };
+    if (row.failure_reason != null) {
+      return { sessionId, lifecycle: "failed", reason: "process gone, failure recorded" };
+    }
+    return resumable("process gone, resumable from provider history");
   }
   const args = await probe.getProcessArgs(row.pid);
   const token = row.cmdline;
@@ -8773,52 +8996,10 @@ async function classifySession(row, probe, currentInstanceId) {
     reason: sameRun ? "owned by this run" : "survived a previous streamer run"
   };
 }
-async function reconcileSessions(rows, probe, currentInstanceId) {
-  return Promise.all(rows.map((row) => classifySession(row, probe, currentInstanceId)));
-}
-
-// src/services/sessions/rehydrateSessions.ts
-var REHYDRATE_MAX = 25;
-var REHYDRATE_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
-var AGENT_EXIT_SOURCES = /* @__PURE__ */ new Set(["exit", "process-exit"]);
-function shouldRehydrate(row, opts) {
-  if (!opts.projectExists(row.project_path)) return false;
-  if (opts.now - row.status_updated_at > REHYDRATE_WINDOW_MS) return false;
-  if (AGENT_EXIT_SOURCES.has(row.status_source) && row.failure_reason == null) return false;
-  return true;
-}
-function rowToStubSession(row) {
-  return {
-    id: row.session_id,
-    provider: row.provider,
-    projectPath: row.project_path,
-    projectName: row.project_name,
-    branch: row.branch,
-    // No PTY exists for a stub, so this is the only truthful status.
-    status: "idle",
-    startedAt: new Date(row.started_at),
-    completedAt: row.completed_at != null ? new Date(row.completed_at) : null,
-    promptCount: row.prompt_count,
-    lastOutput: "",
-    rehydrated: true,
-    ...row.session_name != null && { sessionName: row.session_name },
-    ...row.project_id != null && { projectId: row.project_id },
-    ...row.bound_conversation_id != null && { boundConversationId: row.bound_conversation_id },
-    ...row.resumed_from_conversation_id != null && {
-      resumedFromConversationId: row.resumed_from_conversation_id
-    },
-    ...row.failure_reason != null && { failureReason: row.failure_reason },
-    ...row.last_activity_at != null && { lastActivityAt: new Date(row.last_activity_at) },
-    // Only `shutdown` crosses over. It is the one registry source that is also a
-    // wire StatusSource *and* that genuinely describes the `idle` above — the
-    // streamer stopped this session. A crashed row still says `transition` over
-    // a `running` status, and copying that here would attach observed-confidence
-    // provenance to a status we derived at boot, so leave it unset instead.
-    ...row.status_source === "shutdown" && {
-      statusSource: "shutdown",
-      statusUpdatedAt: new Date(row.status_updated_at)
-    }
-  };
+async function reconcileSessions(rows, probe, currentInstanceId, currentBootToken2 = null) {
+  return Promise.all(
+    rows.map((row) => classifySession(row, probe, currentInstanceId, currentBootToken2))
+  );
 }
 
 // src/types.ts
@@ -9009,7 +9190,8 @@ function managedToResponse(s, ptyAttached) {
     ...s.resumedFromConversationId != null && {
       resumedFromConversationId: s.resumedFromConversationId
     },
-    ...s.boundConversationId != null && { boundConversationId: s.boundConversationId }
+    ...s.boundConversationId != null && { boundConversationId: s.boundConversationId },
+    ...s.interruptedStatus != null && { interruptedStatus: s.interruptedStatus }
   };
 }
 function discoveredToResponse(d, conversationId) {
@@ -9505,6 +9687,7 @@ var StreamerServer = class {
   disableDb = false;
   // Skip the startup warm-up scan (test hook; see ServerConfig.skipStartupWarmup).
   skipStartupWarmup;
+  autoResumeOnBoot;
   browseRoot = null;
   publicUrl = null;
   browserCors;
@@ -9554,7 +9737,7 @@ var StreamerServer = class {
   idempotency = new IdempotencyStore();
   // sessionId → lifecycle verdict from boot reconciliation. Only holds sessions
   // this run did NOT spawn; live ones derive their lifecycle from ptyAttached.
-  sessionLifecycles = /* @__PURE__ */ new Map();
+  sessionVerdicts = /* @__PURE__ */ new Map();
   // Periodic sweep that releases PTYs no agent is using. Null until listen().
   idleReaperTimer = null;
   // Map of clientId → WS socket (populated by the "register" WS handshake)
@@ -9621,6 +9804,7 @@ var StreamerServer = class {
     this.verbose = config.verbose ?? false;
     this.disableDb = config.disableDb ?? false;
     this.skipStartupWarmup = config.skipStartupWarmup ?? false;
+    this.autoResumeOnBoot = config.autoResumeOnBoot ?? false;
     this.scannerPersistenceDisabled = config.scannerPersistent === false;
     this.scanProfiles = config.scanProfiles;
     this.codexRoots = config.codexRoots ?? [(0, import_path18.join)((0, import_os10.homedir)(), ".codex", "sessions")];
@@ -9927,6 +10111,8 @@ var StreamerServer = class {
       sessionsRepo: () => this.sessionsRepo,
       cacheMetadataRepo: () => this.cacheMetadataRepo,
       runtimeStore: () => this.runtimeStore,
+      managedSessionsRepo: () => this.managedSessionsRepo,
+      sessionVerdicts: () => this.sessionVerdicts,
       ptyAttachedIds: () => this.ptyAttachedIds(),
       handleListSessions: (url, res) => this.handleListSessions(url, res),
       handleSessionsCount: (res) => this.handleSessionsCount(res),
@@ -10099,16 +10285,19 @@ var StreamerServer = class {
   broadcastOrUnicastSessionList(req) {
     const clientId = req.headers["x-client-id"];
     const ws = typeof clientId === "string" ? this.clientIdToWs.get(clientId) : void 0;
-    const payload = {
-      type: "session_list",
-      sessions: this.withReconciledLifecycle(this.sessionStore.list(this.ptyAttachedIds()))
-    };
+    const payload = this.sessionListPayload();
     if (ws) {
       this.wsHub.unicast(ws, payload);
     } else {
       this.wsHub.broadcast(payload);
     }
   }
+  sessionListPayload() {
+    return {
+      type: "session_list",
+      sessions: this.withReconciledLifecycle(this.sessionStore.list(this.ptyAttachedIds()))
+    };
+  }
   /**
    * Overlay boot-reconciliation verdicts onto session responses.
    *
@@ -10124,12 +10313,12 @@ var StreamerServer = class {
    * it.
    */
   withReconciledLifecycle(sessions) {
-    if (this.sessionLifecycles.size === 0) return sessions;
+    if (this.sessionVerdicts.size === 0) return sessions;
     return sessions.map((s) => {
       if (s.ptyAttached) return s;
-      const verdict = this.sessionLifecycles.get(s.id);
+      const verdict = this.sessionVerdicts.get(s.id);
       if (!verdict) return s;
-      return { ...s, lifecycle: verdict, lifecycleSource: "reconcile" };
+      return { ...s, lifecycle: verdict.lifecycle, lifecycleSource: "reconcile" };
     });
   }
   addSessionSubscriber(sessionId, ws) {
@@ -10197,14 +10386,30 @@ var StreamerServer = class {
     let verdicts = [];
     try {
       const rows = this.managedSessionsRepo.listNonTerminal();
+      if (rows.length === PROBE_SET_MAX) {
+        this.log.warn(
+          `[reconcile] probe set hit its cap of ${PROBE_SET_MAX} \u2014 older rows skipped`,
+          {
+            event: "registry.probe_truncated",
+            limit: PROBE_SET_MAX
+          }
+        );
+      }
       if (rows.length === 0) return [];
       verdicts = await reconcileSessions(
         rows,
         { isPidAlive, getProcessArgs },
-        this.streamerInstanceId
+        this.streamerInstanceId,
+        currentBootToken()
       );
       for (const v of verdicts) {
-        this.sessionLifecycles.set(v.sessionId, v.lifecycle);
+        this.sessionVerdicts.set(v.sessionId, v);
+        if (v.reason === PRE_BOOT_REASON) {
+          this.log.info(`[reconcile] ${v.sessionId} predates this machine boot \u2014 pid not probed`, {
+            event: "sessions.boot_token_mismatch",
+            sessionId: v.sessionId
+          });
+        }
         if (v.lifecycle === "completed" || v.lifecycle === "failed") {
           this.managedSessionsRepo.recordStatus(v.sessionId, "idle", "reconcile", {
             completedAt: /* @__PURE__ */ new Date()
@@ -10226,6 +10431,30 @@ var StreamerServer = class {
     }
     return verdicts;
   }
+  /**
+   * Drop finished sessions the registry has held long enough (plan Phase 4).
+   *
+   * The registry is authoritative and never rebuilt from the cache, so nothing
+   * else would ever remove a row: without this it grows for the life of the
+   * install, and every boot pays for rows about sessions from months ago.
+   */
+  pruneTerminalSessions() {
+    if (!this.managedSessionsRepo) return;
+    try {
+      const pruned = this.managedSessionsRepo.pruneTerminal();
+      if (pruned > 0) {
+        this.log.info(`[registry] pruned ${pruned} terminal session row(s)`, {
+          event: "registry.pruned",
+          pruned
+        });
+      }
+    } catch (err) {
+      this.log.warn("[registry] failed to prune terminal sessions", {
+        event: "registry.prune_failed",
+        err
+      });
+    }
+  }
   /**
    * Seed the session list with what previous runs left behind (persistence plan
    * Phase 1, gaps G1/G2/G8).
@@ -10242,7 +10471,7 @@ var StreamerServer = class {
    * by id rather than duplicating it.
    */
   rehydratePreviousSessions(verdicts) {
-    if (!this.featureFlags.sessionRehydration || !this.managedSessionsRepo) return;
+    if (!this.managedSessionsRepo) return [];
     try {
       const now = Date.now();
       const rows = this.managedSessionsRepo.listRecoverable({
@@ -10251,16 +10480,30 @@ var StreamerServer = class {
       });
       const truncated = rows.length > REHYDRATE_MAX;
       const candidates = truncated ? rows.slice(0, REHYDRATE_MAX) : rows;
-      if (candidates.length === 0) return;
-      const lifecycleByVerdict = new Map(verdicts.map((v) => [v.sessionId, v.lifecycle]));
+      if (!this.featureFlags.sessionRehydration || candidates.length === 0) return candidates;
+      const verdictById = new Map(verdicts.map((v) => [v.sessionId, v]));
       let rehydrated = 0;
+      const skippedBy = {};
       for (const row of candidates) {
         if (this.sessionStore.getManaged(row.session_id)) continue;
-        if (!shouldRehydrate(row, { now, projectExists: import_fs19.existsSync })) continue;
+        const skip = rehydrateSkipReason(row, { now, projectExists: import_fs19.existsSync });
+        if (skip) {
+          skippedBy[skip] = (skippedBy[skip] ?? 0) + 1;
+          this.log.info(`[rehydrate] skipped ${row.session_id}: ${skip}`, {
+            event: "sessions.rehydrate_skipped",
+            sessionId: row.session_id,
+            reason: skip
+          });
+          continue;
+        }
         this.sessionStore.addManaged(rowToStubSession(row));
-        this.sessionLifecycles.set(
+        this.sessionVerdicts.set(
           row.session_id,
-          lifecycleByVerdict.get(row.session_id) ?? "resumable"
+          verdictById.get(row.session_id) ?? {
+            sessionId: row.session_id,
+            lifecycle: "resumable",
+            reason: "recovered from the registry at boot"
+          }
         );
         if (row.completed_at != null) this.selfPtyEndedAt.set(row.session_id, row.completed_at);
         rehydrated++;
@@ -10269,14 +10512,110 @@ var StreamerServer = class {
         event: "sessions.rehydrated",
         rehydrated,
         skipped: candidates.length - rehydrated,
+        skippedBy,
         truncated
       });
+      return candidates;
     } catch (err) {
       this.log.warn("[rehydrate] failed to rehydrate previous sessions", {
         event: "sessions.rehydrate_failed",
         err
       });
+      return [];
+    }
+  }
+  /** Resume only the recent sessions the user explicitly allowed us to start at boot. */
+  async autoResumePreviousSessions(rows) {
+    if (!this.autoResumeOnBoot) return;
+    const plan = planAutoResume(rows, { now: Date.now(), projectExists: import_fs19.existsSync });
+    const skippedBy = {};
+    for (const { row, reason } of plan.skipped) {
+      skippedBy[reason] = (skippedBy[reason] ?? 0) + 1;
+      this.log.debug(`[auto-resume] skipped ${row.session_id}: ${reason}`, {
+        event: "sessions.auto_resume_skipped",
+        sessionId: row.session_id,
+        reason
+      });
+    }
+    if (plan.skipped.length > 0) {
+      this.log.info(
+        `[auto-resume] left ${plan.skipped.length} ineligible session(s) for manual resume`,
+        {
+          event: "sessions.auto_resume_skipped",
+          skipped: plan.skipped.length,
+          skippedBy
+        }
+      );
+    }
+    for (const row of plan.overflow) {
+      this.log.info(`[auto-resume] left ${row.session_id} for manual resume: ceiling reached`, {
+        event: "sessions.auto_resume_skipped",
+        sessionId: row.session_id,
+        reason: "ceiling_reached"
+      });
     }
+    let resumed = 0;
+    let failed = 0;
+    const inFlight = /* @__PURE__ */ new Set();
+    let started = 0;
+    const resume = async (row) => {
+      try {
+        const outcome = await this.resumeSession({
+          sessionId: row.session_id,
+          projectName: row.project_name,
+          branch: row.branch
+        });
+        if (!outcome.ok) {
+          failed++;
+          this.log.info(`[auto-resume] skipped ${row.session_id}: ${outcome.reason}`, {
+            event: "sessions.auto_resume_skipped",
+            sessionId: row.session_id,
+            reason: outcome.reason,
+            ...outcome.reason === "conversation_busy" && {
+              detectedBy: outcome.detectedBy,
+              lastActivityMs: outcome.lastActivityMs,
+              likelyOwner: outcome.likelyOwner
+            }
+          });
+          return;
+        }
+        resumed++;
+        this.log.info(`[auto-resume] resumed ${row.session_id}`, {
+          event: "sessions.auto_resume_succeeded",
+          sessionId: row.session_id,
+          alreadyRunning: outcome.alreadyRunning
+        });
+      } catch (err) {
+        failed++;
+        this.log.warn(`[auto-resume] failed to resume ${row.session_id}`, {
+          event: "sessions.auto_resume_failed",
+          sessionId: row.session_id,
+          err
+        });
+      }
+    };
+    for (const row of plan.attempts) {
+      while (inFlight.size >= AUTO_RESUME_CONCURRENCY) {
+        await Promise.race(inFlight);
+      }
+      if (started > 0) {
+        await new Promise((resolve2) => setTimeout(resolve2, AUTO_RESUME_STAGGER_MS));
+      }
+      const task = resume(row);
+      inFlight.add(task);
+      void task.then(() => inFlight.delete(task));
+      started++;
+    }
+    await Promise.all(inFlight);
+    if (resumed > 0) this.wsHub.broadcast(this.sessionListPayload());
+    this.log.info(`[auto-resume] completed boot recovery: ${resumed} resumed`, {
+      event: "sessions.auto_resume_completed",
+      attempted: plan.attempts.length,
+      resumed,
+      failed,
+      ineligible: plan.skipped.length,
+      overflow: plan.overflow.length
+    });
   }
   /**
    * Pick a token guaranteed to appear in the spawned process's argv, for the
@@ -10360,7 +10699,7 @@ var StreamerServer = class {
     const now = /* @__PURE__ */ new Date();
     for (const session of this.ptyManager.listSessions()) {
       try {
-        this.managedSessionsRepo.recordStatus(session.id, "idle", "shutdown", {
+        this.managedSessionsRepo.recordStatus(session.id, session.status, "shutdown", {
           completedAt: now,
           lastActivityAt: session.lastActivityAt ?? null,
           promptCount: session.promptCount
@@ -10598,7 +10937,11 @@ var StreamerServer = class {
           );
           this.scannerPersistenceDisabled = true;
         }
-        void this.reconcilePreviousSessions().then((v) => this.rehydratePreviousSessions(v));
+        void this.reconcilePreviousSessions().then(async (v) => {
+          const recoverableRows = this.rehydratePreviousSessions(v);
+          await this.autoResumePreviousSessions(recoverableRows);
+          this.pruneTerminalSessions();
+        });
         if (this.skipStartupWarmup) {
           this.log.debug?.("startup warm-up scan skipped (skipStartupWarmup)", {
             event: "cache.warmup_skipped"
@@ -12166,32 +12509,85 @@ var StreamerServer = class {
       json(res, 400, { error: "Missing sessionId" });
       return;
     }
+    const outcome = await this.resumeSession({
+      sessionId,
+      force: body.force === true,
+      projectName: body.projectName,
+      branch: body.branch
+    });
+    if (!outcome.ok) {
+      switch (outcome.reason) {
+        case "history_file_missing":
+          json(res, 404, {
+            error: "Conversation history file is missing; it can no longer be resumed",
+            code: "history_file_missing"
+          });
+          return;
+        case "no_project_path":
+          json(res, 400, { error: "Could not determine project path" });
+          return;
+        case "conversation_busy":
+          json(res, 409, {
+            error: "This conversation looks active in another session",
+            code: "CONVERSATION_BUSY",
+            detectedBy: outcome.detectedBy,
+            lastActivityMs: outcome.lastActivityMs,
+            likelyOwner: outcome.likelyOwner
+          });
+          return;
+      }
+    }
+    if (outcome.alreadyRunning) {
+      json(res, 200, outcome.response);
+      return;
+    }
+    this.broadcastOrUnicastSessionList(req);
+    json(res, 201, outcome.response ?? outcome.session);
+  }
+  /**
+   * Resume a session, from an HTTP request or from the boot path.
+   *
+   * Extracted from `handleResume` so both callers hit the **same collision
+   * probe** (plan Phase 7c). The probe is what stops this streamer attaching to
+   * a conversation an external terminal already owns; a second, hand-adapted
+   * copy of this sequence in the boot path is how two agents end up appending
+   * to one JSONL at 4am with nobody watching.
+   *
+   * Returns a typed reason rather than writing a response, so the HTTP caller
+   * maps it to a status code and the boot caller logs it.
+   */
+  async resumeSession(opts) {
+    const { sessionId } = opts;
     if (this.ptyManager.hasSession(sessionId)) {
-      const resp2 = this.sessionStore.get(sessionId, this.ptyAttachedIds());
-      if (resp2) {
-        json(res, 200, resp2);
-        return;
+      const resp = this.sessionStore.get(sessionId, this.ptyAttachedIds());
+      if (resp) {
+        return { ok: true, alreadyRunning: true, session: null, response: resp };
+      }
+    }
+    let jsonlPath = this.findJsonlPath(sessionId);
+    let conv = await this.findConversationByUuid(sessionId);
+    let historyId = sessionId;
+    let registryProvider;
+    if (!jsonlPath && !conv) {
+      const row = this.managedSessionsRepo?.get(sessionId) ?? null;
+      const boundId = row ? resumeIdForRow(row) : null;
+      if (boundId != null && boundId !== sessionId) {
+        historyId = boundId;
+        registryProvider = row?.provider;
+        jsonlPath = this.findJsonlPath(boundId);
+        conv = await this.findConversationByUuid(boundId);
       }
     }
-    const jsonlPath = this.findJsonlPath(sessionId);
     const jsonlCwd = jsonlPath ? await this.readCwdFromJsonl(jsonlPath) : null;
-    const conv = await this.findConversationByUuid(sessionId);
     const projectPath = jsonlCwd ?? conv?.projectPath;
     if (!projectPath) {
-      if (!conv && !jsonlPath) {
-        json(res, 404, {
-          error: "Conversation history file is missing; it can no longer be resumed",
-          code: "history_file_missing"
-        });
-        return;
-      }
-      json(res, 400, { error: "Could not determine project path" });
-      return;
+      if (!conv && !jsonlPath) return { ok: false, reason: "history_file_missing" };
+      return { ok: false, reason: "no_project_path" };
     }
     let discovered = [];
-    const cached2 = this.discoveryCache;
-    if (cached2 && Date.now() - cached2.fetchedAt < DISCOVERY_TTL_MS) {
-      discovered = cached2.entries;
+    const cached3 = this.discoveryCache;
+    if (cached3 && Date.now() - cached3.fetchedAt < DISCOVERY_TTL_MS) {
+      discovered = cached3.entries;
     } else {
       try {
         discovered = await Promise.race([
@@ -12207,45 +12603,50 @@ var StreamerServer = class {
       }
     }
     const busy = conversationBusy({
-      conversationId: sessionId,
+      // The id another owner's argv would actually carry — for a placeholder
+      // that is the bound rollout id, not the one the client asked for.
+      conversationId: historyId,
       projectPath,
       jsonlPath,
       discovered,
       windowMs: resolveResumeBusyWindowMs(),
       selfPtyEndedAt: this.selfPtyEndedAt.get(sessionId) ?? null
     });
-    if (busy.busy && body.force !== true) {
-      json(res, 409, {
-        error: "This conversation looks active in another session",
-        code: "CONVERSATION_BUSY",
+    if (busy.busy && opts.force !== true) {
+      return {
+        ok: false,
+        reason: "conversation_busy",
         detectedBy: busy.detectedBy,
         lastActivityMs: busy.lastActivityMs,
         likelyOwner: busy.likelyOwner
-      });
-      return;
+      };
     }
     if (busy.busy) {
       this.contendedSessions.add(sessionId);
     }
-    const cachedConvMeta = this.cache?.getMetaById(sessionId);
-    const provider = coerceProviderForRunner(conv?.provider ?? cachedConvMeta?.provider);
+    const cachedConvMeta = this.cache?.getMetaById(historyId);
+    const provider = coerceProviderForRunner(
+      conv?.provider ?? cachedConvMeta?.provider ?? registryProvider
+    );
     this.discoveryCache = null;
     const session = await this.ptyManager.start(sessionId, {
       provider,
       projectPath,
-      projectName: body.projectName,
-      branch: body.branch,
+      projectName: opts.projectName,
+      branch: opts.branch,
+      // Omitted on every ordinary resume, so argv is unchanged there.
+      ...historyId !== sessionId && { resumeId: historyId },
       claudeFlags: this.claudeFlags,
       claudeExtraArgs: this.claudeExtraArgs,
       ...this.spawnFlagOverrides()
     });
+    if (historyId !== sessionId) session.boundConversationId = historyId;
     this.sessionStore.addManaged(session);
     this.recordSessionSpawn(session);
-    void this.watchConversationFile(sessionId);
-    const resp = this.sessionStore.get(session.id, this.ptyAttachedIds());
-    this.broadcastOrUnicastSessionList(req);
-    json(res, 201, resp ?? session);
+    void this.watchConversationFile(sessionId, historyId);
+    const response = this.sessionStore.get(session.id, this.ptyAttachedIds());
     this.enrichResumedSessionAsync(sessionId, projectPath, conv);
+    return { ok: true, alreadyRunning: false, session, response };
   }
   enrichResumedSessionAsync(sessionId, projectPath, conv) {
     try {
@@ -12258,18 +12659,18 @@ var StreamerServer = class {
         session.filePath = conv.filePath ?? void 0;
       }
       if (!this.cache || !this.projectsRepo || !this.conversationsRepo) return;
-      const cached2 = this.cache.getMetaById(sessionId);
-      if (cached2) {
-        session.model = cached2.model ?? void 0;
-        session.preview = cached2.preview ?? void 0;
-        const first = cached2.firstMessage ? JSON.parse(cached2.firstMessage) : null;
-        const last = cached2.lastMessage ? JSON.parse(cached2.lastMessage) : null;
+      const cached3 = this.cache.getMetaById(sessionId);
+      if (cached3) {
+        session.model = cached3.model ?? void 0;
+        session.preview = cached3.preview ?? void 0;
+        const first = cached3.firstMessage ? JSON.parse(cached3.firstMessage) : null;
+        const last = cached3.lastMessage ? JSON.parse(cached3.lastMessage) : null;
         session.firstMessageText = first?.text ?? void 0;
         session.firstMessageAt = first?.timestamp ? new Date(first.timestamp).toISOString() : void 0;
         session.lastMessageText = last?.text ?? void 0;
         session.lastMessageAt = last?.timestamp ? new Date(last.timestamp).toISOString() : void 0;
       }
-      let resolvedProjectId = cached2?.projectId ?? null;
+      let resolvedProjectId = cached3?.projectId ?? null;
       if (!resolvedProjectId) {
         const project = this.projectsRepo.upsertProjectByPath(projectPath);
         resolvedProjectId = project.id;
@@ -12841,9 +13242,12 @@ var StreamerServer = class {
     }
   }
   // ─── File Watcher Wiring ─────────────────────────────────────────
-  async watchConversationFile(sessionId) {
+  // `historyId` is the id the provider filed the history under, which for a
+  // fresh Codex session is its rollout id rather than our placeholder. The map
+  // stays keyed by `sessionId` — that is what broadcasts resolve against.
+  async watchConversationFile(sessionId, historyId = sessionId) {
     try {
-      const conversation = await this.findConversationByUuid(sessionId);
+      const conversation = await this.findConversationByUuid(historyId);
       if (conversation?.filePath) {
         this.sessionFileMap.set(sessionId, conversation.filePath);
         this.fileWatcher.watch(conversation.filePath);
@@ -13006,6 +13410,15 @@ var StreamerServer = class {
           const codexSessionId = match.id;
           cleanup();
           this.sessionStore.updateManaged(sessionId, { boundConversationId: codexSessionId });
+          try {
+            this.managedSessionsRepo?.recordBinding(sessionId, codexSessionId);
+          } catch (err) {
+            this.log.warn("[registry] failed to record Codex rollout binding", {
+              event: "registry.binding_write_failed",
+              sessionId,
+              err
+            });
+          }
           this.sessionFileMap.set(sessionId, candidatePath);
           this.fileWatcher.watch(candidatePath);
           try {