@threadbase-sh/streamer 1.39.1 → 1.41.0

package/dist/index.cjs

@@ -500,6 +500,12 @@ var FEATURE_FLAGS = [
     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"
   }
 ];
 function findFeatureFlag(id) {
@@ -1936,6 +1942,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;
@@ -2409,6 +2421,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, ts);
   }
   getSession(sessionId) {
@@ -2674,7 +2690,9 @@ function toPublicSession2(s) {
     ...s.lastActivityAt != null && { lastActivityAt: s.lastActivityAt },
     ...s.statusSource != null && { statusSource: s.statusSource },
     ...s.statusUpdatedAt != null && { statusUpdatedAt: s.statusUpdatedAt },
-    ...s.filePath != null && { filePath: s.filePath }
+    ...s.filePath != null && { filePath: s.filePath },
+    ...s.sessionName != null && { sessionName: s.sessionName },
+    ...s.firstMessageText != null && { firstMessageText: s.firstMessageText }
   };
 }
 function stripAnsi2(str) {
@@ -3061,10 +3079,10 @@ var import_client = require("@temporalio/client");
 var import_scanner3 = require("@threadbase-sh/scanner");
 var import_crypto11 = require("crypto");
 var import_events = require("events");
-var import_fs18 = require("fs");
+var import_fs19 = require("fs");
 var import_promises7 = require("fs/promises");
 var import_http = require("http");
-var import_os9 = require("os");
+var import_os10 = require("os");
 var import_path18 = require("path");
 var import_readline = require("readline");
 
@@ -3324,7 +3342,7 @@ async function handleStartAgentSession(body, deps) {
 }
 
 // src/api/app.ts
-var import_hono16 = require("hono");
+var import_hono18 = require("hono");
 
 // src/db/repositories/devices.repository.ts
 var import_crypto5 = require("crypto");
@@ -3644,12 +3662,222 @@ var errorMiddleware = (err, c) => {
   return c.json({ error: message }, 500);
 };
 
-// src/api/routes/browse.routes.ts
+// src/api/routes/backup.routes.ts
 var import_hono2 = require("hono");
+var import_os5 = require("os");
+
+// src/services/backup/backup.ts
+var BACKUP_FORMAT_VERSION = 1;
+var BackupError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+function validateArchive(input) {
+  if (!input || typeof input !== "object") {
+    throw new BackupError("Backup is not an object", "INVALID_ARCHIVE");
+  }
+  const archive = input;
+  const manifest = archive.manifest;
+  if (!manifest || typeof manifest !== "object") {
+    throw new BackupError("Backup is missing its manifest", "INVALID_ARCHIVE");
+  }
+  if (manifest.formatVersion !== BACKUP_FORMAT_VERSION) {
+    throw new BackupError(
+      `Unsupported backup format version ${String(manifest.formatVersion)}; this build reads version ${BACKUP_FORMAT_VERSION}`,
+      "UNSUPPORTED_VERSION"
+    );
+  }
+  if (!Array.isArray(archive.projects)) {
+    throw new BackupError("Backup is missing its projects array", "INVALID_ARCHIVE");
+  }
+  for (const [i, p] of archive.projects.entries()) {
+    if (!p || typeof p !== "object") {
+      throw new BackupError(`Project at index ${i} is not an object`, "INVALID_ARCHIVE");
+    }
+    if (typeof p.id !== "string" || p.id.length === 0) {
+      throw new BackupError(`Project at index ${i} has no id`, "INVALID_ARCHIVE");
+    }
+    if (typeof p.path !== "string" || p.path.length === 0) {
+      throw new BackupError(`Project at index ${i} has no path`, "INVALID_ARCHIVE");
+    }
+  }
+  const ids = new Set(archive.projects.map((p) => p.id));
+  if (ids.size !== archive.projects.length) {
+    throw new BackupError("Backup contains duplicate project ids", "INVALID_ARCHIVE");
+  }
+  return archive;
+}
+function remapPaths(projects, rules) {
+  const ordered = [...rules].sort((a, b) => b.from.length - a.from.length);
+  return projects.map((p) => {
+    const rule = ordered.find((r) => p.path === r.from || p.path.startsWith(`${r.from}/`));
+    if (!rule) return p;
+    return { ...p, path: `${rule.to}${p.path.slice(rule.from.length)}` };
+  });
+}
+function planRestore(incoming, existing) {
+  const byId = new Map(existing.map((e) => [e.id, e]));
+  const byPath = new Map(existing.map((e) => [e.path, e]));
+  const plan = { create: [], update: [], conflict: [] };
+  for (const p of incoming) {
+    const sameId = byId.get(p.id);
+    if (sameId) {
+      if (sameId.path !== p.path) plan.update.push(p);
+      continue;
+    }
+    const samePath = byPath.get(p.path);
+    if (samePath) {
+      plan.conflict.push({ incoming: p, existingId: samePath.id });
+      continue;
+    }
+    plan.create.push(p);
+  }
+  return plan;
+}
+
+// src/version.ts
+var import_node_fs2 = require("fs");
+var import_node_path3 = require("path");
+var cached;
+function getVersion() {
+  if (cached !== void 0) return cached;
+  cached = resolveVersion();
+  return cached;
+}
+function resolveVersion() {
+  const scriptPath = process.argv[1] ?? "";
+  const here = scriptPath ? (0, import_node_path3.dirname)(scriptPath) : process.cwd();
+  let realHere = here;
+  try {
+    realHere = (0, import_node_path3.dirname)((0, import_node_fs2.realpathSync)(scriptPath));
+  } catch {
+  }
+  const searchDirs = realHere === here ? [here, (0, import_node_path3.join)(here, "..")] : [here, (0, import_node_path3.join)(here, ".."), realHere, (0, import_node_path3.join)(realHere, "..")];
+  for (const dir of searchDirs) {
+    try {
+      const v = (0, import_node_fs2.readFileSync)((0, import_node_path3.join)(dir, "version.txt"), "utf8").trim();
+      if (v) return v;
+    } catch {
+    }
+  }
+  try {
+    const pkg = JSON.parse((0, import_node_fs2.readFileSync)((0, import_node_path3.join)(here, "..", "package.json"), "utf8"));
+    if (pkg.version) return `${pkg.version}+source`;
+  } catch {
+  }
+  return "0.0.0+unknown";
+}
+
+// src/api/routes/backup.routes.ts
+function readBody(c) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    c.env.incoming.on("data", (chunk) => chunks.push(chunk));
+    c.env.incoming.on("end", () => {
+      try {
+        const raw = Buffer.concat(chunks).toString("utf-8");
+        resolve2(raw ? JSON.parse(raw) : {});
+      } catch {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    c.env.incoming.on("error", reject);
+  });
+}
+var createBackupRoutes = (deps) => {
+  const app = new import_hono2.Hono();
+  app.get("/export", (c) => {
+    const repo = deps.projectsRepo();
+    if (!repo) {
+      return c.json({ error: "Project store is unavailable", code: "STORE_UNAVAILABLE" }, 503);
+    }
+    const projects = repo.listProjects().map((p) => ({
+      id: p.id,
+      path: p.path,
+      name: p.name ?? null,
+      createdAt: p.createdAt,
+      updatedAt: p.updatedAt
+    }));
+    return c.json({
+      manifest: {
+        formatVersion: BACKUP_FORMAT_VERSION,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        streamerVersion: getVersion(),
+        sourceHost: (0, import_os5.hostname)(),
+        // No endpoint here exports the API key. The flag is recorded so an
+        // archive is self-describing about its own sensitivity rather than
+        // requiring a reader to infer it.
+        includesSecrets: false,
+        counts: { projects: projects.length }
+      },
+      projects
+    });
+  });
+  app.post("/restore", async (c) => {
+    const repo = deps.projectsRepo();
+    if (!repo) {
+      return c.json({ error: "Project store is unavailable", code: "STORE_UNAVAILABLE" }, 503);
+    }
+    let body;
+    try {
+      body = await readBody(c);
+    } catch {
+      return c.json({ error: "Invalid JSON body", code: "INVALID_BODY" }, 400);
+    }
+    let archive;
+    try {
+      archive = validateArchive(body.archive);
+    } catch (err) {
+      if (err instanceof BackupError) {
+        return c.json({ error: err.message, code: err.code }, 400);
+      }
+      throw err;
+    }
+    const rules = Array.isArray(body.pathMap) ? body.pathMap.filter((r) => typeof r?.from === "string" && typeof r?.to === "string").map((r) => ({ from: r.from, to: r.to })) : [];
+    const incoming = rules.length > 0 ? remapPaths(archive.projects, rules) : archive.projects;
+    const existing = repo.listProjects().map((p) => ({ id: p.id, path: p.path }));
+    const plan = planRestore(incoming, existing);
+    const summary = {
+      create: plan.create.length,
+      update: plan.update.length,
+      conflict: plan.conflict.length
+    };
+    if (body.apply !== true) {
+      return c.json({ applied: false, summary, plan });
+    }
+    if (plan.conflict.length > 0) {
+      return c.json(
+        {
+          error: "Restore has unresolved conflicts",
+          code: "RESTORE_CONFLICT",
+          summary,
+          plan
+        },
+        409
+      );
+    }
+    let applied = 0;
+    for (const p of [...plan.create, ...plan.update]) {
+      try {
+        repo.upsertProjectByPath(p.path, { name: p.name });
+        applied++;
+      } catch {
+      }
+    }
+    return c.json({ applied: true, summary, appliedCount: applied });
+  });
+  return app;
+};
+
+// src/api/routes/browse.routes.ts
+var import_hono3 = require("hono");
 var ALREADY_HANDLED = 597;
 var alreadyHandled = () => new Response(null, { status: ALREADY_HANDLED });
 var createBrowseRoutes = (deps) => {
-  const app = new import_hono2.Hono();
+  const app = new import_hono3.Hono();
   app.get("/browse", async (c) => {
     const url = new URL(c.req.url);
     await deps.handleBrowse(url, c.env.outgoing);
@@ -3663,7 +3891,7 @@ var createBrowseRoutes = (deps) => {
 };
 
 // src/api/routes/cacheAlert.routes.ts
-var import_hono3 = require("hono");
+var import_hono4 = require("hono");
 
 // src/schemas/cacheAlert.schema.ts
 var import_zod = require("zod");
@@ -3686,7 +3914,7 @@ function readRawBody2(req) {
   });
 }
 var createCacheAlertRoutes = (deps) => {
-  const app = new import_hono3.Hono();
+  const app = new import_hono4.Hono();
   app.get("/", (c) => {
     const monitor = deps.cacheMonitor();
     return c.json({ pending: monitor?.pending ?? null });
@@ -3723,7 +3951,7 @@ var createCacheAlertRoutes = (deps) => {
 };
 
 // src/api/routes/config.routes.ts
-var import_hono4 = require("hono");
+var import_hono5 = require("hono");
 
 // src/schemas/claudeFlags.schema.ts
 var import_zod2 = require("zod");
@@ -3744,7 +3972,7 @@ function readRawBody3(req) {
   });
 }
 var createConfigRoutes = (deps) => {
-  const app = new import_hono4.Hono();
+  const app = new import_hono5.Hono();
   app.get("/claude-flags", (c) => c.json(deps.claudeFlagsConfig()));
   app.get("/feature-flags", (c) => c.json(deps.featureFlagsConfig()));
   app.put("/claude-flags", async (c) => {
@@ -3779,11 +4007,11 @@ var createConfigRoutes = (deps) => {
 };
 
 // src/api/routes/conversations.routes.ts
-var import_hono5 = require("hono");
+var import_hono6 = require("hono");
 var ALREADY_HANDLED2 = 597;
 var alreadyHandled2 = () => new Response(null, { status: ALREADY_HANDLED2 });
 var createConversationRoutes = (deps) => {
-  const app = new import_hono5.Hono();
+  const app = new import_hono6.Hono();
   app.get("/count", async (c) => {
     const url = new URL(c.req.url);
     await deps.handleConversationsCount(url, c.env.outgoing);
@@ -3810,9 +4038,9 @@ var createConversationRoutes = (deps) => {
 };
 
 // src/api/routes/devices.routes.ts
-var import_hono6 = require("hono");
+var import_hono7 = require("hono");
 var createDeviceRoutes = (deps) => {
-  const app = new import_hono6.Hono();
+  const app = new import_hono7.Hono();
   app.get("/", (c) => {
     const repo = deps.devicesRepo();
     if (!repo) return c.json({ devices: [], available: false });
@@ -3835,45 +4063,134 @@ var createDeviceRoutes = (deps) => {
   return app;
 };
 
-// src/api/routes/health.routes.ts
-var import_hono7 = require("hono");
+// src/api/routes/diagnostics.routes.ts
+var import_fs7 = require("fs");
+var import_hono8 = require("hono");
 
-// src/version.ts
-var import_node_fs2 = require("fs");
-var import_node_path3 = require("path");
-var cached;
-function getVersion() {
-  if (cached !== void 0) return cached;
-  cached = resolveVersion();
-  return cached;
+// src/services/diagnostics/diagnostics.ts
+var DIAGNOSTICS_CONTRACT_VERSION = 1;
+function redactPath(path) {
+  if (!path) return null;
+  const parts = path.split(/[/\\]/).filter(Boolean);
+  if (parts.length <= 2) return parts.join("/");
+  return `\u2026/${parts.slice(-2).join("/")}`;
+}
+function worstStatus(checks) {
+  const rank = { ok: 0, unknown: 1, degraded: 2, failed: 3 };
+  return checks.reduce(
+    (worst, c) => rank[c.status] > rank[worst] ? c.status : worst,
+    "ok"
+  );
 }
-function resolveVersion() {
-  const scriptPath = process.argv[1] ?? "";
-  const here = scriptPath ? (0, import_node_path3.dirname)(scriptPath) : process.cwd();
-  let realHere = here;
-  try {
-    realHere = (0, import_node_path3.dirname)((0, import_node_fs2.realpathSync)(scriptPath));
-  } catch {
+function buildReport(checks, now = /* @__PURE__ */ new Date()) {
+  return {
+    contractVersion: DIAGNOSTICS_CONTRACT_VERSION,
+    generatedAt: now.toISOString(),
+    overall: worstStatus(checks),
+    checks
+  };
+}
+var SECRET_KEY_RE = /(key|token|secret|password|passwd|credential|authorization|cookie)/i;
+function redactValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((v) => redactValue(v));
   }
-  const searchDirs = realHere === here ? [here, (0, import_node_path3.join)(here, "..")] : [here, (0, import_node_path3.join)(here, ".."), realHere, (0, import_node_path3.join)(realHere, "..")];
-  for (const dir of searchDirs) {
-    try {
-      const v = (0, import_node_fs2.readFileSync)((0, import_node_path3.join)(dir, "version.txt"), "utf8").trim();
-      if (v) return v;
-    } catch {
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = SECRET_KEY_RE.test(k) ? "[redacted]" : redactValue(v);
     }
+    return out;
   }
+  return value;
+}
+
+// src/api/routes/diagnostics.routes.ts
+function providerCheck(name, resolve2) {
   try {
-    const pkg = JSON.parse((0, import_node_fs2.readFileSync)((0, import_node_path3.join)(here, "..", "package.json"), "utf8"));
-    if (pkg.version) return `${pkg.version}+source`;
+    const exe = resolve2();
+    return {
+      id: `provider:${name}`,
+      status: "ok",
+      summary: `${name} CLI is installed.`,
+      remediation: "NONE",
+      detail: { location: redactPath(exe) }
+    };
   } catch {
+    return {
+      id: `provider:${name}`,
+      status: "failed",
+      summary: `${name} CLI could not be located. Sessions for this provider cannot start.`,
+      remediation: "PROVIDER_NOT_INSTALLED"
+    };
   }
-  return "0.0.0+unknown";
 }
+var createDiagnosticsRoutes = (deps) => {
+  const app = new import_hono8.Hono();
+  app.get("/", (c) => {
+    const checks = [];
+    checks.push({
+      id: "streamer",
+      status: "ok",
+      summary: "Streamer is running.",
+      remediation: "NONE",
+      detail: { version: getVersion(), uptimeSeconds: Math.floor(process.uptime()) }
+    });
+    checks.push(providerCheck("claude-code", resolveClaudeExe));
+    checks.push(providerCheck("codex-cli", resolveCodexExe));
+    const cacheAlert = deps.cacheMonitor()?.healthzField();
+    checks.push(
+      cacheAlert ? {
+        id: "cache",
+        status: "degraded",
+        summary: "Conversation cache reported an integrity alert.",
+        remediation: "CACHE_DEGRADED"
+      } : {
+        id: "cache",
+        status: "ok",
+        summary: "Conversation cache is healthy.",
+        remediation: "NONE"
+      }
+    );
+    let ptyOk = true;
+    try {
+      require.resolve("node-pty");
+    } catch {
+      ptyOk = false;
+    }
+    checks.push(
+      ptyOk ? { id: "pty", status: "ok", summary: "PTY subsystem is available.", remediation: "NONE" } : {
+        id: "pty",
+        status: "failed",
+        summary: "node-pty failed to load, so no managed session can start.",
+        remediation: "PTY_UNAVAILABLE"
+      }
+    );
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    const claudeProjects = home ? `${home}/.claude/projects` : "";
+    checks.push(
+      claudeProjects && (0, import_fs7.existsSync)(claudeProjects) ? {
+        id: "filesystem",
+        status: "ok",
+        summary: "Provider history directory is present.",
+        remediation: "NONE",
+        detail: { location: redactPath(claudeProjects) }
+      } : {
+        id: "filesystem",
+        status: "degraded",
+        summary: "Provider history directory was not found; history may be unavailable.",
+        remediation: "FS_SCOPE_MISSING"
+      }
+    );
+    return c.json(redactValue(buildReport(checks)));
+  });
+  return app;
+};
 
 // src/api/routes/health.routes.ts
+var import_hono9 = require("hono");
 var createHealthRoutes = (deps) => {
-  const app = new import_hono7.Hono();
+  const app = new import_hono9.Hono();
   app.get("/", (c) => {
     const cacheAlert = deps.cacheMonitor()?.healthzField();
     return c.json({ ok: true, version: getVersion(), ...cacheAlert ? { cacheAlert } : {} });
@@ -3884,7 +4201,7 @@ var createHealthRoutes = (deps) => {
 // src/api/routes/logs.routes.ts
 var import_node_fs3 = require("fs");
 var import_node_path5 = require("path");
-var import_hono8 = require("hono");
+var import_hono10 = require("hono");
 
 // src/lifecycle/constants.ts
 var import_node_os = require("os");
@@ -3942,7 +4259,7 @@ function readLogLines(filePath, sinceOffset, limit) {
   }
 }
 function createLogsRoutes() {
-  const app = new import_hono8.Hono();
+  const app = new import_hono10.Hono();
   app.get("/", (c) => {
     try {
       const sourceParam = (c.req.query("source") || "").toLowerCase();
@@ -4013,8 +4330,8 @@ function createLogsRoutes() {
 // src/api/routes/misc.routes.ts
 var import_node_child_process = require("child_process");
 var import_node_crypto2 = require("crypto");
-var import_hono9 = require("hono");
-var import_os5 = require("os");
+var import_hono11 = require("hono");
+var import_os6 = require("os");
 
 // src/config/update-config.ts
 var import_node_fs4 = require("fs");
@@ -4344,12 +4661,12 @@ function verifyWebhookSignature(body, header, secret) {
 }
 var clientLog = getLogger("client");
 var createMiscRoutes = (deps) => {
-  const app = new import_hono9.Hono();
+  const app = new import_hono11.Hono();
   app.get("/api/info", (c) => {
     const ptyIds = deps.ptyAttachedIds();
     return c.json({
       version: getVersion(),
-      machineName: (0, import_os5.hostname)(),
+      machineName: (0, import_os6.hostname)(),
       platform: process.platform,
       activeSessions: deps.sessionStore.list(ptyIds).filter((s) => s.status === "running").length,
       publicUrl: deps.publicUrl,
@@ -4475,11 +4792,11 @@ var createMiscRoutes = (deps) => {
 };
 
 // src/api/routes/pair.routes.ts
-var import_hono10 = require("hono");
+var import_hono12 = require("hono");
 var ALREADY_HANDLED3 = 597;
 var alreadyHandled3 = () => new Response(null, { status: ALREADY_HANDLED3 });
 var createPairRoutes = (deps) => {
-  const app = new import_hono10.Hono();
+  const app = new import_hono12.Hono();
   app.post("/start", (c) => {
     deps.handlePairStart(c.env.outgoing);
     return alreadyHandled3();
@@ -4492,11 +4809,11 @@ var createPairRoutes = (deps) => {
 };
 
 // src/api/routes/projects.routes.ts
-var import_hono11 = require("hono");
+var import_hono13 = require("hono");
 var ALREADY_HANDLED4 = 597;
 var alreadyHandled4 = () => new Response(null, { status: ALREADY_HANDLED4 });
 var createProjectRoutes = (deps) => {
-  const app = new import_hono11.Hono();
+  const app = new import_hono13.Hono();
   app.get("/", (c) => {
     const url = new URL(c.req.url);
     deps.handleListProjects(url, c.env.outgoing);
@@ -4511,7 +4828,7 @@ var createProjectRoutes = (deps) => {
 };
 
 // src/api/routes/providers.routes.ts
-var import_hono12 = require("hono");
+var import_hono14 = require("hono");
 
 // src/services/providers/providerHealth.ts
 var import_child_process3 = require("child_process");
@@ -4634,7 +4951,7 @@ async function providerHealth(name, resolveExe, detect = runVersion) {
 
 // src/api/routes/providers.routes.ts
 var createProviderRoutes = () => {
-  const app = new import_hono12.Hono();
+  const app = new import_hono14.Hono();
   app.get("/", async (c) => {
     const providers = await Promise.all([
       providerHealth(CLAUDE_CODE_PROVIDER, resolveClaudeExe),
@@ -4646,11 +4963,11 @@ var createProviderRoutes = () => {
 };
 
 // src/api/routes/scanner.routes.ts
-var import_hono13 = require("hono");
+var import_hono15 = require("hono");
 var ALREADY_HANDLED5 = 597;
 var alreadyHandled5 = () => new Response(null, { status: ALREADY_HANDLED5 });
 var createScannerRoutes = (deps) => {
-  const app = new import_hono13.Hono();
+  const app = new import_hono15.Hono();
   app.get("/api/search", async (c) => {
     const url = new URL(c.req.url);
     await deps.handleSearch(url, c.env.outgoing);
@@ -4660,11 +4977,11 @@ var createScannerRoutes = (deps) => {
 };
 
 // src/api/routes/sessions.routes.ts
-var import_hono14 = require("hono");
+var import_hono16 = require("hono");
 var ALREADY_HANDLED6 = 597;
 var alreadyHandled6 = () => new Response(null, { status: ALREADY_HANDLED6 });
 var createSessionRoutes = (deps) => {
-  const app = new import_hono14.Hono();
+  const app = new import_hono16.Hono();
   app.get("/count", (c) => {
     deps.handleSessionsCount(c.env.outgoing);
     return alreadyHandled6();
@@ -4739,9 +5056,9 @@ var createSessionRoutes = (deps) => {
 };
 
 // src/api/routes/ws.routes.ts
-var import_hono15 = require("hono");
+var import_hono17 = require("hono");
 var createWsRoutes = (deps, upgradeWebSocket) => {
-  const app = new import_hono15.Hono();
+  const app = new import_hono17.Hono();
   app.get(
     "/ws",
     upgradeWebSocket(() => {
@@ -4767,7 +5084,7 @@ var createWsRoutes = (deps, upgradeWebSocket) => {
 
 // src/api/app.ts
 var createHonoApp = (deps, upgradeWebSocket) => {
-  const app = new import_hono16.Hono();
+  const app = new import_hono18.Hono();
   const httpLog = getLogger("http");
   app.use("*", async (c, next) => {
     const start = Date.now();
@@ -4788,6 +5105,7 @@ var createHonoApp = (deps, upgradeWebSocket) => {
   app.use("*", authMiddleware(deps));
   app.onError(errorMiddleware);
   app.route("/healthz", createHealthRoutes(deps));
+  app.route("/api/diagnostics", createDiagnosticsRoutes(deps));
   app.route("/", createMiscRoutes(deps));
   app.route("/api/sessions", createSessionRoutes(deps));
   app.route("/api/conversations", createConversationRoutes(deps));
@@ -4796,6 +5114,7 @@ var createHonoApp = (deps, upgradeWebSocket) => {
   app.route("/api/projects", createProjectRoutes(deps));
   app.route("/api/providers", createProviderRoutes());
   app.route("/api/devices", createDeviceRoutes(deps));
+  app.route("/api/backup", createBackupRoutes(deps));
   app.route("/api/pair", createPairRoutes(deps));
   app.route("/api", createBrowseRoutes(deps));
   app.route("/", createScannerRoutes(deps));
@@ -4861,13 +5180,13 @@ async function createDirectory(parentAbsolutePath, name) {
 // src/conversation-cache.ts
 var import_scanner2 = require("@threadbase-sh/scanner");
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
-var import_fs9 = require("fs");
+var import_fs10 = require("fs");
 var import_promises3 = require("fs/promises");
 var import_path12 = require("path");
 var import_promises4 = require("timers/promises");
 
 // src/db/sqlite-migrate.ts
-var import_fs7 = require("fs");
+var import_fs8 = require("fs");
 var import_path10 = require("path");
 var import_url2 = require("url");
 var import_meta2 = {};
@@ -4877,6 +5196,9 @@ function getMigrationsDir2() {
   }
   return __dirname;
 }
+function resolveMigrationsDir(name = "migrations") {
+  return (0, import_path10.join)(getMigrationsDir2(), name);
+}
 var SCHEMA_MIGRATIONS_SQL = `
 CREATE TABLE IF NOT EXISTS schema_migrations (
   id TEXT PRIMARY KEY,
@@ -4885,8 +5207,8 @@ CREATE TABLE IF NOT EXISTS schema_migrations (
 `;
 function runSqliteMigrations(db, migrationsDir) {
   db.exec(SCHEMA_MIGRATIONS_SQL);
-  const dir = migrationsDir ?? (0, import_path10.join)(getMigrationsDir2(), "migrations");
-  const files = (0, import_fs7.readdirSync)(dir).filter((f) => f.endsWith(".sql")).sort();
+  const dir = migrationsDir ?? resolveMigrationsDir();
+  const files = (0, import_fs8.readdirSync)(dir).filter((f) => f.endsWith(".sql")).sort();
   const appliedRows = db.prepare("SELECT id FROM schema_migrations").all();
   const appliedSet = new Set(appliedRows.map((r) => r.id));
   const recordApplied = db.prepare("INSERT INTO schema_migrations (id, applied_at) VALUES (?, ?)");
@@ -4897,7 +5219,7 @@ function runSqliteMigrations(db, migrationsDir) {
       skipped.push(file);
       continue;
     }
-    const sql = (0, import_fs7.readFileSync)((0, import_path10.join)(dir, file), "utf-8");
+    const sql = (0, import_fs8.readFileSync)((0, import_path10.join)(dir, file), "utf-8");
     const tx = db.transaction(() => {
       db.exec(sql);
       recordApplied.run(file, (/* @__PURE__ */ new Date()).toISOString());
@@ -4909,7 +5231,7 @@ function runSqliteMigrations(db, migrationsDir) {
 }
 
 // src/services/conversations/isAgentConversation.ts
-var import_fs8 = require("fs");
+var import_fs9 = require("fs");
 var DEFAULT_AGENT_ENTRYPOINTS = /* @__PURE__ */ new Set(["sdk-cli", "claude-vscode"]);
 var CHUNK_BYTES = 64 * 1024;
 var ENTRYPOINT_PROBE = `"entrypoint":`;
@@ -4931,12 +5253,12 @@ function isAgentFile(filePath, entrypoints = DEFAULT_AGENT_ENTRYPOINTS) {
   if (cached2 !== void 0) return cached2;
   let fd;
   try {
-    fd = (0, import_fs8.openSync)(filePath, "r");
+    fd = (0, import_fs9.openSync)(filePath, "r");
   } catch {
     return false;
   }
   try {
-    const fileSize = (0, import_fs8.statSync)(filePath).size;
+    const fileSize = (0, import_fs9.statSync)(filePath).size;
     if (fileSize === 0) {
       fileDecisionCache.set(key, false);
       return false;
@@ -4947,7 +5269,7 @@ function isAgentFile(filePath, entrypoints = DEFAULT_AGENT_ENTRYPOINTS) {
     let carry = "";
     while (offset < fileSize) {
       const toRead = Math.min(CHUNK_BYTES, fileSize - offset);
-      const got = (0, import_fs8.readSync)(fd, buf, 0, toRead, offset);
+      const got = (0, import_fs9.readSync)(fd, buf, 0, toRead, offset);
       if (got <= 0) break;
       const chunk = carry + buf.toString("utf8", 0, got);
       for (const marker of markers) {
@@ -4968,7 +5290,7 @@ function isAgentFile(filePath, entrypoints = DEFAULT_AGENT_ENTRYPOINTS) {
   } catch {
     return false;
   } finally {
-    (0, import_fs8.closeSync)(fd);
+    (0, import_fs9.closeSync)(fd);
   }
 }
 function parseAgentEntrypointsEnv(raw) {
@@ -5543,7 +5865,7 @@ var ConversationCache = class _ConversationCache {
     if (!fileState) return null;
     let stat3;
     try {
-      stat3 = (0, import_fs9.statSync)(filePath);
+      stat3 = (0, import_fs10.statSync)(filePath);
     } catch {
       return null;
     }
@@ -5564,17 +5886,17 @@ var ConversationCache = class _ConversationCache {
     );
     if (rows.length === 0) return { messages: [], total, fromIndex: from };
     const messages = [];
-    const fd = (0, import_fs9.openSync)(filePath, "r");
+    const fd = (0, import_fs10.openSync)(filePath, "r");
     try {
       const state = (0, import_scanner2.createJsonlParseState)();
       for (const row of rows) {
         const buf = Buffer.alloc(row.byte_length);
-        (0, import_fs9.readSync)(fd, buf, 0, row.byte_length, row.byte_offset);
+        (0, import_fs10.readSync)(fd, buf, 0, row.byte_length, row.byte_offset);
         const msg = (0, import_scanner2.parseJsonlLine)(buf.toString("utf-8"), state);
         if (msg) messages.push(msg);
       }
     } finally {
-      (0, import_fs9.closeSync)(fd);
+      (0, import_fs10.closeSync)(fd);
     }
     return { messages, total, fromIndex: from };
   }
@@ -5602,14 +5924,14 @@ var ConversationCache = class _ConversationCache {
   isAgentFileCached(filePath) {
     let s;
     try {
-      s = (0, import_fs9.statSync)(filePath);
+      s = (0, import_fs10.statSync)(filePath);
     } catch {
       return false;
     }
     return this.classifyAgentFile(filePath, s.mtimeMs, s.size);
   }
   static open(dbPath, tailSize = 10, migrationsDir, options) {
-    (0, import_fs9.mkdirSync)((0, import_path12.dirname)(dbPath), { recursive: true });
+    (0, import_fs10.mkdirSync)((0, import_path12.dirname)(dbPath), { recursive: true });
     const db = new import_better_sqlite3.default(dbPath);
     db.pragma("journal_mode = WAL");
     db.pragma("foreign_keys = ON");
@@ -5796,7 +6118,7 @@ var ConversationCache = class _ConversationCache {
         let mtimeMs = null;
         let fileSize = null;
         try {
-          const s = (0, import_fs9.statSync)(m.filePath);
+          const s = (0, import_fs10.statSync)(m.filePath);
           mtimeMs = s.mtimeMs;
           fileSize = s.size;
         } catch {
@@ -5856,8 +6178,8 @@ var ConversationCache = class _ConversationCache {
     let fileSize;
     let fd;
     try {
-      fileSize = (0, import_fs9.statSync)(filePath).size;
-      fd = (0, import_fs9.openSync)(filePath, "r");
+      fileSize = (0, import_fs10.statSync)(filePath).size;
+      fd = (0, import_fs10.openSync)(filePath, "r");
     } catch {
       return false;
     }
@@ -5870,7 +6192,7 @@ var ConversationCache = class _ConversationCache {
       while (pos > 0 && lines.length < this.tailSize * 4) {
         const toRead = Math.min(CHUNK, pos);
         pos -= toRead;
-        (0, import_fs9.readSync)(fd, buf, 0, toRead, pos);
+        (0, import_fs10.readSync)(fd, buf, 0, toRead, pos);
         const chunk = buf.subarray(0, toRead).toString("utf8");
         const combined = chunk + partial;
         const parts = combined.split("\n");
@@ -5881,7 +6203,7 @@ var ConversationCache = class _ConversationCache {
       }
       if (partial) lines.push(partial);
     } finally {
-      (0, import_fs9.closeSync)(fd);
+      (0, import_fs10.closeSync)(fd);
     }
     const msgs = [];
     for (let i = 0; i < lines.length && msgs.length < this.tailSize; i++) {
@@ -6094,7 +6416,7 @@ var ConversationCache = class _ConversationCache {
    * `handleGetConversation` can still serve the cached tail even when the
    * JSONL has been deleted.
    */
-  pruneGhostFiles(exists = import_fs9.existsSync) {
+  pruneGhostFiles(exists = import_fs10.existsSync) {
     const rows = this.stmts.allFilePaths.all();
     const ghosts = [];
     const prune = this.db.transaction((ids) => {
@@ -6149,7 +6471,7 @@ var ConversationCache = class _ConversationCache {
    * Returns the removed IDs.
    */
   reconcileDeletions(livePaths, opts) {
-    const exists = opts?.exists ?? import_fs9.existsSync;
+    const exists = opts?.exists ?? import_fs10.existsSync;
     const rows = this.stmts.allFilePaths.all();
     const removed = [];
     const drop = this.db.transaction((ids) => {
@@ -6184,7 +6506,7 @@ var ConversationCache = class _ConversationCache {
    * reports drift for the CacheIntegrityMonitor to classify. `tailed` flags
    * rows that still have cached history (which pruneGhostFiles would keep).
    */
-  listMissingFiles(exists = import_fs9.existsSync) {
+  listMissingFiles(exists = import_fs10.existsSync) {
     const rows = this.stmts.allFilePathsWithTitle.all();
     const missing = [];
     for (const row of rows) {
@@ -6296,6 +6618,7 @@ var ManagedSessionsRepository = class {
   updateStatusStmt;
   getStmt;
   listNonTerminalStmt;
+  listRecoverableStmt;
   deleteStmt;
   constructor(db) {
     this.upsertStmt = db.prepare(`
@@ -6348,6 +6671,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. */
@@ -6399,6 +6729,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);
   }
@@ -6534,6 +6872,54 @@ var SessionsRepository = class {
   }
 };
 
+// src/db/runtime-store.ts
+var import_better_sqlite32 = __toESM(require("better-sqlite3"), 1);
+var RuntimeStore = class _RuntimeStore {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  static open(dbPath, migrationsDir) {
+    const db = new import_better_sqlite32.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;
@@ -6554,8 +6940,8 @@ async function recordUpload(pool2, instanceId, row) {
 }
 
 // src/handlers/handleListProjects.ts
-var import_fs10 = require("fs");
-var import_os6 = require("os");
+var import_fs11 = require("fs");
+var import_os7 = require("os");
 var import_path13 = require("path");
 function decodeProjectPath(dirName) {
   return dirName.replace(/-/g, "/");
@@ -6563,14 +6949,14 @@ function decodeProjectPath(dirName) {
 function handleListProjects(url, res) {
   const limit = Math.max(1, parseInt(url.searchParams.get("limit") ?? "50", 10) || 50);
   const offset = Math.max(0, parseInt(url.searchParams.get("offset") ?? "0", 10) || 0);
-  const projectsDir = (0, import_path13.join)((0, import_os6.homedir)(), ".claude", "projects");
+  const projectsDir = (0, import_path13.join)((0, import_os7.homedir)(), ".claude", "projects");
   let entries;
   try {
-    entries = (0, import_fs10.readdirSync)(projectsDir).map((dirName) => {
+    entries = (0, import_fs11.readdirSync)(projectsDir).map((dirName) => {
       const fullPath = (0, import_path13.join)(projectsDir, dirName);
       let mtime = 0;
       try {
-        mtime = (0, import_fs10.statSync)(fullPath).mtimeMs;
+        mtime = (0, import_fs11.statSync)(fullPath).mtimeMs;
       } catch {
       }
       const path = decodeProjectPath(dirName);
@@ -6685,19 +7071,19 @@ function setCacheMetadata(repo, key, value) {
 
 // src/services/cache-integrity/cacheIntegrityMonitor.ts
 var import_crypto9 = require("crypto");
-var import_fs13 = require("fs");
+var import_fs14 = require("fs");
 
 // src/services/cache-integrity/alertStore.ts
-var import_fs11 = require("fs");
-var import_os7 = require("os");
+var import_fs12 = require("fs");
+var import_os8 = require("os");
 var import_path14 = require("path");
 function alertStatePath() {
-  const dir = process.env.THREADBASE_CONFIG_DIR ?? (0, import_path14.join)((0, import_os7.homedir)(), ".threadbase");
+  const dir = process.env.THREADBASE_CONFIG_DIR ?? (0, import_path14.join)((0, import_os8.homedir)(), ".threadbase");
   return (0, import_path14.join)(dir, "cache-alert.json");
 }
 function loadAlertState() {
   try {
-    const parsed = JSON.parse((0, import_fs11.readFileSync)(alertStatePath(), "utf-8"));
+    const parsed = JSON.parse((0, import_fs12.readFileSync)(alertStatePath(), "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
     return {};
@@ -6705,13 +7091,13 @@ function loadAlertState() {
 }
 function saveAlertState(state) {
   const path = alertStatePath();
-  (0, import_fs11.mkdirSync)((0, import_path14.dirname)(path), { recursive: true });
-  (0, import_fs11.writeFileSync)(path, `${JSON.stringify(state, null, 2)}
+  (0, import_fs12.mkdirSync)((0, import_path14.dirname)(path), { recursive: true });
+  (0, import_fs12.writeFileSync)(path, `${JSON.stringify(state, null, 2)}
 `);
 }
 
 // src/services/cache-integrity/backup.ts
-var import_fs12 = require("fs");
+var import_fs13 = require("fs");
 var import_path15 = require("path");
 var DEFAULT_RETAIN = 3;
 function retainCount() {
@@ -6724,16 +7110,16 @@ function timestamp(d) {
 }
 async function backupCacheDb(db, cacheDir) {
   const backupsDir = (0, import_path15.join)(cacheDir, "backups");
-  (0, import_fs12.mkdirSync)(backupsDir, { recursive: true });
+  (0, import_fs13.mkdirSync)(backupsDir, { recursive: true });
   const destPath = (0, import_path15.join)(backupsDir, `cache-${timestamp(/* @__PURE__ */ new Date())}.db`);
   await db.backup(destPath);
   const retain = retainCount();
-  const backups = (0, import_fs12.readdirSync)(backupsDir).filter((f) => f.startsWith("cache-") && f.endsWith(".db")).map((f) => {
+  const backups = (0, import_fs13.readdirSync)(backupsDir).filter((f) => f.startsWith("cache-") && f.endsWith(".db")).map((f) => {
     const full = (0, import_path15.join)(backupsDir, f);
-    return { full, mtime: (0, import_fs12.statSync)(full).mtimeMs };
+    return { full, mtime: (0, import_fs13.statSync)(full).mtimeMs };
   }).sort((a, b) => b.mtime - a.mtime);
   for (const stale of backups.slice(retain)) {
-    if ((0, import_fs12.existsSync)(stale.full)) (0, import_fs12.unlinkSync)(stale.full);
+    if ((0, import_fs13.existsSync)(stale.full)) (0, import_fs13.unlinkSync)(stale.full);
   }
   return destPath;
 }
@@ -6830,7 +7216,7 @@ var CacheIntegrityMonitor = class {
    * the pending record, back up on high severity, and broadcast the alert.
    */
   async runDetection(detectedAt = (/* @__PURE__ */ new Date()).toISOString()) {
-    const all = this.cache.listMissingFiles(import_fs13.existsSync);
+    const all = this.cache.listMissingFiles(import_fs14.existsSync);
     const missing = all.filter((m) => !this.ignoredIds.has(m.id));
     if (missing.length === 0) {
       if (this._pending) {
@@ -6934,7 +7320,7 @@ var CacheIntegrityMonitor = class {
       case "prune_all": {
         await this.ensureBackup(pending);
         const backupPath = pending.backupPath;
-        const stillMissing = pending.missing.filter((m) => !(0, import_fs13.existsSync)(m.filePath)).map((m) => m.id);
+        const stillMissing = pending.missing.filter((m) => !(0, import_fs14.existsSync)(m.filePath)).map((m) => m.id);
         const pruned = this.cache.dropRowsById(stillMissing);
         this.applyDeferredUnlinks();
         this.clearPending();
@@ -6996,7 +7382,7 @@ var CacheIntegrityMonitor = class {
 
 // src/services/conversations/conversationWatcher.ts
 var import_chokidar = __toESM(require("chokidar"), 1);
-var import_fs14 = require("fs");
+var import_fs15 = require("fs");
 var import_promises5 = require("fs/promises");
 var ConversationWatcher = class {
   files = /* @__PURE__ */ new Map();
@@ -7022,7 +7408,7 @@ var ConversationWatcher = class {
     if (this.files.has(key)) return;
     let offset;
     try {
-      offset = (0, import_fs14.statSync)(filePath).size;
+      offset = (0, import_fs15.statSync)(filePath).size;
     } catch {
       offset = 0;
     }
@@ -7204,14 +7590,14 @@ function findSearchTarget(messages, query) {
 }
 
 // src/services/conversations/pruneAgentConversations.ts
-var import_fs15 = require("fs");
+var import_fs16 = require("fs");
 function pruneAgentConversations(cache) {
   const db = cache.getDatabase();
   const rows = db.prepare("SELECT id, file_path FROM conversation_meta").all();
   let pruned = 0;
   let missing = 0;
   for (const row of rows) {
-    if (!(0, import_fs15.existsSync)(row.file_path)) {
+    if (!(0, import_fs16.existsSync)(row.file_path)) {
       missing += 1;
       continue;
     }
@@ -7312,22 +7698,22 @@ function refreshConversationCache(deps) {
 }
 
 // src/services/conversations/shouldRefreshProjectsFromHdd.ts
-var import_fs16 = require("fs");
-var import_os8 = require("os");
+var import_fs17 = require("fs");
+var import_os9 = require("os");
 var import_path16 = require("path");
-var DEFAULT_PROJECTS_DIR = (0, import_path16.join)((0, import_os8.homedir)(), ".claude", "projects");
+var DEFAULT_PROJECTS_DIR = (0, import_path16.join)((0, import_os9.homedir)(), ".claude", "projects");
 function maxProjectsTreeMtimeMs(projectsDir) {
   let maxMs;
   try {
-    maxMs = (0, import_fs16.statSync)(projectsDir).mtimeMs;
+    maxMs = (0, import_fs17.statSync)(projectsDir).mtimeMs;
   } catch {
     return null;
   }
   try {
-    for (const ent of (0, import_fs16.readdirSync)(projectsDir, { withFileTypes: true })) {
+    for (const ent of (0, import_fs17.readdirSync)(projectsDir, { withFileTypes: true })) {
       if (!ent.isDirectory()) continue;
       try {
-        const childMs = (0, import_fs16.statSync)((0, import_path16.join)(projectsDir, ent.name)).mtimeMs;
+        const childMs = (0, import_fs17.statSync)((0, import_path16.join)(projectsDir, ent.name)).mtimeMs;
         if (childMs > maxMs) maxMs = childMs;
       } catch {
       }
@@ -7551,7 +7937,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 {
@@ -7564,14 +7951,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.
    *
@@ -7579,34 +7969,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",
@@ -7616,14 +7994,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 open2 = this.openActivity.get(session.id);
+    if (!open2 || open2.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
+    });
+    open2.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
     });
@@ -7637,9 +8058,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);
   }
 };
 
@@ -7870,7 +8291,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({
@@ -7930,7 +8352,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
@@ -8088,8 +8511,90 @@ function resolveAnswer(pending, body) {
   }
 }
 
+// src/services/search/searchQuery.ts
+var DEFAULT_SEARCH_LIMIT = 50;
+var MAX_SEARCH_LIMIT = 200;
+var MAX_QUERY_LENGTH = 256;
+var SearchQueryError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+function intOr(raw, fallback) {
+  if (raw === null) return fallback;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) ? n : fallback;
+}
+function parseSearchQuery(params) {
+  const q = (params.get("q") ?? "").trim();
+  if (!q) {
+    throw new SearchQueryError("Missing query parameter: q", "invalid_query");
+  }
+  if (q.length > MAX_QUERY_LENGTH) {
+    throw new SearchQueryError(`Query exceeds ${MAX_QUERY_LENGTH} characters`, "query_too_long");
+  }
+  const limit = Math.min(
+    Math.max(intOr(params.get("limit"), DEFAULT_SEARCH_LIMIT), 1),
+    MAX_SEARCH_LIMIT
+  );
+  const offset = Math.max(intOr(params.get("offset"), 0), 0);
+  const filters = {};
+  const provider = params.get("provider");
+  if (provider !== null) {
+    if (!isProviderName(provider)) {
+      throw new SearchQueryError(`Unknown provider: ${provider}`, "invalid_filter");
+    }
+    filters.provider = provider;
+  }
+  const projectPath = params.get("projectPath");
+  if (projectPath) filters.projectPath = projectPath;
+  const branch = params.get("branch");
+  if (branch) filters.branch = branch;
+  for (const [key, field] of [
+    ["since", "since"],
+    ["until", "until"]
+  ]) {
+    const raw = params.get(key);
+    if (raw === null) continue;
+    const ms = Date.parse(raw);
+    if (Number.isNaN(ms)) {
+      throw new SearchQueryError(`Invalid ${key}: expected an ISO 8601 date`, "invalid_filter");
+    }
+    filters[field] = ms;
+  }
+  if (filters.since != null && filters.until != null && filters.since > filters.until) {
+    throw new SearchQueryError("`since` must not be after `until`", "invalid_filter");
+  }
+  return { q, limit, offset, filters };
+}
+function applyFilters(results, filters) {
+  return results.filter((r) => {
+    if (filters.provider && r.provider !== filters.provider) return false;
+    if (filters.projectPath && r.projectPath !== filters.projectPath) return false;
+    if (filters.branch && r.branch !== filters.branch) return false;
+    if (filters.since != null || filters.until != null) {
+      const ts = r.lastActivity == null ? Number.NaN : new Date(r.lastActivity).getTime();
+      if (Number.isNaN(ts)) return false;
+      if (filters.since != null && ts < filters.since) return false;
+      if (filters.until != null && ts > filters.until) return false;
+    }
+    return true;
+  });
+}
+function paginate(results, offset, limit) {
+  const items = results.slice(offset, offset + limit);
+  return {
+    items,
+    total: results.length,
+    offset,
+    hasMore: offset + items.length < results.length
+  };
+}
+
 // src/services/sessions/conversationBusy.ts
-var import_fs17 = require("fs");
+var import_fs18 = require("fs");
 var RESUME_BUSY_WINDOW_MS = 12e4;
 function resolveResumeBusyWindowMs(env = process.env) {
   const raw = env.THREADBASE_RESUME_BUSY_WINDOW_MS;
@@ -8106,7 +8611,7 @@ function conversationBusy(input) {
   let lastActivityMs = null;
   if (input.jsonlPath) {
     try {
-      const mtimeMs = (0, import_fs17.statSync)(input.jsonlPath).mtimeMs;
+      const mtimeMs = (0, import_fs18.statSync)(input.jsonlPath).mtimeMs;
       const age = now - mtimeMs;
       lastActivityMs = Math.max(0, age);
       const isSelfEcho = input.selfPtyEndedAt != null && mtimeMs <= input.selfPtyEndedAt + SELF_ACTIVITY_SKEW_MS;
@@ -8235,6 +8740,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/types.ts
 function confidenceForSource(source) {
   return source === "timeout-fallback" || source === "quiet-fallback" ? "inferred" : "observed";
@@ -8382,14 +8931,15 @@ function managedToResponse(s, 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" : s.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" : s.rehydrated ? "resumable" : s.failureReason != null ? "failed" : "completed",
+    lifecycleSource: ptyAttached ? "spawn" : s.rehydrated ? "reconcile" : "exit",
     // We spawned it, so `status` is the authoritative signal — no inferred
     // `activity` is attached for managed sessions.
-    ownership: "managed",
+    ownership: s.rehydrated ? "historical" : "managed",
     projectPath: s.projectPath,
     projectName: s.projectName,
     branch: s.branch,
@@ -8790,6 +9340,8 @@ var DEFAULT_PTY_GRACE_PERIOD_MS = 27e4;
 var GRACE_MAX_DEFERS = 4;
 var IDLE_REAP_AFTER_MS = 6 * 60 * 60 * 1e3;
 var IDLE_REAP_SWEEP_MS = 5 * 60 * 1e3;
+var SEARCH_OVERFETCH = 4;
+var SEARCH_MAX_SCAN = 1e3;
 var RESUME_DISCOVERY_TIMEOUT_MS = 750;
 var DISCOVERY_TTL_MS = 15e3;
 var ADOPT_KILL_TIMEOUT_MS = 5e3;
@@ -8977,10 +9529,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_crypto11.randomUUID)();
@@ -8999,6 +9554,7 @@ var StreamerServer = class {
   liveActivityRenewal = null;
   discoveryCache = null;
   cacheDir;
+  runtimeDbPath;
   tailSize;
   directoryDebounceMs;
   // Trailing-debounced trigger that flags the scanner stale after a quiet
@@ -9030,7 +9586,7 @@ var StreamerServer = class {
     this.skipStartupWarmup = config.skipStartupWarmup ?? false;
     this.scannerPersistenceDisabled = config.scannerPersistent === false;
     this.scanProfiles = config.scanProfiles;
-    this.codexRoots = config.codexRoots ?? [(0, import_path18.join)((0, import_os9.homedir)(), ".codex", "sessions")];
+    this.codexRoots = config.codexRoots ?? [(0, import_path18.join)((0, import_os10.homedir)(), ".codex", "sessions")];
     this.ptyGracePeriodMs = config.ptyGracePeriodMs ?? DEFAULT_PTY_GRACE_PERIOD_MS;
     this.defaultSystemPrompt = config.defaultSystemPrompt ?? DEFAULT_SYSTEM_PROMPT;
     this.featureFlags = resolveFeatureFlags({ cli: config.featureFlags, yaml: loadFeatureFlags() });
@@ -9044,7 +9600,8 @@ var StreamerServer = class {
     this.claudeFlagsPersistable = config.claudeFlags === void 0;
     this.claudeFlags = config.claudeFlags ?? loadClaudeFlags();
     this.claudeExtraArgs = config.claudeExtraArgs ?? loadClaudeExtraArgs();
-    this.cacheDir = config.cacheDir ?? loadCacheDir() ?? (0, import_path18.join)((0, import_os9.homedir)(), ".threadbase", "cache");
+    this.cacheDir = config.cacheDir ?? loadCacheDir() ?? (0, import_path18.join)((0, import_os10.homedir)(), ".threadbase", "cache");
+    this.runtimeDbPath = config.runtimeDbPath ?? process.env.THREADBASE_RUNTIME_DB ?? (0, import_path18.join)(process.env.THREADBASE_CONFIG_DIR ?? (0, import_path18.join)((0, import_os10.homedir)(), ".threadbase"), "runtime.db");
     this.tailSize = config.tailSize ?? loadTailSize() ?? 10;
     this.directoryDebounceMs = parseDirScanDebounceEnv(process.env.THREADBASE_DIR_SCAN_DEBOUNCE_MS) ?? config.directoryScanDebounceMs ?? 1e3;
     this.markScannerStaleDebounced = debounce(() => {
@@ -9095,7 +9652,7 @@ var StreamerServer = class {
           const seqs = cache.extendMessageIndex(
             filePath,
             spans,
-            (0, import_fs18.statSync)(filePath),
+            (0, import_fs19.statSync)(filePath),
             readFrom,
             endOffset
           );
@@ -9215,6 +9772,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,
@@ -9269,7 +9827,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);
       }
     });
@@ -9320,6 +9878,7 @@ var StreamerServer = class {
       conversationsRepo: () => this.conversationsRepo,
       sessionsRepo: () => this.sessionsRepo,
       cacheMetadataRepo: () => this.cacheMetadataRepo,
+      runtimeStore: () => this.runtimeStore,
       ptyAttachedIds: () => this.ptyAttachedIds(),
       handleListSessions: (url, res) => this.handleListSessions(url, res),
       handleSessionsCount: (res) => this.handleSessionsCount(res),
@@ -9558,14 +10117,14 @@ var StreamerServer = class {
     }
     this.apnsClient = new ApnsClient(creds);
     const sender = new LiveActivitySender(this.apnsClient, pushRepo);
-    const serverId = process.env.THREADBASE_INSTANCE_ID ?? (0, import_os9.hostname)();
-    this.liveActivityNotifier = new LiveActivityNotifier(sender, serverId, (0, import_os9.hostname)());
+    const serverId = process.env.THREADBASE_INSTANCE_ID ?? (0, import_os10.hostname)();
+    this.liveActivityNotifier = new LiveActivityNotifier(sender, serverId, (0, import_os10.hostname)());
     this.liveActivityRenewal = new LiveActivityRenewalScheduler({
       repo: pushRepo,
       sender,
       sessionStore: this.sessionStore,
       serverId,
-      serverLabel: (0, import_os9.hostname)()
+      serverLabel: (0, import_os10.hostname)()
     });
     this.liveActivityRenewal.start();
     this.log.info("Live Activity push enabled", {
@@ -9619,6 +10178,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((v) => [v.sessionId, v.lifecycle]));
+      let rehydrated = 0;
+      for (const row of candidates) {
+        if (this.sessionStore.getManaged(row.session_id)) continue;
+        if (!shouldRehydrate(row, { now, projectExists: import_fs19.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.
@@ -9852,6 +10463,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_path18.join)(this.cacheDir, "cache.db"),
@@ -9879,8 +10501,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);
@@ -9904,7 +10538,7 @@ var StreamerServer = class {
             this.fileWatcher.watchDirectory(dir);
           }
           for (const dir of this.codexRoots) {
-            if (!(0, import_fs18.existsSync)(dir)) continue;
+            if (!(0, import_fs19.existsSync)(dir)) continue;
             this.fileWatcher.watchDirectory(dir);
           }
         } catch (err) {
@@ -9916,6 +10550,7 @@ var StreamerServer = class {
           );
           this.scannerPersistenceDisabled = true;
         }
+        void this.reconcilePreviousSessions().then((v) => this.rehydratePreviousSessions(v));
         if (this.skipStartupWarmup) {
           this.log.debug?.("startup warm-up scan skipped (skipStartupWarmup)", {
             event: "cache.warmup_skipped"
@@ -10123,6 +10758,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();
@@ -10177,7 +10813,7 @@ var StreamerServer = class {
     }
     let body;
     try {
-      body = await readBody(req);
+      body = await readBody2(req);
     } catch (err) {
       const message = err instanceof Error ? err.message : "Invalid body";
       json(res, 400, { error: message });
@@ -10223,7 +10859,7 @@ var StreamerServer = class {
       nonce: sealed.nonce,
       ephemeralPublicKey: sealed.ephemeralPublicKey,
       publicUrl: this.publicUrl,
-      machineName: (0, import_os9.hostname)(),
+      machineName: (0, import_os10.hostname)(),
       ...device && {
         deviceId: device.deviceId,
         deviceToken: device.deviceToken,
@@ -10351,7 +10987,7 @@ var StreamerServer = class {
     if (this.scanProfiles && this.scanProfiles.length > 0) {
       return this.scanProfiles.filter((p) => p.enabled).map((p) => (0, import_path18.join)(p.configDir, "projects"));
     }
-    return [(0, import_path18.join)((0, import_os9.homedir)(), ".claude", "projects")];
+    return [(0, import_path18.join)((0, import_os10.homedir)(), ".claude", "projects")];
   }
   /**
    * Full-glob scan + cache upsert/delete reconcile. Used by ?refresh=1 and by
@@ -10570,7 +11206,8 @@ var StreamerServer = class {
   }
   handleSessionsCount(res) {
     if (this.rejectIfWarmingUp(res)) return;
-    json(res, 200, { total: this.sessionStore.list(this.ptyAttachedIds()).length });
+    const total = this.sessionStore.list(this.ptyAttachedIds()).filter((s) => s.ownership !== "historical").length;
+    json(res, 200, { total });
   }
   handleGetRecentSessions(url, res) {
     if (this.rejectIfWarmingUp(res)) return;
@@ -10753,20 +11390,20 @@ var StreamerServer = class {
     if (this.scanProfiles && this.scanProfiles.length > 0) {
       return this.scanProfiles.filter((p) => p.enabled).map((p) => (0, import_path18.join)(p.configDir, "projects"));
     }
-    return [(0, import_path18.join)((0, import_os9.homedir)(), ".claude", "projects")];
+    return [(0, import_path18.join)((0, import_os10.homedir)(), ".claude", "projects")];
   }
   findJsonlPath(uuid) {
     const filename = `${uuid}.jsonl`;
     for (const projectsDir of this.projectsDirs()) {
-      if (!(0, import_fs18.existsSync)(projectsDir)) continue;
-      for (const dir of (0, import_fs18.readdirSync)(projectsDir)) {
+      if (!(0, import_fs19.existsSync)(projectsDir)) continue;
+      for (const dir of (0, import_fs19.readdirSync)(projectsDir)) {
         const fp = (0, import_path18.join)(projectsDir, dir, filename);
-        if ((0, import_fs18.existsSync)(fp)) return fp;
+        if ((0, import_fs19.existsSync)(fp)) return fp;
         const projectDir = (0, import_path18.join)(projectsDir, dir);
         try {
-          for (const sub of (0, import_fs18.readdirSync)(projectDir)) {
+          for (const sub of (0, import_fs19.readdirSync)(projectDir)) {
             const subagentPath = (0, import_path18.join)(projectDir, sub, "subagents", filename);
-            if ((0, import_fs18.existsSync)(subagentPath)) return subagentPath;
+            if ((0, import_fs19.existsSync)(subagentPath)) return subagentPath;
           }
         } catch {
         }
@@ -10776,7 +11413,7 @@ var StreamerServer = class {
   }
   async readCwdFromJsonl(filePath) {
     return new Promise((resolve2) => {
-      const rl = (0, import_readline.createInterface)({ input: (0, import_fs18.createReadStream)(filePath), crlfDelay: Infinity });
+      const rl = (0, import_readline.createInterface)({ input: (0, import_fs19.createReadStream)(filePath), crlfDelay: Infinity });
       let found = false;
       rl.on("line", (line) => {
         if (found) return;
@@ -10866,7 +11503,7 @@ var StreamerServer = class {
     if (this.isManagedTailPath(key)) return;
     let mtimeMs;
     try {
-      mtimeMs = (0, import_fs18.statSync)(filePath).mtimeMs;
+      mtimeMs = (0, import_fs19.statSync)(filePath).mtimeMs;
     } catch {
       return;
     }
@@ -11048,7 +11685,7 @@ var StreamerServer = class {
     if (!conv.filePath) return false;
     let mtimeMs = null;
     try {
-      mtimeMs = (0, import_fs18.statSync)(conv.filePath).mtimeMs;
+      mtimeMs = (0, import_fs19.statSync)(conv.filePath).mtimeMs;
     } catch {
       return false;
     }
@@ -11303,7 +11940,7 @@ var StreamerServer = class {
     }
     let body;
     try {
-      body = await readBody(req);
+      body = await readBody2(req);
     } catch {
       res.setHeader("Accept-Query", "application/json");
       json(res, 422, { error: "Malformed JSON body", code: "invalid_query" });
@@ -11341,17 +11978,27 @@ var StreamerServer = class {
     });
   }
   async handleSearch(url, res) {
-    const q = url.searchParams.get("q") ?? "";
-    if (!q) {
-      json(res, 400, { error: "Missing query parameter: q" });
-      return;
+    let parsed;
+    try {
+      parsed = parseSearchQuery(url.searchParams);
+    } catch (err) {
+      if (err instanceof SearchQueryError) {
+        json(res, 400, { error: err.message, code: err.code });
+        return;
+      }
+      throw err;
     }
-    const limit = intParam(url, "limit", 50);
+    const { q, limit, offset, filters } = parsed;
+    const startedAt = Date.now();
     const scanner = await this.getScanner();
     const results = await (0, import_scanner3.search)(
       q,
       {
-        limit,
+        // Fetch beyond the requested page: filters below are applied AFTER the
+        // scanner returns, so slicing at `limit` here would drop results that a
+        // later page should contain. Bounded so a broad query cannot pull an
+        // unbounded set into memory.
+        limit: Math.min(offset + limit * SEARCH_OVERFETCH, SEARCH_MAX_SCAN),
         include: "conversations",
         ...this.scanProfiles ? { profiles: this.scanProfiles } : {},
         ...this.codexScanOpts()
@@ -11375,13 +12022,24 @@ var StreamerServer = class {
       lastActivity: r.meta.timestamp,
       firstMessage: r.meta.firstMessage ?? void 0,
       lastMessage: r.meta.lastMessage ?? void 0,
-      provider: r.meta.provider ?? CLAUDE_CODE_PROVIDER
+      provider: r.meta.provider ?? CLAUDE_CODE_PROVIDER,
+      // The scanner already computes relevance and match snippets; the previous
+      // adapter discarded both, so results arrived in an unexplained order with
+      // no indication of WHY anything matched.
+      score: r.score,
+      matches: Array.isArray(r.matches) ? r.matches.map((m) => ({
+        field: m.field,
+        snippet: m.snippet
+      })) : []
     }));
+    const page = paginate(applyFilters(adapted, filters), offset, limit);
     json(res, 200, {
-      conversations: adapted,
-      hasMore: false,
-      offset: 0,
-      total: adapted.length
+      conversations: page.items,
+      hasMore: page.hasMore,
+      offset: page.offset,
+      total: page.total,
+      // Query timing, so a slow search is diagnosable rather than merely felt.
+      tookMs: Date.now() - startedAt
     });
   }
   async handleListSessions(url, res) {
@@ -11427,7 +12085,7 @@ var StreamerServer = class {
     if (this.rejectIfWarmingUp(res)) return;
     const session = this.sessionStore.get(sessionId, this.ptyAttachedIds());
     if (session) {
-      if (!(0, import_fs18.existsSync)(session.projectPath)) {
+      if (!(0, import_fs19.existsSync)(session.projectPath)) {
         session.failureReason = `Project directory not found: ${session.projectPath}`;
       }
       const reconciled = this.withReconciledLifecycle([session])[0];
@@ -11454,7 +12112,7 @@ var StreamerServer = class {
     json(res, 404, { error: "Session not found" });
   }
   async handleResume(req, res) {
-    const body = await readBody(req);
+    const body = await readBody2(req);
     const sessionId = body.sessionId ?? body.conversationId;
     if (!sessionId) {
       json(res, 400, { error: "Missing sessionId" });
@@ -11586,7 +12244,7 @@ var StreamerServer = class {
       return;
     }
     if (this.agentConfig.enabled) {
-      const body2 = await readBody(req);
+      const body2 = await readBody2(req);
       const cache = this.cache;
       if (!cache) {
         json(res, 503, {
@@ -11605,7 +12263,7 @@ var StreamerServer = class {
       json(res, result.status, result.body);
       return;
     }
-    const body = await readBody(req);
+    const body = await readBody2(req);
     const { input, keys } = body;
     let idempotencyKey;
     try {
@@ -11769,7 +12427,7 @@ var StreamerServer = class {
     });
   }
   async handleSendAnswer(sessionId, req, res) {
-    const body = await readBody(req);
+    const body = await readBody2(req);
     const pending = this.pendingQuestions.get(sessionId);
     const resolution = resolveAnswer(pending, body);
     if (!resolution.ok) {
@@ -11798,7 +12456,7 @@ var StreamerServer = class {
       json(res, 400, { error: "Session has no project path" });
       return;
     }
-    const body = await readBody(req);
+    const body = await readBody2(req);
     const { filename, mimeType, dataBase64 } = body ?? {};
     if (typeof filename !== "string" || typeof mimeType !== "string" || typeof dataBase64 !== "string") {
       json(res, 400, { error: "Missing filename, mimeType, or dataBase64" });
@@ -12000,7 +12658,7 @@ var StreamerServer = class {
       return;
     }
     if (this.agentConfig.enabled) {
-      const body2 = await readBody(req);
+      const body2 = await readBody2(req);
       const result = await handleStartAgentSession(body2, {
         sessionStore: this.sessionStore,
         // biome-ignore lint/style/noNonNullAssertion: agentClient is set when agentConfig.enabled is true
@@ -12014,7 +12672,7 @@ var StreamerServer = class {
       }
       return;
     }
-    const body = await readBody(req);
+    const body = await readBody2(req);
     const { path: relativePath, provider: requestedProvider, systemPrompt: clientPrompt } = body;
     if (requestedProvider !== void 0 && !isProviderName(requestedProvider)) {
       json(res, 400, { error: "Invalid provider" });
@@ -12151,7 +12809,7 @@ var StreamerServer = class {
   // file isn't slurped in full.
   readFirstLineSessionId(filePath) {
     try {
-      const content = (0, import_fs18.readFileSync)(filePath, "utf8");
+      const content = (0, import_fs19.readFileSync)(filePath, "utf8");
       const nl = content.indexOf("\n");
       const firstLine = nl === -1 ? content : content.slice(0, nl);
       if (!firstLine.trim()) return null;
@@ -12166,7 +12824,7 @@ var StreamerServer = class {
   // was passed to Claude via --session-id so the filename matches from the start.
   watchForJsonl(sessionId, projectPath) {
     const encoded = projectPath.replace(/[/\\:.]/g, "-");
-    const projectsDir = (0, import_path18.join)((0, import_os9.homedir)(), ".claude", "projects", encoded);
+    const projectsDir = (0, import_path18.join)((0, import_os10.homedir)(), ".claude", "projects", encoded);
     const expectedFile = `${sessionId}.jsonl`;
     const filePath = (0, import_path18.join)(projectsDir, expectedFile);
     const deadline = Date.now() + 12e4;
@@ -12186,11 +12844,11 @@ var StreamerServer = class {
         cleanup();
         return;
       }
-      let resolvedFilePath = (0, import_fs18.existsSync)(filePath) ? filePath : null;
-      if (!resolvedFilePath && (0, import_fs18.existsSync)(projectsDir)) {
+      let resolvedFilePath = (0, import_fs19.existsSync)(filePath) ? filePath : null;
+      if (!resolvedFilePath && (0, import_fs19.existsSync)(projectsDir)) {
         try {
           const now = Date.now();
-          const match = (0, import_fs18.readdirSync)(projectsDir).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, mtime: (0, import_fs18.statSync)((0, import_path18.join)(projectsDir, f)).mtimeMs })).filter(({ mtime }) => now - mtime < 5e3).filter(
+          const match = (0, import_fs19.readdirSync)(projectsDir).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, mtime: (0, import_fs19.statSync)((0, import_path18.join)(projectsDir, f)).mtimeMs })).filter(({ mtime }) => now - mtime < 5e3).filter(
             ({ f }) => (0, import_path18.basename)(f, ".jsonl") === sessionId || this.readFirstLineSessionId((0, import_path18.join)(projectsDir, f)) === sessionId
           ).sort((a, b) => b.mtime - a.mtime)[0];
           if (match) resolvedFilePath = (0, import_path18.join)(projectsDir, match.f);
@@ -12201,7 +12859,7 @@ var StreamerServer = class {
       cleanup();
       this.sessionFileMap.set(sessionId, resolvedFilePath);
       try {
-        const existing = (0, import_fs18.readFileSync)(resolvedFilePath, "utf8").split("\n").filter(Boolean);
+        const existing = (0, import_fs19.readFileSync)(resolvedFilePath, "utf8").split("\n").filter(Boolean);
         if (existing.length > 0) {
           this.broadcastConversationLines(sessionId, existing);
         }
@@ -12225,7 +12883,7 @@ var StreamerServer = class {
     if (this.sessionFileMap.has(sessionId)) return;
     try {
       require("fs").mkdirSync(projectsDir, { recursive: true });
-      watcher = (0, import_fs18.watch)(projectsDir, tryWire);
+      watcher = (0, import_fs19.watch)(projectsDir, tryWire);
       watcher.on("error", cleanup);
     } catch {
     }
@@ -12254,7 +12912,7 @@ var StreamerServer = class {
     };
     const matchesProjectPath = (candidatePath) => {
       try {
-        const firstLine = (0, import_fs18.readFileSync)(candidatePath, "utf8").split("\n", 1)[0];
+        const firstLine = (0, import_fs19.readFileSync)(candidatePath, "utf8").split("\n", 1)[0];
         if (!firstLine) return null;
         const parsed = JSON.parse(firstLine);
         if (parsed?.type !== "session_meta") return null;
@@ -12283,15 +12941,15 @@ var StreamerServer = class {
       );
       for (const root of this.codexRoots) {
         const sessionsDir = (0, import_path18.join)(root, dateDir);
-        if (!(0, import_fs18.existsSync)(sessionsDir)) continue;
+        if (!(0, import_fs19.existsSync)(sessionsDir)) continue;
         let candidateFiles;
         try {
-          candidateFiles = (0, import_fs18.readdirSync)(sessionsDir).filter((f) => f.endsWith(".jsonl"));
+          candidateFiles = (0, import_fs19.readdirSync)(sessionsDir).filter((f) => f.endsWith(".jsonl"));
         } catch {
           continue;
         }
         const nowMs = Date.now();
-        const recentCandidates = candidateFiles.map((f) => ({ f, mtime: (0, import_fs18.statSync)((0, import_path18.join)(sessionsDir, f)).mtimeMs })).filter(({ mtime }) => nowMs - mtime < 1e4).sort((a, b) => b.mtime - a.mtime);
+        const recentCandidates = candidateFiles.map((f) => ({ f, mtime: (0, import_fs19.statSync)((0, import_path18.join)(sessionsDir, f)).mtimeMs })).filter(({ mtime }) => nowMs - mtime < 1e4).sort((a, b) => b.mtime - a.mtime);
         for (const { f } of recentCandidates) {
           const candidatePath = (0, import_path18.join)(sessionsDir, f);
           const match = matchesProjectPath(candidatePath);
@@ -12303,7 +12961,7 @@ var StreamerServer = class {
           this.sessionFileMap.set(sessionId, candidatePath);
           this.fileWatcher.watch(candidatePath);
           try {
-            const existing = (0, import_fs18.readFileSync)(candidatePath, "utf8").split("\n").filter(Boolean);
+            const existing = (0, import_fs19.readFileSync)(candidatePath, "utf8").split("\n").filter(Boolean);
             if (existing.length > 0) {
               this.broadcastConversationLines(sessionId, existing);
             }
@@ -12372,7 +13030,7 @@ var StreamerServer = class {
       });
       return;
     }
-    const body = await readBody(req);
+    const body = await readBody2(req);
     const { path: relativePath, name } = body;
     if (!name || typeof name !== "string") {
       json(res, 400, { error: "Missing name field" });
@@ -12402,7 +13060,7 @@ var StreamerServer = class {
     }
     let parsed;
     try {
-      parsed = await readBody(req);
+      parsed = await readBody2(req);
     } catch {
       json(res, 400, { error: "Invalid JSON" });
       return;
@@ -12459,7 +13117,7 @@ var StreamerServer = class {
     }
     let parsed;
     try {
-      parsed = await readBody(req);
+      parsed = await readBody2(req);
     } catch {
       json(res, 400, { error: "Invalid JSON" });
       return;
@@ -12518,7 +13176,7 @@ async function waitForProcessExit(pid, timeoutMs, pollMs = ADOPT_KILL_POLL_MS) {
 }
 function classifyResumability(cwd) {
   if (!cwd) return { resumable: true };
-  if ((0, import_fs18.existsSync)(cwd)) return { resumable: true };
+  if ((0, import_fs19.existsSync)(cwd)) return { resumable: true };
   const ranInWorktree = /\/\.worktrees\//.test(cwd) || /\/\.claude\/worktrees\//.test(cwd);
   return {
     resumable: false,
@@ -12636,7 +13294,7 @@ function parseSessionListQuery(url) {
   const cursor = url.searchParams.get("cursor") ?? void 0;
   return { query: { limit, sortBy, order, status, cursor } };
 }
-function readBody(req) {
+function readBody2(req) {
   return new Promise((resolve2, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));