@threadbase-sh/streamer 1.40.0 → 1.41.1

package/dist/cli.cjs

@@ -6213,6 +6213,12 @@ var init_feature_flags = __esm({
         description: "Send the built system prompt to fresh Codex sessions. Off by default: Codex has no --system-prompt flag, so the prompt goes in the positional [PROMPT] argument, which Codex treats as the user's opening turn rather than a system-level instruction.",
         default: false,
         env: "THREADBASE_FEATURE_CODEX_SYSTEM_PROMPT"
+      },
+      {
+        id: "sessionRehydration",
+        description: "Seed the session list at boot with sessions a previous streamer run left behind, so a restart leaves them one tap from resuming instead of silently gone. On by default, with a kill switch: it changes what GET /api/sessions contains.",
+        default: true,
+        env: "THREADBASE_FEATURE_SESSION_REHYDRATION"
       }
     ];
   }
@@ -124077,8 +124083,8 @@ function isAbiMismatch(message) {
 }
 function checkSqliteAbi() {
   try {
-    const Database3 = require("better-sqlite3");
-    const db = new Database3(":memory:");
+    const Database4 = require("better-sqlite3");
+    const db = new Database4(":memory:");
     db.close();
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -139971,6 +139977,9 @@ function getMigrationsDir() {
   }
   return __dirname;
 }
+function resolveMigrationsDir(name = "migrations") {
+  return (0, import_path15.join)(getMigrationsDir(), name);
+}
 var SCHEMA_MIGRATIONS_SQL = `
 CREATE TABLE IF NOT EXISTS schema_migrations (
   id TEXT PRIMARY KEY,
@@ -139979,7 +139988,7 @@ CREATE TABLE IF NOT EXISTS schema_migrations (
 `;
 function runSqliteMigrations(db, migrationsDir) {
   db.exec(SCHEMA_MIGRATIONS_SQL);
-  const dir = migrationsDir ?? (0, import_path15.join)(getMigrationsDir(), "migrations");
+  const dir = migrationsDir ?? resolveMigrationsDir();
   const files = (0, import_fs15.readdirSync)(dir).filter((f2) => f2.endsWith(".sql")).sort();
   const appliedRows = db.prepare("SELECT id FROM schema_migrations").all();
   const appliedSet = new Set(appliedRows.map((r) => r.id));
@@ -141480,6 +141489,7 @@ var ManagedSessionsRepository = class {
   updateStatusStmt;
   getStmt;
   listNonTerminalStmt;
+  listRecoverableStmt;
   deleteStmt;
   constructor(db) {
     this.upsertStmt = db.prepare(`
@@ -141523,7 +141533,8 @@ var ManagedSessionsRepository = class {
              completed_at = @completed_at,
              last_activity_at = @last_activity_at,
              prompt_count = @prompt_count,
-             failure_reason = COALESCE(@failure_reason, failure_reason)
+             failure_reason = COALESCE(@failure_reason, failure_reason),
+             session_name = COALESCE(@session_name, session_name)
        WHERE session_id = @session_id
     `);
     this.getStmt = db.prepare("SELECT * FROM managed_sessions WHERE session_id = ?");
@@ -141532,6 +141543,13 @@ var ManagedSessionsRepository = class {
        WHERE completed_at IS NULL
        ORDER BY started_at ASC
     `);
+    this.listRecoverableStmt = db.prepare(`
+      SELECT * FROM managed_sessions
+       WHERE (completed_at IS NULL OR status_source = 'shutdown')
+         AND status_updated_at >= @since
+       ORDER BY status_updated_at DESC
+       LIMIT @limit
+    `);
     this.deleteStmt = db.prepare("DELETE FROM managed_sessions WHERE session_id = ?");
   }
   /** Record a session at spawn, or refresh every field of an existing row. */
@@ -141573,7 +141591,8 @@ var ManagedSessionsRepository = class {
       completed_at: fields.completedAt?.getTime() ?? null,
       last_activity_at: fields.lastActivityAt?.getTime() ?? null,
       prompt_count: fields.promptCount ?? 0,
-      failure_reason: fields.failureReason ?? null
+      failure_reason: fields.failureReason ?? null,
+      session_name: fields.sessionName ?? null
     });
   }
   get(sessionId) {
@@ -141583,6 +141602,14 @@ var ManagedSessionsRepository = class {
   listNonTerminal() {
     return this.listNonTerminalStmt.all();
   }
+  /**
+   * Rows a restart could bring back: still open, or closed by our own shutdown,
+   * and touched no longer ago than `sinceMs`. Newest first, capped — the caller
+   * decides which of these actually deserve rehydrating (`shouldRehydrate`).
+   */
+  listRecoverable({ sinceMs, limit }) {
+    return this.listRecoverableStmt.all({ since: sinceMs, limit });
+  }
   delete(sessionId) {
     this.deleteStmt.run(sessionId);
   }
@@ -141718,6 +141745,54 @@ var SessionsRepository = class {
   }
 };
 
+// src/db/runtime-store.ts
+var import_better_sqlite33 = __toESM(require("better-sqlite3"), 1);
+var RuntimeStore = class _RuntimeStore {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  static open(dbPath, migrationsDir) {
+    const db = new import_better_sqlite33.default(dbPath);
+    db.pragma("journal_mode = WAL");
+    runSqliteMigrations(db, migrationsDir ?? resolveMigrationsDir("runtime-migrations"));
+    return new _RuntimeStore(db);
+  }
+  getDatabase() {
+    return this.db;
+  }
+  /**
+   * One-time move of `managed_sessions` rows out of a pre-split `cache.db`.
+   *
+   * Non-destructive by design: the source table is left in place so an older
+   * streamer rolled back onto the same machine still finds its registry. Runs
+   * only when this file's table is empty, so a second boot is a no-op rather
+   * than a re-copy that would resurrect rows deleted since.
+   *
+   * Returns the number of rows copied.
+   */
+  importLegacyManagedSessions(source) {
+    const existing = this.db.prepare("SELECT COUNT(*) AS n FROM managed_sessions").get();
+    if (existing.n > 0) return 0;
+    const hasTable = source.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'managed_sessions'").get();
+    if (!hasTable) return 0;
+    const rows = source.prepare("SELECT * FROM managed_sessions").all();
+    if (rows.length === 0) return 0;
+    const columns = Object.keys(rows[0]);
+    const insert = this.db.prepare(
+      `INSERT OR IGNORE INTO managed_sessions (${columns.join(", ")})
+       VALUES (${columns.map((c) => `@${c}`).join(", ")})`
+    );
+    this.db.transaction((batch) => {
+      for (const row of batch) insert.run(row);
+    })(rows);
+    return rows.length;
+  }
+  close() {
+    this.db.close();
+  }
+};
+
 // src/db/upload-records.ts
 async function recordUpload(pool2, instanceId, row) {
   if (!pool2) return;
@@ -142739,6 +142814,12 @@ function detectShellPrompt(lines) {
   return null;
 }
 
+// src/utils/deriveSessionName.ts
+function deriveSessionName(firstMessageText) {
+  const firstLine = firstMessageText.split("\n", 1)[0]?.trim() ?? "";
+  return firstLine.slice(0, 80);
+}
+
 // src/pty-manager.ts
 var OUTPUT_BUFFER_MAX2 = 65536;
 var INPUT_HISTORY_MAX2 = 50;
@@ -142746,8 +142827,8 @@ var PTY_COLS2 = 120;
 var PTY_ROWS2 = 40;
 var SCREEN_SCROLLBACK2 = 1e3;
 var CLAUDE_PROMPT_MARKERS = ["\u256D", "\u276F"];
-var PROMPT_MARKER_FALLBACK_MS = 1e4;
 var QUIET_DETECT_MS2 = 500;
+var CLAUDE_READY_FALLBACK_MS = 8e3;
 function buildPasteBytes(input) {
   return `\x1B[200~${input}\x1B[201~`;
 }
@@ -142823,8 +142904,8 @@ var PTYManager = class {
   // silently lost — the "dot bug".
   queuedInputs = /* @__PURE__ */ new Map();
   log;
-  // Timestamp of first PTY chunk per session; drives the prompt-marker fallback
-  // when neither ╭ nor ❯ shows up within PROMPT_MARKER_FALLBACK_MS.
+  // Timestamp of first PTY chunk per session; used for the [pty.ready] elapsed
+  // measurement so a slow boot is visible in the logs.
   firstChunkAt = /* @__PURE__ */ new Map();
   // Per-session chunk counter and last-chunk timestamp. Diagnostic-only,
   // feeds the [pty.chunk] log lines so we can trace whether Claude responded
@@ -142835,6 +142916,8 @@ var PTYManager = class {
   // QUIET_DETECT_MS after the last chunk so ready/prompt detection doesn't
   // wait for another chunk that may never arrive (Claude blocked on input).
   quietCheckers = /* @__PURE__ */ new Map();
+  // Per-session flat backstop from the first chunk (CLAUDE_READY_FALLBACK_MS).
+  readyFallbackTimers = /* @__PURE__ */ new Map();
   // In-flight start()/startFresh() calls keyed by sessionId. A second
   // concurrent resume for the same session (double-tap, client retry) awaits
   // the first call's promise instead of spawning a duplicate PTY (CRITICAL #3).
@@ -142920,6 +143003,7 @@ var PTYManager = class {
     };
     this.sessions.set(sessionId, session);
     this.pendingReady.add(sessionId);
+    this.armReadyFallback(sessionId);
     proc.onData((data) => {
       this.handleOutput(sessionId, data);
     });
@@ -142980,6 +143064,7 @@ var PTYManager = class {
     };
     this.sessions.set(sessionId, session);
     this.pendingReady.add(sessionId);
+    this.armReadyFallback(sessionId);
     proc.onData((data) => {
       this.handleOutput(sessionId, data);
     });
@@ -143154,6 +143239,7 @@ var PTYManager = class {
     this.shellPromptOpen.delete(sessionId);
     this.quietCheckers.get(sessionId)?.cancel();
     this.quietCheckers.delete(sessionId);
+    this.clearReadyFallback(sessionId);
     try {
       session.process.kill("SIGINT");
     } catch {
@@ -143212,6 +143298,10 @@ var PTYManager = class {
     if (session.inputHistory.length > INPUT_HISTORY_MAX2) {
       session.inputHistory.shift();
     }
+    if (session.firstMessageText === void 0) {
+      session.firstMessageText = text;
+      session.sessionName = deriveSessionName(text);
+    }
     this.onUserMessage?.(session.id, text, ts2);
   }
   getSession(sessionId) {
@@ -143238,6 +143328,8 @@ var PTYManager = class {
     this.lastChunkAt.clear();
     for (const quiet of this.quietCheckers.values()) quiet.cancel();
     this.quietCheckers.clear();
+    for (const timer of this.readyFallbackTimers.values()) clearTimeout(timer);
+    this.readyFallbackTimers.clear();
     this.permissionOpen.clear();
     this.lastScreenQuestionKey.clear();
     this.shellPromptOpen.clear();
@@ -143280,8 +143372,6 @@ var PTYManager = class {
     const matchedMarker = CLAUDE_PROMPT_MARKERS.find((m2) => stripped.includes(m2));
     if (session.status === "running" && matchedMarker) {
       this.markReady(sessionId, session, "prompt-marker", `marker:${matchedMarker}`);
-    } else if (session.status === "running" && this.pendingReady.has(sessionId) && now - (this.firstChunkAt.get(sessionId) ?? now) >= PROMPT_MARKER_FALLBACK_MS) {
-      this.markReady(sessionId, session, "timeout-fallback", "fallback:timeout");
     }
     this.onOutput?.(sessionId, data);
     this.detectLivePrompts(sessionId, data, stripped).catch((err) => {
@@ -143381,7 +143471,13 @@ var PTYManager = class {
     const session = this.sessions.get(sessionId);
     if (session?.status !== "running") return;
     if (this.pendingReady.has(sessionId)) {
-      this.markReady(sessionId, session, "quiet-fallback", "quiet:timeout");
+      this.recheckReadyFromScreen(sessionId).catch((err) => {
+        this.log.warn("[pty.ready] boot screen recheck failed", {
+          event: "pty.ready_recheck_failed",
+          sessionId,
+          err
+        });
+      });
     } else {
       this.recheckReadyFromScreen(sessionId).catch((err) => {
         this.log.warn("[pty.ready] screen recheck failed", {
@@ -143413,9 +143509,32 @@ var PTYManager = class {
       this.markReady(sessionId, session, "screen-marker", `quiet:screen-marker:${matchedMarker}`);
     }
   }
+  // Flat backstop from the first chunk: if neither a prompt marker nor the
+  // screen recheck settles the session within CLAUDE_READY_FALLBACK_MS, mark it
+  // ready anyway so start requests resolve and queued input is not held
+  // forever. This is what makes the quiet-checker safe to be strict — a boot
+  // variant whose marker we cannot see still recovers, just 8s later instead of
+  // 500ms sooner and wrong. unref() so it never holds the process open.
+  armReadyFallback(sessionId) {
+    const timer = setTimeout(() => {
+      this.readyFallbackTimers.delete(sessionId);
+      const session = this.sessions.get(sessionId);
+      if (session?.status === "running" && this.pendingReady.has(sessionId)) {
+        this.markReady(sessionId, session, "timeout-fallback", "fallback:timeout");
+      }
+    }, CLAUDE_READY_FALLBACK_MS);
+    timer.unref?.();
+    this.readyFallbackTimers.set(sessionId, timer);
+  }
+  clearReadyFallback(sessionId) {
+    const timer = this.readyFallbackTimers.get(sessionId);
+    if (timer) clearTimeout(timer);
+    this.readyFallbackTimers.delete(sessionId);
+  }
   // Transition a session from "running" to "waiting_input", clear pendingReady,
   // and flush any queued input. Idempotent: callers can invoke at any chunk.
   markReady(sessionId, session, source, reason) {
+    this.clearReadyFallback(sessionId);
     session.lastActivityAt = /* @__PURE__ */ new Date();
     session.status = "waiting_input";
     session.statusSource = source;
@@ -143459,6 +143578,7 @@ var PTYManager = class {
     this.shellPromptOpen.delete(sessionId);
     this.quietCheckers.get(sessionId)?.cancel();
     this.quietCheckers.delete(sessionId);
+    this.clearReadyFallback(sessionId);
   }
 };
 function toPublicSession2(s3) {
@@ -143477,7 +143597,9 @@ function toPublicSession2(s3) {
     ...s3.lastActivityAt != null && { lastActivityAt: s3.lastActivityAt },
     ...s3.statusSource != null && { statusSource: s3.statusSource },
     ...s3.statusUpdatedAt != null && { statusUpdatedAt: s3.statusUpdatedAt },
-    ...s3.filePath != null && { filePath: s3.filePath }
+    ...s3.filePath != null && { filePath: s3.filePath },
+    ...s3.sessionName != null && { sessionName: s3.sessionName },
+    ...s3.firstMessageText != null && { firstMessageText: s3.firstMessageText }
   };
 }
 function stripAnsi2(str) {
@@ -145035,7 +145157,8 @@ function contentStateForSession(args) {
     status,
     startedAt: args.startedAtOverride ?? args.session.startedAt.getTime(),
     lastOutput: truncateLastOutput(args.session.lastOutput ?? ""),
-    ...args.serverLabel != null && { serverLabel: args.serverLabel }
+    ...args.serverLabel != null && { serverLabel: args.serverLabel },
+    ...args.session.sessionName != null && { sessionName: args.session.sessionName }
   };
 }
 var LiveActivityNotifier = class {
@@ -145048,14 +145171,17 @@ var LiveActivityNotifier = class {
   serverId;
   serverLabel;
   /**
-   * Last status pushed per session.
+   * Sessions with a currently open (pushed) activity.
    *
-   * Live Activity pushes are rate-limited by iOS and the surface only renders
-   * `running` vs `waiting_input`, so re-pushing an unchanged status is pure
-   * budget spend for no visible change. This is what makes the notifier
-   * edge-triggered rather than level-triggered.
+   * An activity opens on a `waiting_input → running` edge (the user sent a
+   * prompt) and closes on the matching `running → waiting_input` edge (the
+   * response, including any sub-agents, finished) — so this set is what makes
+   * the notifier per-turn rather than per-session. A session's very first
+   * `running` (right after spawn, before any user prompt) has no prior
+   * `waiting_input` and therefore no edge, so it never opens an activity —
+   * this is what keeps a fresh/idle session from pushing anything.
    */
-  lastPushed = /* @__PURE__ */ new Map();
+  openActivity = /* @__PURE__ */ new Map();
   /**
    * React to a session status change.
    *
@@ -145063,34 +145189,22 @@ var LiveActivityNotifier = class {
    * transition, so this returns a promise the caller may ignore and every error
    * is logged rather than propagated.
    */
-  async onStatusChange(session) {
+  async onStatusChange(session, previousStatus) {
     const status = toLiveActivityStatus(session.status);
     try {
       if (!status) {
-        await this.endFor(session);
+        if (this.openActivity.has(session.id)) await this.endFor(session);
         return;
       }
-      if (this.lastPushed.get(session.id) === status) return;
-      const contentState = contentStateForSession({
-        session,
-        serverId: this.serverId,
-        serverLabel: this.serverLabel
-      });
-      if (!contentState) return;
-      const outcome = await this.sender.send({
-        sessionId: session.id,
-        event: "update",
-        contentState
-      });
-      this.lastPushed.set(session.id, status);
-      if (outcome.attempted > 0) {
-        log4.info("live_activity.updated", {
-          event: "live_activity.updated",
-          sessionId: session.id,
-          status,
-          ...outcome
-        });
+      if (status === "running" && previousStatus === "waiting_input") {
+        await this.startTurn(session);
+        return;
       }
+      if (status === "waiting_input" && previousStatus === "running") {
+        if (this.openActivity.has(session.id)) await this.endFor(session);
+        return;
+      }
+      await this.maybeSendName(session);
     } catch (err) {
       log4.error("live_activity.notify_failed", {
         event: "live_activity.notify_failed",
@@ -145100,14 +145214,57 @@ var LiveActivityNotifier = class {
       });
     }
   }
+  async startTurn(session) {
+    const contentState = contentStateForSession({
+      session,
+      serverId: this.serverId,
+      serverLabel: this.serverLabel
+    });
+    if (!contentState) return;
+    const outcome = await this.sender.send({
+      sessionId: session.id,
+      event: "update",
+      contentState
+    });
+    this.openActivity.set(session.id, { sessionNameSent: session.sessionName != null });
+    if (outcome.attempted > 0) {
+      log4.info("live_activity.updated", {
+        event: "live_activity.updated",
+        sessionId: session.id,
+        status: contentState.status,
+        ...outcome
+      });
+    }
+  }
+  async maybeSendName(session) {
+    const open3 = this.openActivity.get(session.id);
+    if (!open3 || open3.sessionNameSent || session.sessionName == null) return;
+    const contentState = contentStateForSession({
+      session,
+      serverId: this.serverId,
+      serverLabel: this.serverLabel
+    });
+    if (!contentState) return;
+    const outcome = await this.sender.send({
+      sessionId: session.id,
+      event: "update",
+      contentState
+    });
+    open3.sessionNameSent = true;
+    if (outcome.attempted > 0) {
+      log4.info("live_activity.updated", {
+        event: "live_activity.updated",
+        sessionId: session.id,
+        status: contentState.status,
+        ...outcome
+      });
+    }
+  }
   async endFor(session) {
-    const lastStatus = this.lastPushed.get(session.id);
-    this.lastPushed.delete(session.id);
+    this.openActivity.delete(session.id);
+    const status = toLiveActivityStatus(session.status);
     const contentState = contentStateForSession({
-      session: {
-        ...session,
-        status: lastStatus === "waiting_input" ? "waiting_input" : "running"
-      },
+      session: { ...session, status: status ?? "waiting_input" },
       serverId: this.serverId,
       serverLabel: this.serverLabel
     });
@@ -145121,9 +145278,9 @@ var LiveActivityNotifier = class {
       });
     }
   }
-  /** Drop cached state for a session, so a resume re-pushes its first status. */
+  /** Drop cached state for a session, so a resume re-opens on its next turn. */
   forget(sessionId) {
-    this.lastPushed.delete(sessionId);
+    this.openActivity.delete(sessionId);
   }
 };
 
@@ -145358,7 +145515,8 @@ var LiveActivityRenewalScheduler = class {
       status,
       startedAt,
       lastOutput: session.lastOutput ?? "",
-      ...this.deps.serverLabel != null && { serverLabel: this.deps.serverLabel }
+      ...this.deps.serverLabel != null && { serverLabel: this.deps.serverLabel },
+      ...session.sessionName != null && { sessionName: session.sessionName }
     };
     try {
       await this.deps.sender.send({
@@ -145418,7 +145576,8 @@ var LiveActivityRenewalScheduler = class {
         // Carried through unchanged — the whole point of the renewal.
         startedAt: args.startedAt,
         lastOutput: truncateLastOutput(session.lastOutput ?? ""),
-        ...this.deps.serverLabel != null && { serverLabel: this.deps.serverLabel }
+        ...this.deps.serverLabel != null && { serverLabel: this.deps.serverLabel },
+        ...session.sessionName != null && { sessionName: session.sessionName }
       },
       now: args.now,
       staleDate: args.startedAt + ACTIVITY_MAX_LIFETIME_MS
@@ -145805,6 +145964,50 @@ 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)
+    }
+  };
+}
+
 // src/agent/dedupe.ts
 function createProgressDedupeLRU(capacity) {
   if (!Number.isFinite(capacity) || capacity < 1) {
@@ -145978,14 +146181,15 @@ function managedToResponse(s3, ptyAttached) {
     // Lifecycle for a session this run knows about. `attached` while we hold
     // its PTY; once the PTY is gone the session is terminal from this run's
     // perspective — `failed` when it recorded a reason, else `completed`.
-    // Sessions left by *previous* runs never reach here: they aren't in the
-    // in-memory store, and the boot reconciler classifies them instead
-    // (docs/architecture/2026-07-24-durable-session-runtime.md).
-    lifecycle: ptyAttached ? "attached" : s3.failureReason != null ? "failed" : "completed",
-    lifecycleSource: ptyAttached ? "spawn" : "exit",
+    // A `rehydrated` stub is the exception: the boot rehydrator seeded it from
+    // the durable registry, so it is a previous run's session with no process
+    // behind it — `resumable`, and `historical` rather than `managed`
+    // (docs/plans/live-sessions-persistence-plan.md §4, Phase 1).
+    lifecycle: ptyAttached ? "attached" : s3.rehydrated ? "resumable" : s3.failureReason != null ? "failed" : "completed",
+    lifecycleSource: ptyAttached ? "spawn" : s3.rehydrated ? "reconcile" : "exit",
     // We spawned it, so `status` is the authoritative signal — no inferred
     // `activity` is attached for managed sessions.
-    ownership: "managed",
+    ownership: s3.rehydrated ? "historical" : "managed",
     projectPath: s3.projectPath,
     projectName: s3.projectName,
     branch: s3.branch,
@@ -146575,10 +146779,13 @@ var StreamerServer = class {
   projectsRepo = null;
   conversationsRepo = null;
   sessionsRepo = null;
-  // Durable session registry (C1 Phase 2). Null when the cache DB failed to
-  // open — persistence degrades to today's in-memory-only behaviour rather than
-  // taking the server down with it, so every write goes through `?.`.
+  // Durable session registry (C1 Phase 2). Null when runtime.db failed to open
+  // — persistence degrades to today's in-memory-only behaviour rather than
+  // taking the server down with it, so every write goes through `?.`. Note the
+  // handle is runtime.db, NOT the conversation cache: a cache failure used to
+  // null this repo and silently disable all session persistence.
   managedSessionsRepo = null;
+  runtimeStore = null;
   // Identifies this streamer run. A registry row carrying a different id is a
   // session that outlived the process that started it.
   streamerInstanceId = (0, import_crypto13.randomUUID)();
@@ -146597,6 +146804,7 @@ var StreamerServer = class {
   liveActivityRenewal = null;
   discoveryCache = null;
   cacheDir;
+  runtimeDbPath;
   tailSize;
   directoryDebounceMs;
   // Trailing-debounced trigger that flags the scanner stale after a quiet
@@ -146643,6 +146851,7 @@ var StreamerServer = class {
     this.claudeFlags = config2.claudeFlags ?? loadClaudeFlags();
     this.claudeExtraArgs = config2.claudeExtraArgs ?? loadClaudeExtraArgs();
     this.cacheDir = config2.cacheDir ?? loadCacheDir() ?? (0, import_path29.join)((0, import_os13.homedir)(), ".threadbase", "cache");
+    this.runtimeDbPath = config2.runtimeDbPath ?? process.env.THREADBASE_RUNTIME_DB ?? (0, import_path29.join)(process.env.THREADBASE_CONFIG_DIR ?? (0, import_path29.join)((0, import_os13.homedir)(), ".threadbase"), "runtime.db");
     this.tailSize = config2.tailSize ?? loadTailSize() ?? 10;
     this.directoryDebounceMs = parseDirScanDebounceEnv(process.env.THREADBASE_DIR_SCAN_DEBOUNCE_MS) ?? config2.directoryScanDebounceMs ?? 1e3;
     this.markScannerStaleDebounced = debounce(() => {
@@ -146813,6 +147022,7 @@ var StreamerServer = class {
         if (resp) this.wsHub.broadcast({ type: "session_ready", session: resp });
       },
       onStatusChange: (session) => {
+        const previousStatus = this.sessionStore.getManaged(session.id)?.status;
         this.sessionStore.updateManaged(session.id, {
           status: session.status,
           completedAt: session.completedAt,
@@ -146826,7 +147036,11 @@ var StreamerServer = class {
             completedAt: session.completedAt,
             lastActivityAt: session.lastActivityAt ?? null,
             promptCount: session.promptCount,
-            failureReason: session.failureReason ?? null
+            failureReason: session.failureReason ?? null,
+            // Derived from the first user message, so it does not exist yet at
+            // recordSpawn. The input that produces it also flips
+            // waiting_input→running, which lands here.
+            sessionName: session.sessionName ?? null
           }
         );
         if (session.status === "waiting_input" || session.status === "idle") {
@@ -146867,7 +147081,7 @@ var StreamerServer = class {
         if (resp) {
           this.wsHub.broadcast({ type: "session_update", session: resp });
         }
-        void this.liveActivityNotifier?.onStatusChange(session);
+        void this.liveActivityNotifier?.onStatusChange(session, previousStatus);
         this.sessionStatusBus.emit(`status:${session.id}`, session.status);
       }
     });
@@ -146918,6 +147132,7 @@ var StreamerServer = class {
       conversationsRepo: () => this.conversationsRepo,
       sessionsRepo: () => this.sessionsRepo,
       cacheMetadataRepo: () => this.cacheMetadataRepo,
+      runtimeStore: () => this.runtimeStore,
       ptyAttachedIds: () => this.ptyAttachedIds(),
       handleListSessions: (url2, res) => this.handleListSessions(url2, res),
       handleSessionsCount: (res) => this.handleSessionsCount(res),
@@ -147217,6 +147432,58 @@ var StreamerServer = class {
     }
     return verdicts;
   }
+  /**
+   * Seed the session list with what previous runs left behind (persistence plan
+   * Phase 1, gaps G1/G2/G8).
+   *
+   * Reconciliation classifies rows and stops there; a verdict is overlaid onto a
+   * SessionResponse that already exists, and after a clean restart none does —
+   * `SessionStore` starts empty. So the user's session did not become
+   * `resumable`, it became *absent*. This is the half that puts it back.
+   *
+   * The seeded stubs hold no PTY and are never handed to `LiveSessionManager`,
+   * so `reapIdleSessions` and `startGraceTimer` — both of which iterate
+   * `ptyManager.listSessions()` — cannot observe them. A later resume calls
+   * `sessionStore.addManaged` with the real session, which overwrites the stub
+   * by id rather than duplicating it.
+   */
+  rehydratePreviousSessions(verdicts) {
+    if (!this.featureFlags.sessionRehydration || !this.managedSessionsRepo) return;
+    try {
+      const now = Date.now();
+      const rows = this.managedSessionsRepo.listRecoverable({
+        sinceMs: now - REHYDRATE_WINDOW_MS,
+        limit: REHYDRATE_MAX + 1
+      });
+      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((v2) => [v2.sessionId, v2.lifecycle]));
+      let rehydrated = 0;
+      for (const row of candidates) {
+        if (this.sessionStore.getManaged(row.session_id)) continue;
+        if (!shouldRehydrate(row, { now, projectExists: import_fs30.existsSync })) continue;
+        this.sessionStore.addManaged(rowToStubSession(row));
+        this.sessionLifecycles.set(
+          row.session_id,
+          lifecycleByVerdict.get(row.session_id) ?? "resumable"
+        );
+        if (row.completed_at != null) this.selfPtyEndedAt.set(row.session_id, row.completed_at);
+        rehydrated++;
+      }
+      this.log.info(`[rehydrate] recovered ${rehydrated} session(s) from the registry`, {
+        event: "sessions.rehydrated",
+        rehydrated,
+        skipped: candidates.length - rehydrated,
+        truncated
+      });
+    } catch (err) {
+      this.log.warn("[rehydrate] failed to rehydrate previous sessions", {
+        event: "sessions.rehydrate_failed",
+        err
+      });
+    }
+  }
   /**
    * Pick a token guaranteed to appear in the spawned process's argv, for the
    * reconciler's pid-reuse guard.
@@ -147450,6 +147717,17 @@ var StreamerServer = class {
           port,
           event: "server.listening"
         });
+        try {
+          this.runtimeStore = RuntimeStore.open(this.runtimeDbPath);
+          this.managedSessionsRepo = new ManagedSessionsRepository(this.runtimeStore.getDatabase());
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          const abiMismatch = message.includes("NODE_MODULE_VERSION") || message.includes("was compiled against a different Node.js version");
+          this.log.error(
+            `Runtime store failed to open \u2014 session persistence DISABLED; sessions will not survive a restart.` + (abiMismatch ? ` Fix: npm rebuild better-sqlite3` : "") + ` (${message})`,
+            { error: message, abiMismatch, path: this.runtimeDbPath, event: "runtime.open_failed" }
+          );
+        }
         try {
           this.cache = ConversationCache.open(
             (0, import_path29.join)(this.cacheDir, "cache.db"),
@@ -147477,8 +147755,20 @@ var StreamerServer = class {
           this.projectsRepo = new ProjectsRepository(db);
           this.conversationsRepo = new ConversationsRepository(this.cache);
           this.sessionsRepo = new SessionsRepository(this.sessionStore);
-          this.managedSessionsRepo = new ManagedSessionsRepository(db);
-          void this.reconcilePreviousSessions();
+          try {
+            const copied = this.runtimeStore?.importLegacyManagedSessions(db) ?? 0;
+            if (copied > 0) {
+              this.log.info(`Copied ${copied} managed session row(s) from cache.db to runtime.db`, {
+                copied,
+                event: "runtime.legacy_import"
+              });
+            }
+          } catch (err) {
+            this.log.warn("[registry] legacy managed_sessions copy failed", {
+              event: "runtime.legacy_import_failed",
+              err
+            });
+          }
           this.cacheMetadataRepo = new CacheMetadataRepository(db);
           this.pushRepo = new PushRepository(db);
           this.devicesRepo = new DevicesRepository(db);
@@ -147514,6 +147804,7 @@ var StreamerServer = class {
           );
           this.scannerPersistenceDisabled = true;
         }
+        void this.reconcilePreviousSessions().then((v2) => this.rehydratePreviousSessions(v2));
         if (this.skipStartupWarmup) {
           this.log.debug?.("startup warm-up scan skipped (skipStartupWarmup)", {
             event: "cache.warmup_skipped"
@@ -147721,6 +148012,7 @@ var StreamerServer = class {
     this.allScanners.clear();
     this.scanner = null;
     this.cache?.close();
+    this.runtimeStore?.close();
     this.ptyManager.dispose();
     this.fileWatcher.dispose();
     this.externalTails.clear();
@@ -148168,7 +148460,8 @@ var StreamerServer = class {
   }
   handleSessionsCount(res) {
     if (this.rejectIfWarmingUp(res)) return;
-    json2(res, 200, { total: this.sessionStore.list(this.ptyAttachedIds()).length });
+    const total = this.sessionStore.list(this.ptyAttachedIds()).filter((s3) => s3.ownership !== "historical").length;
+    json2(res, 200, { total });
   }
   handleGetRecentSessions(url2, res) {
     if (this.rejectIfWarmingUp(res)) return;