@threadbase-sh/streamer 1.33.0 → 1.35.0

package/dist/index.js

@@ -2208,6 +2208,14 @@ var PTYManager = class {
     if (session?.status !== "running") return;
     if (this.pendingReady.has(sessionId)) {
       this.markReady(sessionId, session, "quiet:timeout");
+    } else {
+      this.recheckReadyFromScreen(sessionId).catch((err) => {
+        this.log.warn("[pty.ready] screen recheck failed", {
+          event: "pty.ready_recheck_failed",
+          sessionId,
+          err
+        });
+      });
     }
     this.detectLivePrompts(sessionId, "", session.lastOutput).catch((err) => {
       this.log.warn("[pty.prompt_detect] failed", {
@@ -2217,6 +2225,20 @@ var PTYManager = class {
       });
     });
   }
+  // Re-check the rendered screen (not just the last chunk) for a prompt
+  // marker. Only meaningful once pendingReady is already clear — the boot
+  // fallback above covers the first prompt after spawn/resume. Scoped to a
+  // full viewport (PTY_ROWS), not just the last few lines: "on screen" means
+  // whatever a user attached to this PTY would currently see.
+  async recheckReadyFromScreen(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (session?.status !== "running") return;
+    const lines = await this.getOutputLines(sessionId, PTY_ROWS2);
+    const matchedMarker = CLAUDE_PROMPT_MARKERS.find((m) => lines.some((l) => l.includes(m)));
+    if (matchedMarker && session.status === "running") {
+      this.markReady(sessionId, session, `quiet:screen-marker:${matchedMarker}`);
+    }
+  }
   // 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, reason) {
@@ -2389,6 +2411,44 @@ async function discoverClaudeProcesses() {
   if (platform2() === "win32") return discoverWindows();
   return discoverUnix();
 }
+var CLAUDE_CLI_SCRIPT = /claude-code[\\/](?:cli|index)\.(?:js|mjs|cjs)$/i;
+var JS_RUNTIMES = /* @__PURE__ */ new Set(["node", "node.exe", "bun", "bun.exe", "deno", "deno.exe"]);
+function tokenizeCommandLine(commandLine) {
+  const tokens = [];
+  let current = "";
+  let quoted = false;
+  for (const ch of commandLine) {
+    if (ch === '"') {
+      quoted = !quoted;
+      continue;
+    }
+    if (!quoted && (ch === " " || ch === "	")) {
+      if (current) tokens.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current) tokens.push(current);
+  return tokens;
+}
+function exeBaseName(token) {
+  const cut = Math.max(token.lastIndexOf("/"), token.lastIndexOf("\\"));
+  return cut === -1 ? token : token.slice(cut + 1);
+}
+function looksLikeClaudeProcess(commandLine) {
+  const tokens = tokenizeCommandLine(commandLine);
+  if (tokens.length === 0) return false;
+  const exe = exeBaseName(tokens[0]).toLowerCase();
+  if (exe === "claude" || exe === "claude.exe") return true;
+  if (JS_RUNTIMES.has(exe)) {
+    for (const raw of tokens.slice(1)) {
+      if (raw.startsWith("-")) continue;
+      return CLAUDE_CLI_SCRIPT.test(raw);
+    }
+  }
+  return false;
+}
 async function discoverUnix() {
   const pids = await getPidsUnix();
   const results = await Promise.all(
@@ -2416,6 +2476,8 @@ async function discoverUnix() {
   return results.filter((r) => r !== null);
 }
 async function discoverWindows() {
+  const viaCim = await discoverWindowsViaCim();
+  if (viaCim) return viaCim;
   const pids = await getPidsWindows();
   const results = await Promise.all(
     pids.map(async (pid) => {
@@ -2450,7 +2512,24 @@ function run(cmd, args, opts = {}) {
     );
   });
 }
+function parsePsOutput(stdout) {
+  const pids = [];
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const match = trimmed.match(/^(\d+)\s+(.*)$/);
+    if (!match) continue;
+    const pid = Number.parseInt(match[1], 10);
+    if (!(pid > 0)) continue;
+    if (looksLikeClaudeProcess(match[2])) pids.push(pid);
+  }
+  return pids;
+}
 async function getPidsUnix() {
+  try {
+    return parsePsOutput(await run("ps", ["-eo", "pid=,args="]));
+  } catch {
+  }
   try {
     const output = await run("pgrep", ["-x", "claude"]);
     return output.trim().split("\n").filter(Boolean).map((s) => Number.parseInt(s, 10));
@@ -2471,6 +2550,54 @@ async function getProcessStartTimeUnix(pid) {
   const d = new Date(raw);
   return Number.isNaN(d.getTime()) ? /* @__PURE__ */ new Date() : d;
 }
+function parseCimProcesses(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return [];
+  const parsed = JSON.parse(trimmed);
+  return Array.isArray(parsed) ? parsed : [parsed];
+}
+function parseCimDate(value) {
+  if (value) {
+    const epoch = value.match(/\/Date\((\d+)\)\//);
+    if (epoch) return new Date(Number(epoch[1]));
+    const d = new Date(value);
+    if (!Number.isNaN(d.getTime())) return d;
+  }
+  return /* @__PURE__ */ new Date();
+}
+async function discoverWindowsViaCim() {
+  let stdout;
+  try {
+    stdout = await run("powershell.exe", [
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      "Get-CimInstance Win32_Process | Select-Object ProcessId,CommandLine,CreationDate | ConvertTo-Json -Compress"
+    ]);
+  } catch {
+    return null;
+  }
+  let rows;
+  try {
+    rows = parseCimProcesses(stdout);
+  } catch {
+    return null;
+  }
+  const results = [];
+  for (const row of rows) {
+    const commandLine = row.CommandLine ?? "";
+    if (!commandLine || !looksLikeClaudeProcess(commandLine)) continue;
+    results.push({
+      pid: row.ProcessId,
+      projectPath: "",
+      projectName: "",
+      branch: "",
+      conversationId: extractResumeId(commandLine),
+      startedAt: parseCimDate(row.CreationDate)
+    });
+  }
+  return results;
+}
 async function getPidsWindows() {
   try {
     const output = await run("tasklist", ["/FI", "IMAGENAME eq claude.exe", "/FO", "CSV", "/NH"]);
@@ -2513,10 +2640,15 @@ async function getProcessInfoWindows(pid) {
   }
 }
 function extractResumeId(args) {
-  const match = args.match(/--resume\s+(\S+)/);
-  return match?.[1] ?? null;
+  const eq = args.match(/(?:--resume|-r)=(\S+)/);
+  if (eq?.[1] && !eq[1].startsWith("-")) return eq[1];
+  const spaced = args.match(/(?:--resume|-r)\s+(\S+)/);
+  const candidate = spaced?.[1];
+  if (!candidate || candidate.startsWith("-")) return null;
+  return candidate;
 }
 async function readGitBranch(dir) {
+  if (!dir) return "";
   try {
     return (await run("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: dir, timeout: 3e3 })).trim();
   } catch {
@@ -2538,16 +2670,16 @@ import {
 import { EventEmitter } from "events";
 import {
   createReadStream,
-  existsSync as existsSync8,
+  existsSync as existsSync10,
   watch as fsWatch,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync7,
-  statSync as statSync6
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync8,
+  statSync as statSync8
 } from "fs";
 import { realpath as realpath2 } from "fs/promises";
 import { createServer } from "http";
-import { homedir as homedir7 } from "os";
-import { dirname as dirname8, join as join15 } from "path";
+import { homedir as homedir8 } from "os";
+import { basename as basename5, dirname as dirname9, join as join17 } from "path";
 import { createInterface } from "readline";
 
 // node_modules/nanoid/index.js
@@ -2806,7 +2938,7 @@ async function handleStartAgentSession(body, deps) {
 }
 
 // src/api/app.ts
-import { Hono as Hono12 } from "hono";
+import { Hono as Hono13 } from "hono";
 
 // src/api/middleware/auth.middleware.ts
 function isLocalRequest(remoteAddr) {
@@ -2928,12 +3060,72 @@ var createBrowseRoutes = (deps) => {
   return app;
 };
 
-// src/api/routes/conversations.routes.ts
+// src/api/routes/cacheAlert.routes.ts
 import { Hono as Hono3 } from "hono";
+
+// src/schemas/cacheAlert.schema.ts
+import { z } from "zod";
+var ResolveCacheAlertSchema = z.object({
+  fingerprint: z.string(),
+  action: z.enum(["prune_all", "prune_selected", "ignore", "reset_rescan"]),
+  ids: z.array(z.string()).optional()
+}).refine((v) => v.action !== "prune_selected" || v.ids !== void 0 && v.ids.length > 0, {
+  message: "prune_selected requires a non-empty ids array",
+  path: ["ids"]
+});
+
+// src/api/routes/cacheAlert.routes.ts
+function readRawBody2(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+var createCacheAlertRoutes = (deps) => {
+  const app = new Hono3();
+  app.get("/", (c) => {
+    const monitor = deps.cacheMonitor();
+    return c.json({ pending: monitor?.pending ?? null });
+  });
+  app.post("/resolve", async (c) => {
+    let body;
+    try {
+      const incoming = c.env?.incoming;
+      const raw = incoming ? await readRawBody2(incoming) : Buffer.from(await c.req.arrayBuffer()).toString("utf-8");
+      body = raw ? JSON.parse(raw) : {};
+    } catch {
+      return c.json({ error: "invalid json" }, 400);
+    }
+    const parsed = ResolveCacheAlertSchema.safeParse(body);
+    if (!parsed.success) {
+      return c.json({ error: "invalid body", details: parsed.error.flatten() }, 400);
+    }
+    const monitor = deps.cacheMonitor();
+    if (!monitor) return c.json({ ok: true, alreadyResolved: true });
+    const { fingerprint, action, ids } = parsed.data;
+    const result = await monitor.resolve(fingerprint, action, ids);
+    if ("conflict" in result) {
+      return c.json(
+        { error: "fingerprint_mismatch", currentFingerprint: result.currentFingerprint },
+        409
+      );
+    }
+    if ("alreadyResolved" in result) {
+      return c.json({ ok: true, alreadyResolved: true });
+    }
+    return c.json(result);
+  });
+  return app;
+};
+
+// src/api/routes/conversations.routes.ts
+import { Hono as Hono4 } from "hono";
 var ALREADY_HANDLED2 = 597;
 var alreadyHandled2 = () => new Response(null, { status: ALREADY_HANDLED2 });
 var createConversationRoutes = (deps) => {
-  const app = new Hono3();
+  const app = new Hono4();
   app.get("/count", async (c) => {
     const url = new URL(c.req.url);
     await deps.handleConversationsCount(url, c.env.outgoing);
@@ -2960,7 +3152,7 @@ var createConversationRoutes = (deps) => {
 };
 
 // src/api/routes/health.routes.ts
-import { Hono as Hono4 } from "hono";
+import { Hono as Hono5 } from "hono";
 
 // src/version.ts
 import { readFileSync as readFileSync4, realpathSync } from "fs";
@@ -2996,16 +3188,19 @@ function resolveVersion() {
 }
 
 // src/api/routes/health.routes.ts
-var createHealthRoutes = () => {
-  const app = new Hono4();
-  app.get("/", (c) => c.json({ ok: true, version: getVersion() }));
+var createHealthRoutes = (deps) => {
+  const app = new Hono5();
+  app.get("/", (c) => {
+    const cacheAlert = deps.cacheMonitor()?.healthzField();
+    return c.json({ ok: true, version: getVersion(), ...cacheAlert ? { cacheAlert } : {} });
+  });
   return app;
 };
 
 // src/api/routes/logs.routes.ts
 import { closeSync, existsSync as existsSync5, fstatSync, openSync, readSync, statSync } from "fs";
 import { join as join9 } from "path";
-import { Hono as Hono5 } from "hono";
+import { Hono as Hono6 } from "hono";
 
 // src/lifecycle/constants.ts
 import { homedir as homedir4 } from "os";
@@ -3063,7 +3258,7 @@ function readLogLines(filePath, sinceOffset, limit) {
   }
 }
 function createLogsRoutes() {
-  const app = new Hono5();
+  const app = new Hono6();
   app.get("/", (c) => {
     try {
       const sourceParam = (c.req.query("source") || "").toLowerCase();
@@ -3134,7 +3329,7 @@ function createLogsRoutes() {
 // src/api/routes/misc.routes.ts
 import { spawn } from "child_process";
 import { createHmac, timingSafeEqual as timingSafeEqual2 } from "crypto";
-import { Hono as Hono6 } from "hono";
+import { Hono as Hono7 } from "hono";
 import { hostname } from "os";
 
 // src/config/update-config.ts
@@ -3144,15 +3339,15 @@ import { join as join10 } from "path";
 import { parse as parseYaml } from "yaml";
 
 // src/schemas/updateConfig.schema.ts
-import { z } from "zod";
-var UpdateConfigSchema = z.object({
-  auto_update: z.boolean().default(false),
-  channel: z.enum(["stable", "next"]).default("stable"),
-  allow: z.array(z.enum(["patch", "minor", "major"])).default(["patch", "minor"]),
-  poll_interval_minutes: z.number().int().min(0).default(60),
-  defer_if_active_sessions: z.boolean().default(true),
-  github_repo: z.string().regex(/^[^/]+\/[^/]+$/, "github_repo must be 'owner/name'"),
-  webhook_secret: z.string().min(1).nullable().default(null)
+import { z as z2 } from "zod";
+var UpdateConfigSchema = z2.object({
+  auto_update: z2.boolean().default(false),
+  channel: z2.enum(["stable", "next"]).default("stable"),
+  allow: z2.array(z2.enum(["patch", "minor", "major"])).default(["patch", "minor"]),
+  poll_interval_minutes: z2.number().int().min(0).default(1440),
+  defer_if_active_sessions: z2.boolean().default(true),
+  github_repo: z2.string().regex(/^[^/]+\/[^/]+$/, "github_repo must be 'owner/name'"),
+  webhook_secret: z2.string().min(1).nullable().default(null)
 }).strict();
 
 // src/config/update-config.ts
@@ -3189,7 +3384,7 @@ function readJsonBody(req) {
     req.on("error", reject);
   });
 }
-function readRawBody2(req) {
+function readRawBody3(req) {
   return new Promise((resolve2, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
@@ -3208,7 +3403,7 @@ function verifyWebhookSignature(body, header, secret) {
 }
 var clientLog = getLogger("client");
 var createMiscRoutes = (deps) => {
-  const app = new Hono6();
+  const app = new Hono7();
   app.get("/api/info", (c) => {
     const ptyIds = deps.ptyAttachedIds();
     return c.json({
@@ -3241,7 +3436,7 @@ var createMiscRoutes = (deps) => {
     }
     let body;
     try {
-      body = await readRawBody2(c.env.incoming);
+      body = await readRawBody3(c.env.incoming);
     } catch {
       return c.json({ error: "could not read body" }, 400);
     }
@@ -3284,11 +3479,11 @@ var createMiscRoutes = (deps) => {
 };
 
 // src/api/routes/pair.routes.ts
-import { Hono as Hono7 } from "hono";
+import { Hono as Hono8 } from "hono";
 var ALREADY_HANDLED3 = 597;
 var alreadyHandled3 = () => new Response(null, { status: ALREADY_HANDLED3 });
 var createPairRoutes = (deps) => {
-  const app = new Hono7();
+  const app = new Hono8();
   app.post("/start", (c) => {
     deps.handlePairStart(c.env.outgoing);
     return alreadyHandled3();
@@ -3301,11 +3496,11 @@ var createPairRoutes = (deps) => {
 };
 
 // src/api/routes/projects.routes.ts
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono9 } from "hono";
 var ALREADY_HANDLED4 = 597;
 var alreadyHandled4 = () => new Response(null, { status: ALREADY_HANDLED4 });
 var createProjectRoutes = (deps) => {
-  const app = new Hono8();
+  const app = new Hono9();
   app.get("/", (c) => {
     const url = new URL(c.req.url);
     deps.handleListProjects(url, c.env.outgoing);
@@ -3320,11 +3515,11 @@ var createProjectRoutes = (deps) => {
 };
 
 // src/api/routes/scanner.routes.ts
-import { Hono as Hono9 } from "hono";
+import { Hono as Hono10 } from "hono";
 var ALREADY_HANDLED5 = 597;
 var alreadyHandled5 = () => new Response(null, { status: ALREADY_HANDLED5 });
 var createScannerRoutes = (deps) => {
-  const app = new Hono9();
+  const app = new Hono10();
   app.get("/api/search", async (c) => {
     const url = new URL(c.req.url);
     await deps.handleSearch(url, c.env.outgoing);
@@ -3334,11 +3529,11 @@ var createScannerRoutes = (deps) => {
 };
 
 // src/api/routes/sessions.routes.ts
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono11 } from "hono";
 var ALREADY_HANDLED6 = 597;
 var alreadyHandled6 = () => new Response(null, { status: ALREADY_HANDLED6 });
 var createSessionRoutes = (deps) => {
-  const app = new Hono10();
+  const app = new Hono11();
   app.get("/count", (c) => {
     deps.handleSessionsCount(c.env.outgoing);
     return alreadyHandled6();
@@ -3405,9 +3600,9 @@ var createSessionRoutes = (deps) => {
 };
 
 // src/api/routes/ws.routes.ts
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono12 } from "hono";
 var createWsRoutes = (deps, upgradeWebSocket) => {
-  const app = new Hono11();
+  const app = new Hono12();
   app.get(
     "/ws",
     upgradeWebSocket(() => {
@@ -3433,7 +3628,7 @@ var createWsRoutes = (deps, upgradeWebSocket) => {
 
 // src/api/app.ts
 var createHonoApp = (deps, upgradeWebSocket) => {
-  const app = new Hono12();
+  const app = new Hono13();
   const httpLog = getLogger("http");
   app.use("*", async (c, next) => {
     const start = Date.now();
@@ -3453,10 +3648,11 @@ var createHonoApp = (deps, upgradeWebSocket) => {
   app.use("*", corsMiddleware(deps.browserCors));
   app.use("*", authMiddleware(deps));
   app.onError(errorMiddleware);
-  app.route("/healthz", createHealthRoutes());
+  app.route("/healthz", createHealthRoutes(deps));
   app.route("/", createMiscRoutes(deps));
   app.route("/api/sessions", createSessionRoutes(deps));
   app.route("/api/conversations", createConversationRoutes(deps));
+  app.route("/api/cache/alert", createCacheAlertRoutes(deps));
   app.route("/api/projects", createProjectRoutes(deps));
   app.route("/api/pair", createPairRoutes(deps));
   app.route("/api", createBrowseRoutes(deps));
@@ -3641,6 +3837,31 @@ function parseAgentEntrypointsEnv(raw) {
   return new Set(parts);
 }
 
+// src/utils/canonicalizeFilePath.ts
+import { normalize } from "path";
+function canonicalizeFilePath(filePath) {
+  return filePath.trim().replace(/\\/g, "/");
+}
+function toNativeFilePath(filePath) {
+  return normalize(filePath.trim());
+}
+function canonicalLivePathSet(metas) {
+  const live = /* @__PURE__ */ new Set();
+  for (const meta of metas) {
+    if (meta.filePath) live.add(canonicalizeFilePath(meta.filePath));
+  }
+  return live;
+}
+function joinStatCacheByNativePath(metas, canonicalStats) {
+  const joined = /* @__PURE__ */ new Map();
+  for (const meta of metas) {
+    if (!meta.filePath) continue;
+    const stat3 = canonicalStats.get(canonicalizeFilePath(meta.filePath));
+    if (stat3) joined.set(meta.filePath, { stat: stat3, meta });
+  }
+  return joined;
+}
+
 // src/utils/fileIdentity.ts
 import { createHash } from "crypto";
 function fileIdentity(stat3, headBytes) {
@@ -3753,8 +3974,19 @@ var ConversationCache = class _ConversationCache {
       ),
       // Batch equivalent of updateMeta: bumps message_count by N in one write
       // (used by updateFromLines so a burst of appended lines is one UPDATE).
+      // last_activity/last_message only move FORWARD: a batch whose newest line
+      // predates the stored last_activity (interleaved writers appending an older
+      // line) must not drag the metadata backward. message_count and updated_at
+      // still advance — a real message was appended and the row did change.
       updateMetaBatch: db.prepare(
-        "UPDATE conversation_meta SET message_count = message_count + @inc, last_activity = @last_activity, last_message = @last_message, updated_at = @updated_at WHERE id = @id"
+        `UPDATE conversation_meta SET
+           message_count = message_count + @inc,
+           last_activity = CASE WHEN @last_activity > IFNULL(last_activity, -1)
+                                THEN @last_activity ELSE last_activity END,
+           last_message  = CASE WHEN @last_activity > IFNULL(last_activity, -1)
+                                THEN @last_message ELSE last_message END,
+           updated_at    = @updated_at
+         WHERE id = @id`
       ),
       insertSkeleton: db.prepare(
         "INSERT OR IGNORE INTO conversation_meta (id, file_path, message_count, updated_at) VALUES (?, ?, 1, ?)"
@@ -3836,6 +4068,7 @@ var ConversationCache = class _ConversationCache {
         "SELECT provider FROM conversation_meta WHERE file_path = ?"
       ),
       allFilePaths: db.prepare("SELECT id, file_path FROM conversation_meta"),
+      allFilePathsWithTitle: db.prepare("SELECT id, file_path, title FROM conversation_meta"),
       allFileStats: db.prepare(
         "SELECT file_path, mtime_ms, file_size FROM conversation_meta WHERE mtime_ms IS NOT NULL AND file_size IS NOT NULL"
       ),
@@ -3988,7 +4221,7 @@ var ConversationCache = class _ConversationCache {
   // excluded from the index entirely; the scanner serves them (it routes each
   // provider to its own parser).
   isIndexableFile(filePath) {
-    const row = this.stmts.getProviderByFilePath.get(filePath);
+    const row = this.stmts.getProviderByFilePath.get(canonicalizeFilePath(filePath));
     if (!row) return false;
     return (row.provider ?? CLAUDE_CODE_PROVIDER) === CLAUDE_CODE_PROVIDER;
   }
@@ -4256,7 +4489,7 @@ var ConversationCache = class _ConversationCache {
     if (this.fileIndexLoaded) return;
     const rows = this.stmts.allFilePaths.all();
     for (const row of rows) {
-      this.fileIndex.set(row.file_path, row.id);
+      this.fileIndex.set(canonicalizeFilePath(row.file_path), row.id);
     }
     this.fileIndexLoaded = true;
   }
@@ -4275,12 +4508,13 @@ var ConversationCache = class _ConversationCache {
     const role = line.role ?? line.type;
     const isMessage = role === "user" || role === "assistant";
     this.ensureFileIndex();
+    const key = canonicalizeFilePath(filePath);
     if (!isMessage && !line.cwd && !line.slug) return;
-    let convId = this.fileIndex.get(filePath);
+    let convId = this.fileIndex.get(key);
     if (!convId) {
-      const pseudoId = filePath.split(/[/\\]/).pop()?.replace(/\.jsonl$/, "") ?? filePath;
-      this.stmts.insertSkeleton.run(pseudoId, filePath, 0);
-      this.fileIndex.set(filePath, pseudoId);
+      const pseudoId = key.split(/[/\\]/).pop()?.replace(/\.jsonl$/, "") ?? key;
+      this.stmts.insertSkeleton.run(pseudoId, key, 0);
+      this.fileIndex.set(key, pseudoId);
       convId = pseudoId;
     }
     if (line.cwd || line.slug) {
@@ -4295,18 +4529,18 @@ var ConversationCache = class _ConversationCache {
       });
     }
     if (!isMessage) return;
-    const timestamp = line.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
-    const activityMs = new Date(timestamp).getTime();
+    const timestamp2 = line.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+    const activityMs = new Date(timestamp2).getTime();
     if (Number.isNaN(activityMs)) return;
     const contentBlocks = normalizeContent(line.message?.content ?? line.content);
     const text = contentBlocks.find((b) => b.type === "text")?.text?.slice(0, 200) ?? "";
-    const lastMessage = JSON.stringify({ role, timestamp, text });
+    const lastMessage = JSON.stringify({ role, timestamp: timestamp2, text });
     const seq = ++this.tailSeq;
     const result = this.stmts.updateMeta.run(activityMs, lastMessage, seq, convId);
     if (result.changes === 0) return;
     const tailRow = this.stmts.getTail.get(convId);
     const msgs = tailRow ? JSON.parse(tailRow.messages_json) : [];
-    msgs.push({ role, timestamp, text, content: contentBlocks });
+    msgs.push({ role, timestamp: timestamp2, text, content: contentBlocks });
     if (msgs.length > this.tailSize) msgs.splice(0, msgs.length - this.tailSize);
     this.stmts.upsertTail.run(convId, JSON.stringify(msgs), msgs.length, seq);
   }
@@ -4318,7 +4552,8 @@ var ConversationCache = class _ConversationCache {
    * updateFromLine in order: the agent filter short-circuits the whole batch,
    * project context is backfilled last-wins, message_count increases by the
    * number of surviving message lines, and last_activity/last_message reflect
-   * the final message line.
+   * the newest message line by timestamp (a monotonic guard keeps them from
+   * moving backward when an interleaved writer appends an older line — P0.3).
    */
   updateFromLines(filePath, rawLines) {
     let sawProjectContext = false;
@@ -4354,23 +4589,26 @@ var ConversationCache = class _ConversationCache {
         backfillTitle ??= lineTitle;
       }
       if (!isMessage) continue;
-      const timestamp = line.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
-      const activityMs = new Date(timestamp).getTime();
+      const timestamp2 = line.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+      const activityMs = new Date(timestamp2).getTime();
       if (Number.isNaN(activityMs)) continue;
       const contentBlocks = normalizeContent(line.message?.content ?? line.content);
       const text = contentBlocks.find((b) => b.type === "text")?.text?.slice(0, 200) ?? "";
       msgCount += 1;
-      lastActivityMs = activityMs;
-      lastMessage = JSON.stringify({ role, timestamp, text });
-      newTail.push({ role, timestamp, text, content: contentBlocks });
+      if (lastActivityMs === null || activityMs > lastActivityMs) {
+        lastActivityMs = activityMs;
+        lastMessage = JSON.stringify({ role, timestamp: timestamp2, text });
+      }
+      newTail.push({ role, timestamp: timestamp2, text, content: contentBlocks });
     }
     if (!sawProjectContext && msgCount === 0) return;
     this.ensureFileIndex();
-    let convId = this.fileIndex.get(filePath);
+    const key = canonicalizeFilePath(filePath);
+    let convId = this.fileIndex.get(key);
     if (!convId) {
-      const pseudoId = filePath.split(/[/\\]/).pop()?.replace(/\.jsonl$/, "") ?? filePath;
-      this.stmts.insertSkeleton.run(pseudoId, filePath, 0);
-      this.fileIndex.set(filePath, pseudoId);
+      const pseudoId = key.split(/[/\\]/).pop()?.replace(/\.jsonl$/, "") ?? key;
+      this.stmts.insertSkeleton.run(pseudoId, key, 0);
+      this.fileIndex.set(key, pseudoId);
       convId = pseudoId;
     }
     const id = convId;
@@ -4413,6 +4651,7 @@ var ConversationCache = class _ConversationCache {
       for (const m of items) {
         const id = m.sessionId || m.id.split("/").pop()?.replace(/\.jsonl$/, "") || m.id;
         const lastActivityMs = m.timestamp ? new Date(m.timestamp).getTime() : null;
+        const canonicalPath = canonicalizeFilePath(m.filePath);
         let mtimeMs = null;
         let fileSize = null;
         try {
@@ -4428,10 +4667,10 @@ var ConversationCache = class _ConversationCache {
         const scannerMetaJson = JSON.stringify(m);
         this.stmts.upsertFull.run({
           id,
-          file_path: m.filePath,
+          file_path: canonicalPath,
           project_path: m.projectPath ?? null,
           project_name: m.projectName ?? null,
-          title: m.title ?? m.projectName ?? null,
+          title: m.title ?? m.sessionName ?? m.projectName ?? null,
           model: m.model ?? null,
           account: m.account ?? null,
           branch: m.gitBranch ?? null,
@@ -4447,7 +4686,7 @@ var ConversationCache = class _ConversationCache {
           scanner_meta_json: scannerMetaJson
         });
         this.stmts.updateScannerCache.run(mtimeMs, fileSize, scannerMetaJson, id);
-        if (this.fileIndexLoaded) this.fileIndex.set(m.filePath, id);
+        if (this.fileIndexLoaded) this.fileIndex.set(canonicalPath, id);
         upsertedIds.push(id);
       }
     });
@@ -4458,11 +4697,12 @@ var ConversationCache = class _ConversationCache {
   // by updateFromLine when a previously-cached file turns out to be an agent
   // JSONL.
   deleteByFilePath(filePath) {
-    const row = this.stmts.getIdByFilePath.get(filePath);
+    const key = canonicalizeFilePath(filePath);
+    const row = this.stmts.getIdByFilePath.get(key);
     if (!row) return false;
     this.stmts.deleteTailById.run(row.id);
     const result = this.stmts.deleteById.run(row.id);
-    this.fileIndex.delete(filePath);
+    this.fileIndex.delete(key);
     return result.changes > 0;
   }
   // Reads the last `tailSize` qualifying lines from a JSONL file and writes them
@@ -4514,10 +4754,10 @@ var ConversationCache = class _ConversationCache {
       }
       const role = parsed.role ?? parsed.type;
       if (!role) continue;
-      const timestamp = parsed.timestamp ?? "";
+      const timestamp2 = parsed.timestamp ?? "";
       const contentBlocks = normalizeContent(parsed.message?.content ?? parsed.content);
       const text = contentBlocks.find((b) => b.type === "text")?.text?.slice(0, 200) ?? "";
-      msgs.unshift({ role, timestamp, text, content: contentBlocks });
+      msgs.unshift({ role, timestamp: timestamp2, text, content: contentBlocks });
     }
     if (msgs.length === 0) return false;
     this.stmts.upsertTail.run(convId, JSON.stringify(msgs), msgs.length, 0);
@@ -4585,6 +4825,16 @@ var ConversationCache = class _ConversationCache {
     }
     return map;
   }
+  /**
+   * Conversation id for a JSONL path, or null when no row exists yet. Resolves
+   * by file_path (NOT conversationIdForFile) so codex rollout files — named
+   * rollout-<ts>-<uuid>.jsonl, whose stem is not the row id — resolve correctly.
+   */
+  getIdByFilePath(filePath) {
+    const key = canonicalizeFilePath(filePath);
+    const row = this.stmts.getIdByFilePath.get(key);
+    return row?.id ?? null;
+  }
   getMetaById(id) {
     const row = this.stmts.getFullById.get(id);
     if (!row) return null;
@@ -4677,22 +4927,23 @@ var ConversationCache = class _ConversationCache {
   /**
    * Drop the cached row for a file. Two callers with opposite intent:
    *  - a directory-watch "change" event (the file was appended to) — pass
-   *    `skipIfTailed: true`. A cached tail means the row is being actively
-   *    maintained from the file's real content by the live-tail
-   *    (updateFromLines) or warm-up path, fresher than any scanner-derived
-   *    view. Both watchers fire on the same append with no ordering guarantee;
-   *    without this guard the invalidate can land after the tail write and wipe
-   *    the just-cached row, flickering the conversation out of
-   *    /api/conversations on nearly every message (CRITICAL #2). The debounced
-   *    rescan still re-derives metadata, so skipping the eager drop loses
-   *    nothing.
+   *    `skipIfTailed: true`, which NEVER deletes (upsert-or-leave). A change
+   *    event fires on every external append; deleting here flickers the
+   *    conversation out of /api/conversations — whether it's a live-tailed row
+   *    the updateFromLines/warm-up path just wrote (CRITICAL #2; both watchers
+   *    fire on the same append with no ordering guarantee) OR a refresh-created
+   *    untailed row (a ?refresh=1 upsert never populates a tail, so the old
+   *    "delete when untailed" behavior made it vanish on its next append with no
+   *    client action). The live-tail path owns the row's content and the
+   *    debounced rescan re-derives metadata, so leaving the row loses nothing.
    *  - a genuine unlink (the file is gone) — leave `skipIfTailed` false so the
    *    row is always removed, otherwise a deleted session ghosts in the cache.
    */
   invalidateByFilePath(filePath, opts) {
-    const row = this.stmts.getIdByFilePath.get(filePath);
+    const key = canonicalizeFilePath(filePath);
+    const row = this.stmts.getIdByFilePath.get(key);
     if (!row) return null;
-    if (opts?.skipIfTailed && this.stmts.hasTail.get(row.id)) return null;
+    if (opts?.skipIfTailed) return null;
     this.invalidate(row.id);
     return row.id;
   }
@@ -4786,6 +5037,68 @@ var ConversationCache = class _ConversationCache {
     }
     return removed;
   }
+  /**
+   * Read-only: list cached rows whose `file_path` no longer exists on disk.
+   * Unlike pruneGhostFiles/reconcileDeletions this mutates nothing — it just
+   * reports drift for the CacheIntegrityMonitor to classify. `tailed` flags
+   * rows that still have cached history (which pruneGhostFiles would keep).
+   */
+  listMissingFiles(exists = existsSync6) {
+    const rows = this.stmts.allFilePathsWithTitle.all();
+    const missing = [];
+    for (const row of rows) {
+      if (exists(row.file_path)) continue;
+      missing.push({
+        id: row.id,
+        filePath: row.file_path,
+        title: row.title,
+        tailed: !!this.stmts.hasTail.get(row.id)
+      });
+    }
+    return missing;
+  }
+  /**
+   * Drop the given conversation ids outright — main row, tail, and message
+   * index — regardless of whether they have a tail. Used by the cache-integrity
+   * resolution actions (prune_all / prune_selected). Returns the count dropped.
+   */
+  dropRowsById(ids) {
+    if (ids.length === 0) return 0;
+    const drop = this.db.transaction((toDrop) => {
+      let n = 0;
+      for (const id of toDrop) {
+        this.stmts.deleteTailById.run(id);
+        this.stmts.deleteMessageIndex.run(id);
+        n += this.stmts.deleteById.run(id).changes;
+      }
+      return n;
+    });
+    const dropped = drop(ids);
+    if (this.fileIndexLoaded) {
+      for (const id of ids) {
+        for (const [fp, cid] of this.fileIndex) {
+          if (cid === id) {
+            this.fileIndex.delete(fp);
+            break;
+          }
+        }
+      }
+    }
+    return dropped;
+  }
+  /**
+   * Wipe all cached conversation state — meta, tails, and message index — and
+   * reset the in-memory file index. Only called by the `reset_rescan`
+   * resolution action, which repopulates from a fresh disk scan afterward.
+   */
+  clearAll() {
+    this.db.transaction(() => {
+      this.stmts.deleteTailAll.run();
+      this.stmts.deleteAll.run();
+      this.db.exec("DELETE FROM conversation_message_index");
+    })();
+    this.fileIndex = /* @__PURE__ */ new Map();
+  }
 };
 
 // src/db/repositories/cacheMetadata.repository.ts
@@ -5095,9 +5408,320 @@ function seal(plaintext, recipientPublicKeyBase64) {
   };
 }
 
+// src/services/cache-integrity/cacheIntegrityMonitor.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync8 } from "fs";
+
+// src/services/cache-integrity/alertStore.ts
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname8, join as join14 } from "path";
+function alertStatePath() {
+  const dir = process.env.THREADBASE_CONFIG_DIR ?? join14(homedir7(), ".threadbase");
+  return join14(dir, "cache-alert.json");
+}
+function loadAlertState() {
+  try {
+    const parsed = JSON.parse(readFileSync7(alertStatePath(), "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function saveAlertState(state) {
+  const path = alertStatePath();
+  mkdirSync4(dirname8(path), { recursive: true });
+  writeFileSync3(path, `${JSON.stringify(state, null, 2)}
+`);
+}
+
+// src/services/cache-integrity/backup.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readdirSync as readdirSync4, statSync as statSync5, unlinkSync } from "fs";
+import { join as join15 } from "path";
+var DEFAULT_RETAIN = 3;
+function retainCount() {
+  const parsed = Number.parseInt(process.env.THREADBASE_CACHE_BACKUP_RETAIN ?? "", 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_RETAIN;
+}
+function timestamp(d) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+async function backupCacheDb(db, cacheDir) {
+  const backupsDir = join15(cacheDir, "backups");
+  mkdirSync5(backupsDir, { recursive: true });
+  const destPath = join15(backupsDir, `cache-${timestamp(/* @__PURE__ */ new Date())}.db`);
+  await db.backup(destPath);
+  const retain = retainCount();
+  const backups = readdirSync4(backupsDir).filter((f) => f.startsWith("cache-") && f.endsWith(".db")).map((f) => {
+    const full = join15(backupsDir, f);
+    return { full, mtime: statSync5(full).mtimeMs };
+  }).sort((a, b) => b.mtime - a.mtime);
+  for (const stale of backups.slice(retain)) {
+    if (existsSync7(stale.full)) unlinkSync(stale.full);
+  }
+  return destPath;
+}
+
+// src/services/cache-integrity/cacheIntegrityMonitor.ts
+var MAX_MISSING_PERSISTED = 1e3;
+var SAMPLE_SIZE = 20;
+var STORM_WINDOW_MS = 3e4;
+var STORM_THRESHOLD = 10;
+function envInt(name, fallback) {
+  const parsed = Number.parseInt(process.env[name] ?? "", 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function fingerprintOf(ids) {
+  const sorted = [...ids].sort();
+  return `sha256:${createHash2("sha256").update(sorted.join("\n")).digest("hex")}`;
+}
+var CacheIntegrityMonitor = class {
+  constructor(cache, wsHub, log3, cacheDir, rescan, runDuringReset) {
+    this.cache = cache;
+    this.wsHub = wsHub;
+    this.log = log3;
+    this.cacheDir = cacheDir;
+    this.rescan = rescan;
+    this.runDuringReset = runDuringReset;
+    const state = loadAlertState();
+    this._pending = state.pending ?? null;
+    this.ignoredIds = new Set(state.ignoredIds ?? []);
+  }
+  cache;
+  wsHub;
+  log;
+  cacheDir;
+  rescan;
+  runDuringReset;
+  _pending;
+  ignoredIds;
+  deferredUnlinks = [];
+  unlinkTimes = [];
+  get pending() {
+    return this._pending;
+  }
+  persist() {
+    const state = {};
+    if (this._pending) {
+      state.pending = {
+        ...this._pending,
+        missing: this._pending.missing.slice(0, MAX_MISSING_PERSISTED)
+      };
+    }
+    if (this.ignoredIds.size > 0) state.ignoredIds = [...this.ignoredIds];
+    saveAlertState(state);
+  }
+  classifySeverity(missingCount, totalRows) {
+    const minMissing = envInt("THREADBASE_CACHE_ALERT_MIN_MISSING", 20);
+    const minRatio = Number.parseFloat(process.env.THREADBASE_CACHE_ALERT_MIN_RATIO ?? "0.20");
+    const ratio = totalRows > 0 ? missingCount / totalRows : 0;
+    const ratioThreshold = Number.isFinite(minRatio) ? minRatio : 0.2;
+    return missingCount >= minMissing && ratio >= ratioThreshold ? "high" : "low";
+  }
+  sampleOf(missing) {
+    return missing.slice(0, SAMPLE_SIZE).map((m) => ({
+      id: m.id,
+      ...m.title != null ? { title: m.title } : {}
+    }));
+  }
+  buildWsMessage(pending) {
+    return {
+      type: "cache_alert",
+      fingerprint: pending.fingerprint,
+      severity: pending.severity,
+      missingCount: pending.missingCount,
+      totalRows: pending.totalRows,
+      detectedAt: pending.detectedAt,
+      sample: this.sampleOf(pending.missing)
+    };
+  }
+  wsMessage() {
+    return this._pending ? this.buildWsMessage(this._pending) : null;
+  }
+  healthzField() {
+    if (!this._pending) return void 0;
+    return {
+      severity: this._pending.severity,
+      missingCount: this._pending.missingCount,
+      fingerprint: this._pending.fingerprint,
+      detectedAt: this._pending.detectedAt
+    };
+  }
+  /**
+   * Scan the cache for rows whose file is gone, excluding ids the user chose to
+   * ignore. If none remain, clear any stale pending alert and return (the caller
+   * decides whether to run pruneGhostFiles). Otherwise classify severity, persist
+   * the pending record, back up on high severity, and broadcast the alert.
+   */
+  async runDetection(detectedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+    const all = this.cache.listMissingFiles(existsSync8);
+    const missing = all.filter((m) => !this.ignoredIds.has(m.id));
+    if (missing.length === 0) {
+      if (this._pending) {
+        this._pending = null;
+        this.persist();
+      }
+      return;
+    }
+    const totalRows = this.cache.listConversations({ limit: 0, offset: 0 }).total;
+    const fingerprint = fingerprintOf(missing.map((m) => m.id));
+    const severity = this.classifySeverity(missing.length, totalRows);
+    const pending = {
+      fingerprint,
+      severity,
+      detectedAt,
+      missingCount: missing.length,
+      totalRows,
+      missing
+    };
+    if (severity === "high") {
+      try {
+        pending.backupPath = await backupCacheDb(this.cache.getDatabase(), this.cacheDir);
+      } catch (err) {
+        this.log.warn("cache-integrity backup failed", {
+          event: "cache_integrity.backup_failed",
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    this._pending = pending;
+    this.persist();
+    this.log.warn("cache integrity drift detected", {
+      event: "cache_integrity.detected",
+      severity,
+      missingCount: missing.length,
+      totalRows,
+      fingerprint
+    });
+    this.wsHub.broadcast(this.buildWsMessage(pending));
+  }
+  /** Queue an unlink while an alert is pending — the row is not invalidated. */
+  deferUnlink(filePath) {
+    this.deferredUnlinks.push(filePath);
+  }
+  /**
+   * Record a live unlink while NO alert is pending. Crossing the storm threshold
+   * (>= 10 unlinks within 30s) re-triggers detection.
+   */
+  recordUnlink(filePath) {
+    const now = Date.now();
+    this.unlinkTimes.push(now);
+    this.unlinkTimes = this.unlinkTimes.filter((t) => now - t < STORM_WINDOW_MS);
+    if (this.unlinkTimes.length >= STORM_THRESHOLD) {
+      this.unlinkTimes = [];
+      void this.runDetection().catch((err) => {
+        this.log.error("cache-integrity storm detection failed", {
+          event: "cache_integrity.storm_detection_failed",
+          error: err instanceof Error ? err.message : String(err),
+          filePath
+        });
+      });
+    }
+  }
+  async ensureBackup(pending) {
+    if (pending.backupPath) return pending.backupPath;
+    try {
+      pending.backupPath = await backupCacheDb(this.cache.getDatabase(), this.cacheDir);
+    } catch (err) {
+      this.log.warn("cache-integrity backup failed", {
+        event: "cache_integrity.backup_failed",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    return pending.backupPath;
+  }
+  clearPending() {
+    this._pending = null;
+    this.deferredUnlinks = [];
+    this.persist();
+  }
+  applyDeferredUnlinks() {
+    for (const fp of this.deferredUnlinks) this.cache.invalidateByFilePath(fp);
+    this.deferredUnlinks = [];
+  }
+  broadcastResolved(fingerprint, action) {
+    this.wsHub.broadcast({ type: "cache_alert_resolved", fingerprint, action });
+  }
+  /**
+   * Apply the human's chosen resolution. Idempotent per fingerprint: no pending
+   * alert → alreadyResolved; a different fingerprint → conflict. See the spec's
+   * four-action semantics.
+   */
+  async resolve(fingerprint, action, ids) {
+    const pending = this._pending;
+    if (!pending) return { alreadyResolved: true };
+    if (pending.fingerprint !== fingerprint) {
+      return { conflict: true, currentFingerprint: pending.fingerprint };
+    }
+    this._pending = null;
+    switch (action) {
+      case "prune_all": {
+        await this.ensureBackup(pending);
+        const backupPath = pending.backupPath;
+        const stillMissing = pending.missing.filter((m) => !existsSync8(m.filePath)).map((m) => m.id);
+        const pruned = this.cache.dropRowsById(stillMissing);
+        this.applyDeferredUnlinks();
+        this.clearPending();
+        this.broadcastResolved(fingerprint, action);
+        return { ok: true, action, pruned, backupPath };
+      }
+      case "prune_selected": {
+        const requested = new Set(ids ?? []);
+        const pendingIds = new Set(pending.missing.map((m) => m.id));
+        const toDrop = [...requested].filter((id) => pendingIds.has(id));
+        await this.ensureBackup(pending);
+        const backupPath = pending.backupPath;
+        const pruned = this.cache.dropRowsById(toDrop);
+        const prunedPaths = new Set(
+          pending.missing.filter((m) => toDrop.includes(m.id)).map((m) => m.filePath)
+        );
+        this.deferredUnlinks = this.deferredUnlinks.filter((fp) => {
+          if (prunedPaths.has(fp)) {
+            this.cache.invalidateByFilePath(fp);
+            return false;
+          }
+          return true;
+        });
+        this.persist();
+        await this.runDetection();
+        this.broadcastResolved(fingerprint, action);
+        return { ok: true, action, pruned, backupPath };
+      }
+      case "ignore": {
+        for (const m of pending.missing) this.ignoredIds.add(m.id);
+        this.deferredUnlinks = [];
+        this.clearPending();
+        this.broadcastResolved(fingerprint, action);
+        return { ok: true, action };
+      }
+      case "reset_rescan": {
+        const backupPath = await this.ensureBackup(pending);
+        const reset = async () => {
+          this.cache.clearAll();
+          if (this.rescan) {
+            const metas = await this.rescan();
+            this.cache.upsertFromScannerMeta(metas);
+          }
+        };
+        const resetPromise = this.runDuringReset ? this.runDuringReset(reset) : reset();
+        void resetPromise.catch((err) => {
+          this.log.error("cache-integrity reset rescan failed", {
+            event: "cache_integrity.reset_rescan_failed",
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+        this.clearPending();
+        this.broadcastResolved(fingerprint, action);
+        return { ok: true, action, backupPath };
+      }
+    }
+  }
+};
+
 // src/services/conversations/conversationWatcher.ts
 import chokidar from "chokidar";
-import { statSync as statSync5 } from "fs";
+import { statSync as statSync6 } from "fs";
 import { open, stat as stat2 } from "fs/promises";
 var ConversationWatcher = class {
   files = /* @__PURE__ */ new Map();
@@ -5107,6 +5731,7 @@ var ConversationWatcher = class {
   onNewLineSpans;
   onConversationChanged;
   onFileDeleted;
+  onTruncated;
   onError;
   constructor(events = {}) {
     this.onNewLine = events.onNewLine;
@@ -5114,13 +5739,15 @@ var ConversationWatcher = class {
     this.onNewLineSpans = events.onNewLineSpans;
     this.onConversationChanged = events.onConversationChanged;
     this.onFileDeleted = events.onFileDeleted;
+    this.onTruncated = events.onTruncated;
     this.onError = events.onError;
   }
   watch(filePath) {
-    if (this.files.has(filePath)) return;
+    const key = canonicalizeFilePath(filePath);
+    if (this.files.has(key)) return;
     let offset;
     try {
-      offset = statSync5(filePath).size;
+      offset = statSync6(filePath).size;
     } catch {
       offset = 0;
     }
@@ -5129,23 +5756,24 @@ var ConversationWatcher = class {
       awaitWriteFinish: { stabilityThreshold: 50, pollInterval: 25 }
     });
     watcher.on("change", () => {
-      void this.readNewLines(filePath);
+      void this.readNewLines(key);
     });
     watcher.on("add", () => {
-      void this.readNewLines(filePath);
+      void this.readNewLines(key);
     });
     watcher.on("unlink", () => this.onFileDeleted?.(filePath));
     watcher.on("error", (err) => {
       const error = err instanceof Error ? err : new Error(String(err));
       this.onError?.(filePath, error);
     });
-    this.files.set(filePath, { watcher, offset, reading: false, pending: false });
+    this.files.set(key, { watcher, offset, reading: false, pending: false, path: filePath });
   }
   unwatch(filePath) {
-    const entry = this.files.get(filePath);
+    const key = canonicalizeFilePath(filePath);
+    const entry = this.files.get(key);
     if (!entry) return;
     void entry.watcher.close();
-    this.files.delete(filePath);
+    this.files.delete(key);
   }
   /**
    * Re-drive the tail read for a file that's already being tailed. A per-file
@@ -5156,8 +5784,9 @@ var ConversationWatcher = class {
    * event is a cheap stat + no-op. Returns false for untailed paths.
    */
   poke(filePath) {
-    if (!this.files.has(filePath)) return false;
-    void this.readNewLines(filePath);
+    const key = canonicalizeFilePath(filePath);
+    if (!this.files.has(key)) return false;
+    void this.readNewLines(key);
     return true;
   }
   /**
@@ -5194,9 +5823,10 @@ var ConversationWatcher = class {
     for (const [path] of this.files) this.unwatch(path);
     for (const [dir] of this.directories) this.unwatchDirectory(dir);
   }
-  async readNewLines(filePath) {
-    const entry = this.files.get(filePath);
+  async readNewLines(key) {
+    const entry = this.files.get(key);
     if (!entry) return;
+    const filePath = entry.path;
     if (entry.reading) {
       entry.pending = true;
       return;
@@ -5205,6 +5835,10 @@ var ConversationWatcher = class {
     try {
       for (; ; ) {
         const st = await stat2(filePath);
+        if (st.size < entry.offset) {
+          entry.offset = 0;
+          this.onTruncated?.(filePath);
+        }
         if (st.size <= entry.offset) break;
         const readFrom = entry.offset;
         const bytesToRead = st.size - readFrom;
@@ -5217,7 +5851,7 @@ var ConversationWatcher = class {
         }
         const { spans, consumed } = splitCompleteLines(buf, readFrom);
         entry.offset = readFrom + consumed;
-        if (!this.files.has(filePath)) return;
+        if (!this.files.has(key)) return;
         const lines = spans.map((s) => s.text);
         if (spans.length > 0) {
           this.onNewLineSpans?.(filePath, spans, readFrom, entry.offset);
@@ -5237,9 +5871,9 @@ var ConversationWatcher = class {
       this.onError?.(filePath, err instanceof Error ? err : new Error(String(err)));
     } finally {
       entry.reading = false;
-      if (entry.pending && this.files.has(filePath)) {
+      if (entry.pending && this.files.has(key)) {
         entry.pending = false;
-        void this.readNewLines(filePath);
+        void this.readNewLines(key);
       }
     }
   }
@@ -5295,14 +5929,14 @@ function findSearchTarget(messages, query) {
 }
 
 // src/services/conversations/pruneAgentConversations.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync9 } from "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 (!existsSync7(row.file_path)) {
+    if (!existsSync9(row.file_path)) {
       missing += 1;
       continue;
     }
@@ -5448,6 +6082,52 @@ function resolveAnswer(pending, body) {
   }
 }
 
+// src/services/sessions/conversationBusy.ts
+import { statSync as statSync7 } from "fs";
+var RESUME_BUSY_WINDOW_MS = 12e4;
+function resolveResumeBusyWindowMs(env = process.env) {
+  const raw = env.THREADBASE_RESUME_BUSY_WINDOW_MS;
+  if (raw === void 0) return RESUME_BUSY_WINDOW_MS;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : RESUME_BUSY_WINDOW_MS;
+}
+var SELF_ACTIVITY_SKEW_MS = 5e3;
+function conversationBusy(input) {
+  const now = input.now ?? Date.now();
+  const windowMs = input.windowMs ?? RESUME_BUSY_WINDOW_MS;
+  const platform3 = input.platform ?? process.platform;
+  const detectedBy = [];
+  let lastActivityMs = null;
+  if (input.jsonlPath) {
+    try {
+      const mtimeMs = statSync7(input.jsonlPath).mtimeMs;
+      const age = now - mtimeMs;
+      lastActivityMs = Math.max(0, age);
+      const isSelfEcho = input.selfPtyEndedAt != null && mtimeMs <= input.selfPtyEndedAt + SELF_ACTIVITY_SKEW_MS;
+      if (age <= windowMs && !isSelfEcho) detectedBy.push("jsonl_mtime");
+    } catch {
+    }
+  }
+  const argvMatch = input.discovered.some((p) => p.conversationId === input.conversationId);
+  if (argvMatch) detectedBy.push("process_argv");
+  let cwdMatch = false;
+  if (platform3 !== "win32" && input.projectPath) {
+    const target = canonicalizeProjectPath(input.projectPath);
+    cwdMatch = input.discovered.some(
+      (p) => !!p.projectPath && canonicalizeProjectPath(p.projectPath) === target
+    );
+    if (cwdMatch) detectedBy.push("process_cwd");
+  }
+  return {
+    busy: detectedBy.length > 0,
+    detectedBy,
+    lastActivityMs,
+    // A matched process is a concrete external owner; a lone mtime hit could be
+    // an editor, a crashed process, or a process we could not enumerate.
+    likelyOwner: argvMatch || cwdMatch ? "external" : "unknown"
+  };
+}
+
 // src/session-store.ts
 var SessionStore = class {
   managed = /* @__PURE__ */ new Map();
@@ -5587,6 +6267,9 @@ function managedToResponse(s, ptyAttached) {
     conversationId: s.id,
     provider: s.provider ?? CLAUDE_CODE_PROVIDER,
     status: s.status,
+    // We spawned it, so `status` is the authoritative signal — no inferred
+    // `activity` is attached for managed sessions.
+    ownership: "managed",
     projectPath: s.projectPath,
     projectName: s.projectName,
     branch: s.branch,
@@ -5620,7 +6303,14 @@ function discoveredToResponse(d, conversationId) {
     id: conversationId,
     conversationId,
     provider: CLAUDE_CODE_PROVIDER,
+    // Stays "idle" deliberately: we cannot see this process's prompt state, and
+    // reporting `running` would route mobile to the destructive Overtake screen.
+    // Liveness travels in the additive fields below instead.
     status: "idle",
+    ownership: "external",
+    // Discovery just enumerated this PID, so it was alive moments ago. We never
+    // report "gone" here — a vanished process simply stops being listed.
+    processLiveness: "alive",
     projectPath: d.projectPath,
     projectName: d.projectName,
     branch: d.branch,
@@ -5638,7 +6328,7 @@ function discoveredToResponse(d, conversationId) {
 import { randomBytes as randomBytes3 } from "crypto";
 import { mkdir as mkdir3, writeFile } from "fs/promises";
 import heicConvert from "heic-convert";
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 var UPLOAD_DIR_NAME = ".threadbase-uploads";
 var MAX_BYTES = 25 * 1024 * 1024;
 var HEIC_MIMES = /* @__PURE__ */ new Set(["image/heic", "image/heif"]);
@@ -5671,9 +6361,9 @@ async function saveUploadFile(input) {
   }
   const id = `up_${randomBytes3(8).toString("hex")}`;
   const safeName = sanitizeFilename(originalName) || `file${MIME_TO_EXT[mimeType] ?? ""}`;
-  const dir = join14(input.projectPath, UPLOAD_DIR_NAME, input.sessionId);
+  const dir = join16(input.projectPath, UPLOAD_DIR_NAME, input.sessionId);
   await mkdir3(dir, { recursive: true });
-  const filePath = join14(dir, `${Date.now()}-${id}-${safeName}`);
+  const filePath = join16(dir, `${Date.now()}-${id}-${safeName}`);
   await writeFile(filePath, buffer);
   return {
     id,
@@ -5685,7 +6375,7 @@ async function saveUploadFile(input) {
 }
 function sanitizeFilename(name) {
   const base = name.split(/[\\/]/).pop() ?? "";
-  const cleaned = base.replace(/^\.+/, "").split("").filter((c) => c.charCodeAt(0) >= 32 && c.charCodeAt(0) !== 127).join("");
+  const cleaned = base.replace(/^\.+/, "").split("").filter((c) => c.charCodeAt(0) >= 32 && c.charCodeAt(0) !== 127).join("").replace(/[\s@"'`$\\]/g, "_");
   return cleaned;
 }
 
@@ -5718,12 +6408,12 @@ function normalizeCodexLineToClaudeShape(line) {
   const text = extractCodexText(payload.content);
   if (!text) return null;
   if (role === "user" && isCodexInjectedContext(text)) return null;
-  const timestamp = typeof entry.timestamp === "string" ? entry.timestamp : (/* @__PURE__ */ new Date()).toISOString();
-  const uuid = typeof payload.id === "string" && payload.id.length > 0 ? payload.id : `codex-${role}-${timestamp}-${hashPrefix(text)}`;
+  const timestamp2 = typeof entry.timestamp === "string" ? entry.timestamp : (/* @__PURE__ */ new Date()).toISOString();
+  const uuid = typeof payload.id === "string" && payload.id.length > 0 ? payload.id : `codex-${role}-${timestamp2}-${hashPrefix(text)}`;
   return JSON.stringify({
     type: role,
     uuid,
-    timestamp,
+    timestamp: timestamp2,
     message: {
       role,
       content: [{ type: "text", text }]
@@ -5773,13 +6463,13 @@ function hashPrefix(text) {
 }
 
 // src/utils/conversationEtag.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 function computeConversationEtag({
   filePath,
   messageCount,
-  timestamp
+  timestamp: timestamp2
 }) {
-  const digest = createHash2("sha1").update(`${filePath}:${messageCount}:${timestamp}`).digest("hex").slice(0, 16);
+  const digest = createHash3("sha1").update(`${filePath}:${messageCount}:${timestamp2}`).digest("hex").slice(0, 16);
   return `"${digest}"`;
 }
 
@@ -5929,8 +6619,17 @@ var WSHub = class {
 var BROWSE_SYSTEM_PROMPT = (browseRoot) => `You are working within the project boundary: ${browseRoot}. Do not read, write, or execute commands that access files or directories outside this boundary.`;
 var DEFAULT_SYSTEM_PROMPT = "When presenting options or choices to the user, limit the options to at most 3.";
 var DEFAULT_PTY_GRACE_PERIOD_MS = 27e4;
+var GRACE_MAX_DEFERS = 4;
+var RESUME_DISCOVERY_TIMEOUT_MS = 750;
+var DISCOVERY_TTL_MS = 15e3;
+var ADOPT_KILL_TIMEOUT_MS = 5e3;
+var ADOPT_KILL_POLL_MS = 100;
 var REFRESH_TTL_MS = 2e3;
 var START_READY_TIMEOUT_MS = 1e4;
+var EXTERNAL_TAIL_RECENCY_MS = RESUME_BUSY_WINDOW_MS;
+var EXTERNAL_TAIL_MAX = 32;
+var EXTERNAL_TAIL_IDLE_MS = 3e5;
+var EXTERNAL_ACTIVE_WRITING_MS = 3e4;
 function parseIncludeAgentsEnv(raw) {
   if (raw === void 0) return false;
   const v = raw.trim().toLowerCase();
@@ -5944,11 +6643,30 @@ var StreamerServer = class {
   fileWatcher;
   sessionFileMap = /* @__PURE__ */ new Map();
   // sessionId → JSONL filePath
+  // canonical JSONL path → live tail on a file NO PTY session owns (an external
+  // agent is writing it). Deliberately separate from sessionFileMap so managed
+  // session semantics — terminal_output, session_update, question cards — are
+  // untouched: an external tail only ever pushes transcript lines.
+  externalTails = /* @__PURE__ */ new Map();
   // Per-file seq assignments from the most recent onNewLineSpans (offset index),
   // handed to the immediately-following onNewLines so it can stamp WS `seq` on
   // the matching conversation_events entries. Same read → same lines order.
   pendingLineSeqs = /* @__PURE__ */ new Map();
+  // `origin` records whether the pending question came from the live PTY-screen
+  // path (handleLiveQuestion) or a JSONL flush. A JSONL-derived question must
+  // never clobber a PTY-originated one for a DIFFERENT question — an external
+  // agent appending an AskUserQuestion into a shared conversation would
+  // otherwise misroute the answer into this streamer's PTY.
   pendingQuestions = /* @__PURE__ */ new Map();
+  // Sessions resumed past a detected collision (busy probe said busy, caller
+  // forced). JSONL-derived actionable question cards are suppressed for these
+  // because a line in the shared file may have been written by the other owner.
+  contendedSessions = /* @__PURE__ */ new Set();
+  // conversationId → ms epoch when THIS streamer's PTY for it last went idle.
+  // Lets the resume collision probe tell our own trailing JSONL writes (a
+  // hold → resume round trip) apart from another owner's. Pruned on write so it
+  // cannot grow without bound across a long-lived process.
+  selfPtyEndedAt = /* @__PURE__ */ new Map();
   // Content key of the AskUserQuestion currently broadcast for a session (from
   // either the rendered screen or JSONL), used to de-dupe the two paths: when
   // the screen detection fires first, the later JSONL flush of the same question
@@ -5983,7 +6701,8 @@ var StreamerServer = class {
   // listener-level 'error' handler demotes EADDRINUSE to debug during this
   // window so the self-healing kickstart-relaunch race doesn't spam warn.
   binding = false;
-  cacheReady = false;
+  activeWarmups = /* @__PURE__ */ new Map([[0, "startup"]]);
+  nextWarmupId = 1;
   // Every fire-and-forget task that runs a scan and then writes to this.cache
   // in an async continuation (startup warm-up, background count refresh, …).
   // close() awaits all of them before closing this.cache, so a scan's post-scan
@@ -6015,6 +6734,9 @@ var StreamerServer = class {
   defaultEffort;
   // Map of sessionId → grace timer; fires to kill PTY after WS disconnect
   ptyGraceTimers = /* @__PURE__ */ new Map();
+  // Consecutive grace-timer defers for a still-`running` session (see
+  // GRACE_MAX_DEFERS). Reset when a subscriber reconnects or the PTY settles.
+  ptyGraceDeferCounts = /* @__PURE__ */ new Map();
   // Map of sessionId → set of subscribed WS clients
   sessionSubscribers = /* @__PURE__ */ new Map();
   // Map of clientId → WS socket (populated by the "register" WS handshake)
@@ -6022,6 +6744,7 @@ var StreamerServer = class {
   // Reverse map for cleanup on close
   wsToClientId = /* @__PURE__ */ new Map();
   cache = null;
+  cacheMonitor = null;
   projectsRepo = null;
   conversationsRepo = null;
   sessionsRepo = null;
@@ -6058,13 +6781,13 @@ var StreamerServer = class {
     this.disableDb = config.disableDb ?? false;
     this.scannerPersistenceDisabled = config.scannerPersistent === false;
     this.scanProfiles = config.scanProfiles;
-    this.codexRoots = config.codexRoots ?? [join15(homedir7(), ".codex", "sessions")];
+    this.codexRoots = config.codexRoots ?? [join17(homedir8(), ".codex", "sessions")];
     this.ptyGracePeriodMs = config.ptyGracePeriodMs ?? DEFAULT_PTY_GRACE_PERIOD_MS;
     this.defaultSystemPrompt = config.defaultSystemPrompt ?? DEFAULT_SYSTEM_PROMPT;
     this.defaultPermissionMode = config.defaultPermissionMode ?? loadDefaultPermissionMode() ?? "acceptEdits";
     this.defaultModel = config.defaultModel ?? "sonnet";
     this.defaultEffort = config.defaultEffort ?? "low";
-    this.cacheDir = config.cacheDir ?? loadCacheDir() ?? join15(homedir7(), ".threadbase", "cache");
+    this.cacheDir = config.cacheDir ?? loadCacheDir() ?? join17(homedir8(), ".threadbase", "cache");
     this.tailSize = config.tailSize ?? loadTailSize() ?? 10;
     this.directoryDebounceMs = parseDirScanDebounceEnv(process.env.THREADBASE_DIR_SCAN_DEBOUNCE_MS) ?? config.directoryScanDebounceMs ?? 1e3;
     this.markScannerStaleDebounced = debounce(() => {
@@ -6105,7 +6828,7 @@ var StreamerServer = class {
           const seqs = cache.extendMessageIndex(
             filePath,
             spans,
-            statSync6(filePath),
+            statSync8(filePath),
             readFrom,
             endOffset
           );
@@ -6135,39 +6858,25 @@ var StreamerServer = class {
       },
       onNewLines: (filePath, lines) => {
         this.cache?.updateFromLines(filePath, lines);
+        let managed = false;
         for (const [sessionId, watchedPath] of this.sessionFileMap) {
           if (watchedPath === filePath) {
-            const priorToolUseId = this.pendingQuestions.get(sessionId)?.toolUseId;
-            const { messages, pending } = questionsFromLines(sessionId, lines);
-            for (const p of pending) {
-              this.pendingQuestions.set(sessionId, p);
-              const t = setTimeout(() => {
-                if (this.pendingQuestions.get(sessionId)?.toolUseId === p.toolUseId) {
-                  this.cancelPendingQuestion(sessionId);
-                }
-              }, 6e4);
-              t.unref();
-            }
-            for (const m of messages) {
-              const key = questionContentKey(m.questions);
-              const broadcast = shouldBroadcastQuestion({
-                newContentKey: key,
-                lastContentKey: this.pendingQuestionKey.get(sessionId),
-                newToolUseId: m.toolUseId,
-                priorToolUseId
-              });
-              this.pendingQuestionKey.set(sessionId, key);
-              if (broadcast) this.wsHub.broadcast(m);
-            }
+            managed = true;
+            this.processJsonlQuestions(sessionId, lines);
             const seqs = this.pendingLineSeqs.get(filePath);
             this.broadcastConversationLines(sessionId, lines, seqs);
             break;
           }
         }
+        if (!managed) {
+          this.broadcastExternalTailLines(filePath, lines, this.pendingLineSeqs.get(filePath));
+        }
         this.pendingLineSeqs.delete(filePath);
       },
       onConversationChanged: (filePath) => {
-        this.fileWatcher.poke(filePath);
+        const tailed = this.fileWatcher.poke(filePath);
+        if (!tailed) this.maybeAttachExternalTail(filePath);
+        this.sweepIdleExternalTails();
         this.cache?.invalidateByFilePath(filePath, { skipIfTailed: true });
         this.markScannerStaleDebounced();
         this.log.debug?.(`Scanner invalidated by directory event: ${filePath}`, {
@@ -6175,7 +6884,20 @@ var StreamerServer = class {
           event: "cache.directory_change"
         });
       },
+      onTruncated: (filePath) => {
+        this.cache?.deleteFileIndex(filePath, ConversationCache.conversationIdForFile(filePath));
+        this.cache?.clearIndexParseState(filePath);
+        this.log.warn(`JSONL truncated/replaced; offset index dropped: ${filePath}`, {
+          filePath,
+          event: "tail.truncated"
+        });
+      },
       onFileDeleted: (filePath) => {
+        this.detachExternalTail(canonicalizeFilePath(filePath));
+        if (this.cacheMonitor?.pending) {
+          this.cacheMonitor.deferUnlink(filePath);
+          return;
+        }
         const id = this.cache?.invalidateByFilePath(filePath);
         if (id)
           this.log.info(`Cache row invalidated after JSONL delete: ${id}`, {
@@ -6183,6 +6905,7 @@ var StreamerServer = class {
             filePath,
             event: "cache.invalidate_on_unlink"
           });
+        this.cacheMonitor?.recordUnlink(filePath);
       }
     });
     this.ptyManager = new LiveSessionManager({
@@ -6246,6 +6969,8 @@ var StreamerServer = class {
             this.cancelPendingQuestion(session.id);
           }
           this.pendingPermission.delete(session.id);
+          this.contendedSessions.delete(session.id);
+          this.rememberSelfPtyEnded(session.id);
         }
         const resp = this.sessionStore.get(session.id, this.ptyAttachedIds());
         if (resp) {
@@ -6269,7 +6994,7 @@ var StreamerServer = class {
         temporalClient,
         taskQueue: agentConfig.temporal.taskQueue
       });
-      const conversationsBaseDir = agentConfig.conversationsDir || join15(dirname8(this.cacheDir), "conversations");
+      const conversationsBaseDir = agentConfig.conversationsDir || join17(dirname9(this.cacheDir), "conversations");
       conversationWriter = createConversationWriter({
         baseDir: conversationsBaseDir
       });
@@ -6291,6 +7016,7 @@ var StreamerServer = class {
       sessionStore: this.sessionStore,
       wsHub: this.wsHub,
       cache: () => this.cache,
+      cacheMonitor: () => this.cacheMonitor,
       projectsRepo: () => this.projectsRepo,
       conversationsRepo: () => this.conversationsRepo,
       sessionsRepo: () => this.sessionsRepo,
@@ -6326,9 +7052,11 @@ var StreamerServer = class {
         this.wsHub.addClient(ws);
         const sessions = this.sessionStore.list(this.ptyAttachedIds());
         ws.send(JSON.stringify({ type: "session_list", sessions }));
-        if (this.cacheReady) {
+        if (!this.currentWarmupState()) {
           ws.send(JSON.stringify({ type: "cache_ready" }));
         }
+        const alertMsg = this.cacheMonitor?.wsMessage();
+        if (alertMsg) this.wsHub.unicast(ws, alertMsg);
       },
       handleWsMessage: async (ws, raw) => {
         try {
@@ -6444,6 +7172,17 @@ var StreamerServer = class {
   ptyAttachedIds() {
     return new Set(this.ptyManager.listSessions().map((s) => s.id));
   }
+  // Record that our own PTY for `conversationId` just ended. Entries older than
+  // the busy window can never change a verdict, so drop them as we go rather
+  // than accumulating one per conversation for the process's lifetime.
+  rememberSelfPtyEnded(conversationId) {
+    const now = Date.now();
+    const cutoff = now - resolveResumeBusyWindowMs();
+    for (const [id, at] of this.selfPtyEndedAt) {
+      if (at < cutoff) this.selfPtyEndedAt.delete(id);
+    }
+    this.selfPtyEndedAt.set(conversationId, now);
+  }
   /**
    * Send a session_list to only the client that triggered this HTTP request
    * (identified by X-Client-Id header → registered WS socket). Falls back to
@@ -6474,6 +7213,7 @@ var StreamerServer = class {
       clearTimeout(existing);
       this.ptyGraceTimers.delete(sessionId);
     }
+    this.ptyGraceDeferCounts.delete(sessionId);
   }
   startGraceTimer(sessionId, delayMs) {
     const existing = this.ptyGraceTimers.get(sessionId);
@@ -6483,14 +7223,24 @@ var StreamerServer = class {
       if (this.ptyManager.hasSession(sessionId)) {
         const resp = this.sessionStore.get(sessionId, this.ptyAttachedIds());
         if (resp?.status === "running") {
-          this.log.info(
-            `[grace] session ${sessionId} still running, deferring hold`,
-            { sessionId, event: "pty.grace_defer" },
+          const defers = (this.ptyGraceDeferCounts.get(sessionId) ?? 0) + 1;
+          if (defers <= GRACE_MAX_DEFERS) {
+            this.ptyGraceDeferCounts.set(sessionId, defers);
+            this.log.info(
+              `[grace] session ${sessionId} still running, deferring hold (${defers}/${GRACE_MAX_DEFERS})`,
+              { sessionId, event: "pty.grace_defer", defers, maxDefers: GRACE_MAX_DEFERS },
+              "pino"
+            );
+            this.startGraceTimer(sessionId, delayMs);
+            return;
+          }
+          this.log.warn(
+            `[grace] session ${sessionId} exceeded ${GRACE_MAX_DEFERS} defers, holding anyway`,
+            { sessionId, event: "pty.grace_defer_cap", defers, maxDefers: GRACE_MAX_DEFERS },
             "pino"
           );
-          this.startGraceTimer(sessionId, delayMs);
-          return;
         }
+        this.ptyGraceDeferCounts.delete(sessionId);
         this.sessionSubscribers.delete(sessionId);
         this.log.info(
           `[grace] killing idle PTY for ${sessionId}`,
@@ -6501,6 +7251,7 @@ var StreamerServer = class {
         const held = this.sessionStore.get(sessionId, this.ptyAttachedIds());
         if (held) this.wsHub.broadcast({ type: "session_update", session: held });
       } else {
+        this.ptyGraceDeferCounts.delete(sessionId);
         this.sessionSubscribers.delete(sessionId);
       }
     }, delayMs);
@@ -6510,6 +7261,39 @@ var StreamerServer = class {
     const addr = this.httpServer.address();
     return typeof addr === "object" && addr ? addr.port : 0;
   }
+  currentWarmupState() {
+    let current = null;
+    for (const state of this.activeWarmups.values()) current = state;
+    return current;
+  }
+  beginWarmup(state) {
+    const id = this.nextWarmupId++;
+    this.activeWarmups.set(id, state);
+    return id;
+  }
+  finishWarmup(id) {
+    if (!this.activeWarmups.delete(id) || this.activeWarmups.size > 0) return;
+    this.wsHub.broadcast({ type: "cache_ready" });
+  }
+  async withWarmup(state, operation) {
+    const id = this.beginWarmup(state);
+    try {
+      return await operation();
+    } finally {
+      this.finishWarmup(id);
+    }
+  }
+  rejectIfWarmingUp(res) {
+    const warmupState = this.currentWarmupState();
+    if (!warmupState) return false;
+    const body = {
+      error: "Server is warming up",
+      code: "SERVER_WARMING_UP",
+      warmupState
+    };
+    json(res, 503, body);
+    return true;
+  }
   async listen(port, opts) {
     const dbConfig = this.disableDb ? null : getDbConfig();
     if (dbConfig) {
@@ -6533,13 +7317,16 @@ var StreamerServer = class {
         });
         try {
           this.cache = ConversationCache.open(
-            join15(this.cacheDir, "cache.db"),
+            join17(this.cacheDir, "cache.db"),
             this.tailSize,
             void 0,
             {
               filterAgentConversations: !this.includeAgents,
               agentEntrypoints: this.agentEntrypoints,
-              onAgentFileDetected: (fp) => this.fileWatcher.unwatch(fp)
+              onAgentFileDetected: (fp) => {
+                this.fileWatcher.unwatch(fp);
+                this.externalTails.delete(canonicalizeFilePath(fp));
+              }
             }
           );
           if (!this.includeAgents) {
@@ -6556,9 +7343,28 @@ var StreamerServer = class {
           this.conversationsRepo = new ConversationsRepository(this.cache);
           this.sessionsRepo = new SessionsRepository(this.sessionStore);
           this.cacheMetadataRepo = new CacheMetadataRepository(db);
+          this.cacheMonitor = new CacheIntegrityMonitor(
+            this.cache,
+            this.wsHub,
+            this.log,
+            this.cacheDir,
+            async () => {
+              const scanner = await this.rescanForRefresh();
+              return [...scanner.getMetadataCache().values()];
+            },
+            (operation) => {
+              const reset = this.withWarmup("cache_reset", operation);
+              this.trackCacheWrite(reset);
+              return reset;
+            }
+          );
           for (const dir of this.projectsDirs()) {
             this.fileWatcher.watchDirectory(dir);
           }
+          for (const dir of this.codexRoots) {
+            if (!existsSync10(dir)) continue;
+            this.fileWatcher.watchDirectory(dir);
+          }
         } 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");
@@ -6625,11 +7431,19 @@ var StreamerServer = class {
               }
             );
           }
-          const pruned = this.cache.pruneGhostFiles();
-          this.log.info(`Startup ghost prune: removed ${pruned.length} stale cache rows`, {
-            count: pruned.length,
-            event: "cache.prune_ghosts"
-          });
+          await this.cacheMonitor?.runDetection();
+          if (this.cacheMonitor?.pending) {
+            this.log.warn("Startup ghost prune skipped \u2014 cache integrity alert pending", {
+              fingerprint: this.cacheMonitor.pending.fingerprint,
+              event: "cache.prune_ghosts_frozen"
+            });
+          } else {
+            const pruned = this.cache.pruneGhostFiles();
+            this.log.info(`Startup ghost prune: removed ${pruned.length} stale cache rows`, {
+              count: pruned.length,
+              event: "cache.prune_ghosts"
+            });
+          }
         }).catch((err) => {
           const message = err instanceof Error ? err.message : String(err);
           this.log.warn(`Startup cache warm-up failed: ${message}`, {
@@ -6637,8 +7451,7 @@ var StreamerServer = class {
             event: "cache.warmup_failed"
           });
         }).finally(() => {
-          this.cacheReady = true;
-          this.wsHub.broadcast({ type: "cache_ready" });
+          this.finishWarmup(0);
           resolveWarm();
         });
       }
@@ -6741,6 +7554,7 @@ var StreamerServer = class {
     this.cache?.close();
     this.ptyManager.dispose();
     this.fileWatcher.dispose();
+    this.externalTails.clear();
     this.wsHub.dispose();
     this.pairTokens.dispose();
     if (this.dbPool) {
@@ -6869,6 +7683,7 @@ var StreamerServer = class {
     return this.checkRateLimit(this.sessionInputAttempts, sessionId, 500, 6e4);
   }
   async handleListConversations(url, res) {
+    if (this.rejectIfWarmingUp(res)) return;
     const limit = intParam(url, "limit", 50);
     const offset = intParam(url, "offset", 0);
     const sort = url.searchParams.get("sort") ?? "recent";
@@ -6876,14 +7691,13 @@ var StreamerServer = class {
     const providerFilter = url.searchParams.get("provider") ?? void 0;
     const bustCache = url.searchParams.get("refresh") === "1";
     if (bustCache && this.cache) {
-      const scanner2 = await this.rescanForRefresh();
+      const scanner2 = await this.withWarmup("conversation_refresh", () => this.rescanForRefresh());
       const metas2 = [...scanner2.getMetadataCache().values()];
       try {
         this.cache.upsertFromScannerMeta(metas2);
-        const livePaths = new Set(
-          metas2.map((m) => m.filePath).filter((p) => Boolean(p))
-        );
-        this.cache.reconcileDeletions(livePaths);
+        if (!this.cacheMonitor?.pending) {
+          this.cache.reconcileDeletions(canonicalLivePathSet(metas2));
+        }
       } catch (err) {
         this.log.warn(
           `refresh reconcile failed: ${err instanceof Error ? err.message : String(err)}`,
@@ -6958,6 +7772,7 @@ var StreamerServer = class {
     json(res, 200, { conversations: adapted, hasMore: offset + limit < total, offset, total });
   }
   async handleConversationsCount(url, res) {
+    if (this.rejectIfWarmingUp(res)) return;
     const project = url.searchParams.get("project") ?? void 0;
     const providerFilter = url.searchParams.get("provider") ?? void 0;
     const bustCache = url.searchParams.get("refresh") === "1";
@@ -6985,7 +7800,7 @@ var StreamerServer = class {
   // path — refresh=1 returns the cached total synchronously and this catches up.
   refreshCountInBackground() {
     this.trackCacheWrite(
-      (async () => {
+      this.withWarmup("conversation_refresh", async () => {
         try {
           const scanner = await this.getFreshScanner();
           if (this.cache) {
@@ -6997,13 +7812,15 @@ var StreamerServer = class {
             { event: "count.refresh_failed" }
           );
         }
-      })()
+      })
     );
   }
   handleSessionsCount(res) {
+    if (this.rejectIfWarmingUp(res)) return;
     json(res, 200, { total: this.sessionStore.list(this.ptyAttachedIds()).length });
   }
   handleGetRecentSessions(url, res) {
+    if (this.rejectIfWarmingUp(res)) return;
     const limit = intParam(url, "limit", 20);
     if (!this.cache) {
       json(res, 200, { sessions: [], total: 0 });
@@ -7014,6 +7831,7 @@ var StreamerServer = class {
       type: "conversation",
       id: c.id,
       status: "idle",
+      ownership: "historical",
       ptyAttached: false,
       projectId: c.projectId ?? void 0,
       projectPath: c.projectPath ?? "",
@@ -7040,21 +7858,19 @@ var StreamerServer = class {
     if (!this.cache) return void 0;
     if (!previousScanner) {
       const persisted = this.cache.getScannerStatCache();
-      return persisted.size > 0 ? persisted : void 0;
+      if (persisted.size === 0) return void 0;
+      const nativeKeyed = /* @__PURE__ */ new Map();
+      for (const [canonicalPath, entry] of persisted) {
+        nativeKeyed.set(toNativeFilePath(canonicalPath), entry);
+      }
+      return nativeKeyed;
     }
     const dbStats = this.cache.getFileStats();
     if (dbStats.size === 0) return void 0;
-    const metaByPath = /* @__PURE__ */ new Map();
-    if (previousScanner) {
-      for (const meta of previousScanner.getMetadataCache().values()) {
-        if (meta.filePath) metaByPath.set(meta.filePath, meta);
-      }
-    }
-    const statCache = /* @__PURE__ */ new Map();
-    for (const [filePath, stat3] of dbStats) {
-      const meta = metaByPath.get(filePath);
-      if (meta) statCache.set(filePath, { stat: stat3, meta });
-    }
+    const statCache = joinStatCacheByNativePath(
+      previousScanner.getMetadataCache().values(),
+      dbStats
+    );
     return statCache.size > 0 ? statCache : void 0;
   }
   // Returns the provider + codexRoots fragment to spread into every scan()/search() call.
@@ -7148,22 +7964,22 @@ var StreamerServer = class {
    */
   projectsDirs() {
     if (this.scanProfiles && this.scanProfiles.length > 0) {
-      return this.scanProfiles.filter((p) => p.enabled).map((p) => join15(p.configDir, "projects"));
+      return this.scanProfiles.filter((p) => p.enabled).map((p) => join17(p.configDir, "projects"));
     }
-    return [join15(homedir7(), ".claude", "projects")];
+    return [join17(homedir8(), ".claude", "projects")];
   }
   findJsonlPath(uuid) {
     const filename = `${uuid}.jsonl`;
     for (const projectsDir of this.projectsDirs()) {
-      if (!existsSync8(projectsDir)) continue;
-      for (const dir of readdirSync4(projectsDir)) {
-        const fp = join15(projectsDir, dir, filename);
-        if (existsSync8(fp)) return fp;
-        const projectDir = join15(projectsDir, dir);
+      if (!existsSync10(projectsDir)) continue;
+      for (const dir of readdirSync5(projectsDir)) {
+        const fp = join17(projectsDir, dir, filename);
+        if (existsSync10(fp)) return fp;
+        const projectDir = join17(projectsDir, dir);
         try {
-          for (const sub of readdirSync4(projectDir)) {
-            const subagentPath = join15(projectDir, sub, "subagents", filename);
-            if (existsSync8(subagentPath)) return subagentPath;
+          for (const sub of readdirSync5(projectDir)) {
+            const subagentPath = join17(projectDir, sub, "subagents", filename);
+            if (existsSync10(subagentPath)) return subagentPath;
           }
         } catch {
         }
@@ -7243,6 +8059,140 @@ var StreamerServer = class {
       this.wsHub.broadcast({ type: "conversation_event", sessionId, line });
     }
   }
+  // ─── External (non-PTY) live tails ───────────────────────────────
+  /** True when a managed (PTY) session owns the tail for this canonical path. */
+  isManagedTailPath(key) {
+    for (const watchedPath of this.sessionFileMap.values()) {
+      if (canonicalizeFilePath(watchedPath) === key) return true;
+    }
+    return false;
+  }
+  /**
+   * Attach a live tail to a JSONL nobody is tailing yet, when it was touched
+   * recently enough to look actively written by an external agent. Capped at
+   * EXTERNAL_TAIL_MAX with LRU eviction.
+   */
+  maybeAttachExternalTail(filePath) {
+    if (!filePath.endsWith(".jsonl")) return;
+    const key = canonicalizeFilePath(filePath);
+    if (this.externalTails.has(key)) return;
+    if (this.isManagedTailPath(key)) return;
+    let mtimeMs;
+    try {
+      mtimeMs = statSync8(filePath).mtimeMs;
+    } catch {
+      return;
+    }
+    const now = Date.now();
+    if (now - mtimeMs > EXTERNAL_TAIL_RECENCY_MS) return;
+    this.evictExternalTailsIfNeeded();
+    this.externalTails.set(key, {
+      conversationId: ConversationCache.conversationIdForFile(key),
+      lastActivityAt: now
+    });
+    this.fileWatcher.watch(filePath);
+    this.log.debug?.(`External tail attached: ${filePath}`, {
+      filePath,
+      tails: this.externalTails.size,
+      event: "external_tail.attach"
+    });
+  }
+  /** Stop tailing an external file and drop its bookkeeping. */
+  detachExternalTail(key) {
+    if (!this.externalTails.delete(key)) return;
+    this.fileWatcher.unwatch(key);
+    this.log.debug?.(`External tail detached: ${key}`, {
+      filePath: key,
+      event: "external_tail.detach"
+    });
+  }
+  /** Make room for one more tail by evicting the least recently active ones. */
+  evictExternalTailsIfNeeded() {
+    while (this.externalTails.size >= EXTERNAL_TAIL_MAX) {
+      let lruKey = null;
+      let lruAt = Number.POSITIVE_INFINITY;
+      for (const [key, entry] of this.externalTails) {
+        if (this.isManagedTailPath(key)) {
+          this.externalTails.delete(key);
+          return;
+        }
+        if (entry.lastActivityAt < lruAt) {
+          lruAt = entry.lastActivityAt;
+          lruKey = key;
+        }
+      }
+      if (!lruKey) return;
+      this.detachExternalTail(lruKey);
+    }
+  }
+  /**
+   * INFERRED activity for an externally-owned conversation, derived purely from
+   * how recently its JSONL grew (the external tail's bookkeeping). Returns
+   * undefined when we hold no tail for it, so a session we know nothing about
+   * reports no activity rather than a fabricated "quiet".
+   *
+   * This can never distinguish a generating agent from one blocked on a
+   * permission gate — gates render on the PTY screen and never reach the JSONL —
+   * which is why it is a separate field and not folded into `status`.
+   */
+  externalActivityFor(conversationId, now = Date.now()) {
+    for (const entry of this.externalTails.values()) {
+      if (entry.conversationId !== conversationId) continue;
+      return {
+        state: now - entry.lastActivityAt <= EXTERNAL_ACTIVE_WRITING_MS ? "active_writing" : "quiet",
+        lastEventAt: new Date(entry.lastActivityAt).toISOString(),
+        source: "jsonl"
+      };
+    }
+    return void 0;
+  }
+  /** Attach inferred `activity` to externally-owned sessions in a response set. */
+  withExternalActivity(sessions) {
+    if (this.externalTails.size === 0) return sessions;
+    const now = Date.now();
+    return sessions.map((s) => {
+      if (s.ownership !== "external") return s;
+      const activity = this.externalActivityFor(s.conversationId ?? s.id, now);
+      return activity ? { ...s, activity } : s;
+    });
+  }
+  /** Detach external tails idle past EXTERNAL_TAIL_IDLE_MS. */
+  sweepIdleExternalTails(now = Date.now()) {
+    for (const [key, entry] of [...this.externalTails]) {
+      if (this.isManagedTailPath(key)) {
+        this.externalTails.delete(key);
+        continue;
+      }
+      if (now - entry.lastActivityAt > EXTERNAL_TAIL_IDLE_MS) this.detachExternalTail(key);
+    }
+  }
+  /**
+   * Push appended lines from an externally-owned conversation. Reuses the exact
+   * conversation_events / conversation_event shapes mobile already consumes,
+   * keyed by the conversation UUID — an external session has no PTY, so it must
+   * never produce terminal_output / terminal_replay / session_ready, and never a
+   * session_update whose session.id is a conversation UUID (that would mint a
+   * phantom session row in the mobile cache). Question cards are likewise never
+   * derived here: with no PTY there is nothing that could deliver an answer.
+   */
+  broadcastExternalTailLines(filePath, lines, seqs) {
+    const key = canonicalizeFilePath(filePath);
+    const entry = this.externalTails.get(key);
+    if (!entry) return;
+    entry.lastActivityAt = Date.now();
+    const conversationId = this.cache?.getIdByFilePath(key);
+    if (!conversationId) return;
+    entry.conversationId = conversationId;
+    this.broadcastConversationLines(conversationId, lines, seqs);
+    const meta = this.cache?.getMetaById(conversationId);
+    this.wsHub.broadcast({
+      type: "conversation_updated",
+      conversationId,
+      messageCount: meta?.messageCount ?? 0,
+      lastActivity: meta?.lastActivity ?? (/* @__PURE__ */ new Date()).toISOString(),
+      ownership: "external"
+    });
+  }
   async findConversationByUuid(uuid) {
     const lookupId = this.resolveConversationLookupId(uuid);
     if (!this.scannerReady && !this.scanProfiles) {
@@ -7311,13 +8261,14 @@ var StreamerServer = class {
     if (!conv.filePath) return false;
     let mtimeMs = null;
     try {
-      mtimeMs = statSync6(conv.filePath).mtimeMs;
+      mtimeMs = statSync8(conv.filePath).mtimeMs;
     } catch {
       return false;
     }
     return isScannedSnapshotStale(conv.timestamp, mtimeMs);
   }
   async handleGetConversation(id, url, res, ifNoneMatch) {
+    if (this.rejectIfWarmingUp(res)) return;
     const conversation = await this.findConversationByUuid(id);
     if (!conversation && this.cache) {
       const isFirstLoad = !url.searchParams.has("before_index");
@@ -7645,7 +8596,7 @@ var StreamerServer = class {
     });
   }
   async handleListSessions(url, res) {
-    const DISCOVERY_TTL_MS = 15e3;
+    if (this.rejectIfWarmingUp(res)) return;
     const now = Date.now();
     if (!this.discoveryCache || now - this.discoveryCache.fetchedAt >= DISCOVERY_TTL_MS) {
       try {
@@ -7657,7 +8608,7 @@ var StreamerServer = class {
     }
     const hasPaginationParams = url.searchParams.has("limit") || url.searchParams.has("cursor") || url.searchParams.has("sortBy") || url.searchParams.has("order") || url.searchParams.has("status");
     if (!hasPaginationParams) {
-      json(res, 200, this.sessionStore.list(this.ptyAttachedIds()));
+      json(res, 200, this.withExternalActivity(this.sessionStore.list(this.ptyAttachedIds())));
       return;
     }
     const parsed = parseSessionListQuery(url);
@@ -7667,6 +8618,7 @@ var StreamerServer = class {
     }
     try {
       const page = this.sessionStore.paginate(this.ptyAttachedIds(), parsed.query);
+      page.sessions = this.withExternalActivity(page.sessions);
       json(res, 200, page);
     } catch (err) {
       if (err instanceof Error && err.message === "INVALID_CURSOR") {
@@ -7677,9 +8629,10 @@ var StreamerServer = class {
     }
   }
   handleGetSession(sessionId, res) {
+    if (this.rejectIfWarmingUp(res)) return;
     const session = this.sessionStore.get(sessionId, this.ptyAttachedIds());
     if (session) {
-      if (!existsSync8(session.projectPath)) {
+      if (!existsSync10(session.projectPath)) {
         session.failureReason = `Project directory not found: ${session.projectPath}`;
       }
       json(res, 200, session);
@@ -7693,7 +8646,6 @@ var StreamerServer = class {
     json(res, 404, { error: "Session not found" });
   }
   async handleResume(req, res) {
-    this.discoveryCache = null;
     const body = await readBody(req);
     const sessionId = body.sessionId ?? body.conversationId;
     if (!sessionId) {
@@ -7722,8 +8674,48 @@ var StreamerServer = class {
       json(res, 400, { error: "Could not determine project path" });
       return;
     }
+    let discovered = [];
+    const cached2 = this.discoveryCache;
+    if (cached2 && Date.now() - cached2.fetchedAt < DISCOVERY_TTL_MS) {
+      discovered = cached2.entries;
+    } else {
+      try {
+        discovered = await Promise.race([
+          discoverClaudeProcesses(),
+          new Promise(
+            (resolve2) => setTimeout(() => resolve2([]), RESUME_DISCOVERY_TIMEOUT_MS).unref?.()
+          )
+        ]);
+        if (discovered.length > 0) {
+          this.discoveryCache = { entries: discovered, fetchedAt: Date.now() };
+        }
+      } catch {
+      }
+    }
+    const busy = conversationBusy({
+      conversationId: sessionId,
+      projectPath,
+      jsonlPath,
+      discovered,
+      windowMs: resolveResumeBusyWindowMs(),
+      selfPtyEndedAt: this.selfPtyEndedAt.get(sessionId) ?? null
+    });
+    if (busy.busy && body.force !== true) {
+      json(res, 409, {
+        error: "This conversation looks active in another session",
+        code: "CONVERSATION_BUSY",
+        detectedBy: busy.detectedBy,
+        lastActivityMs: busy.lastActivityMs,
+        likelyOwner: busy.likelyOwner
+      });
+      return;
+    }
+    if (busy.busy) {
+      this.contendedSessions.add(sessionId);
+    }
     const cachedConvMeta = this.cache?.getMetaById(sessionId);
     const provider = coerceProviderForRunner(conv?.provider ?? cachedConvMeta?.provider);
+    this.discoveryCache = null;
     const session = await this.ptyManager.start(sessionId, {
       provider,
       projectPath,
@@ -7857,6 +8849,45 @@ var StreamerServer = class {
       json(res, 400, { error: message });
     }
   }
+  // Store + broadcast AskUserQuestion cards found in a JSONL batch for a watched
+  // session. Two P0 safety guards on top of the screen/JSONL de-dupe:
+  //   (a) contended file → suppress JSONL-derived cards entirely (a line may be
+  //       the OTHER owner's question); the streamer's own PTY questions still
+  //       arrive via the live-screen path (handleLiveQuestion), not suppressed.
+  //   (b) a JSONL question must never clobber a PTY-screen question that is a
+  //       DIFFERENT question — answering it would type into this streamer's PTY.
+  //       Same-content re-syncs (screen synthetic id → real toolUseId) still pass.
+  processJsonlQuestions(sessionId, lines) {
+    const priorPending = this.pendingQuestions.get(sessionId);
+    const priorToolUseId = priorPending?.toolUseId;
+    const contended = this.contendedSessions.has(sessionId);
+    const priorPtyKey = priorPending?.origin === "pty" ? questionContentKey(priorPending.questions) : null;
+    const foreignVsPty = (questions) => priorPtyKey !== null && questionContentKey(questions) !== priorPtyKey;
+    const { messages, pending } = questionsFromLines(sessionId, lines);
+    for (const p of pending) {
+      if (contended || foreignVsPty(p.questions)) continue;
+      const origin = priorPtyKey !== null && questionContentKey(p.questions) === priorPtyKey ? "pty" : "jsonl";
+      this.pendingQuestions.set(sessionId, { ...p, origin });
+      const t = setTimeout(() => {
+        if (this.pendingQuestions.get(sessionId)?.toolUseId === p.toolUseId) {
+          this.cancelPendingQuestion(sessionId);
+        }
+      }, 6e4);
+      t.unref();
+    }
+    for (const m of messages) {
+      if (contended || foreignVsPty(m.questions)) continue;
+      const key = questionContentKey(m.questions);
+      const broadcast = shouldBroadcastQuestion({
+        newContentKey: key,
+        lastContentKey: this.pendingQuestionKey.get(sessionId),
+        newToolUseId: m.toolUseId,
+        priorToolUseId
+      });
+      this.pendingQuestionKey.set(sessionId, key);
+      if (broadcast) this.wsHub.broadcast(m);
+    }
+  }
   cancelPendingQuestion(sessionId) {
     const pq = this.pendingQuestions.get(sessionId);
     if (!pq) return;
@@ -7873,7 +8904,7 @@ var StreamerServer = class {
     const key = questionContentKey(questions);
     if (this.pendingQuestionKey.get(sessionId) === key) return;
     const toolUseId = `screen:${sessionId}:${key.length}`;
-    this.pendingQuestions.set(sessionId, { toolUseId, questions });
+    this.pendingQuestions.set(sessionId, { toolUseId, questions, origin: "pty" });
     this.pendingQuestionKey.set(sessionId, key);
     this.wsHub.broadcast({ type: "question", sessionId, toolUseId, questions });
   }
@@ -8050,13 +9081,64 @@ var StreamerServer = class {
       json(res, 404, { error: "Discovered session not found" });
       return;
     }
-    const { projectPath, projectName, branch } = discSession;
+    const { branch } = discSession;
+    let { projectPath, projectName } = discSession;
     const convId = discSession.id;
     if (discSession.pid == null) {
       json(res, 400, { error: "Session has no known PID" });
       return;
     }
+    if (!projectPath) {
+      const jsonlPath = this.findJsonlPath(convId);
+      const jsonlCwd = jsonlPath ? await this.readCwdFromJsonl(jsonlPath) : null;
+      if (jsonlCwd) {
+        projectPath = jsonlCwd;
+        projectName = projectName || basename5(jsonlCwd);
+      }
+    }
+    if (!projectPath) {
+      this.log.warn("adopt: refusing, working directory unknown", {
+        event: "adopt.no_project_path",
+        sessionId,
+        pid: discSession.pid
+      });
+      json(res, 400, {
+        error: "Cannot take over this session: its working directory could not be determined on this platform",
+        code: "ADOPT_NO_PROJECT_PATH"
+      });
+      return;
+    }
+    const availability = classifyResumability(projectPath);
+    if (!availability.resumable) {
+      this.log.warn("adopt: refusing, project directory no longer exists", {
+        event: "adopt.project_path_missing",
+        sessionId,
+        pid: discSession.pid,
+        projectPath,
+        reason: availability.unavailable_reason
+      });
+      json(res, 400, {
+        error: "Cannot take over this session: its project directory no longer exists",
+        code: "ADOPT_PROJECT_PATH_MISSING",
+        reason: availability.unavailable_reason
+      });
+      return;
+    }
     this.ptyManager.killPid(discSession.pid);
+    const exited = await waitForProcessExit(discSession.pid, ADOPT_KILL_TIMEOUT_MS);
+    if (!exited) {
+      this.log.warn("adopt: external process did not exit; refusing to double-write", {
+        event: "adopt.kill_timeout",
+        sessionId,
+        pid: discSession.pid
+      });
+      json(res, 409, {
+        error: "The existing process did not exit; not starting a second agent on this conversation",
+        code: "ADOPT_KILL_TIMEOUT",
+        pid: discSession.pid
+      });
+      return;
+    }
     const session = await this.ptyManager.start(convId, {
       projectPath,
       projectName,
@@ -8087,7 +9169,7 @@ var StreamerServer = class {
         sessionStore: this.sessionStore,
         // biome-ignore lint/style/noNonNullAssertion: agentClient is set when agentConfig.enabled is true
         agentClient: this.agentClient,
-        conversationsDir: this.cacheDir ? join15(dirname8(this.cacheDir), "conversations") : "",
+        conversationsDir: this.cacheDir ? join17(dirname9(this.cacheDir), "conversations") : "",
         agentConfig: this.agentConfig
       });
       json(res, result.status, result.body);
@@ -8225,14 +9307,30 @@ var StreamerServer = class {
     } catch {
     }
   }
+  // Read just the `sessionId` field from a JSONL's first line, used by the
+  // watchForJsonl fallback to confirm a candidate file's identity before
+  // binding it. Reads only up to the first newline so a large actively-written
+  // file isn't slurped in full.
+  readFirstLineSessionId(filePath) {
+    try {
+      const content = readFileSync8(filePath, "utf8");
+      const nl = content.indexOf("\n");
+      const firstLine = nl === -1 ? content : content.slice(0, nl);
+      if (!firstLine.trim()) return null;
+      const obj = JSON.parse(firstLine);
+      return typeof obj.sessionId === "string" ? obj.sessionId : null;
+    } catch {
+      return null;
+    }
+  }
   // Watch the project directory for the JSONL file Claude creates for sessionId.
   // Once found, wire up structured event streaming. No rekeying needed — the UUID
   // was passed to Claude via --session-id so the filename matches from the start.
   watchForJsonl(sessionId, projectPath) {
     const encoded = projectPath.replace(/[/\\:.]/g, "-");
-    const projectsDir = join15(homedir7(), ".claude", "projects", encoded);
+    const projectsDir = join17(homedir8(), ".claude", "projects", encoded);
     const expectedFile = `${sessionId}.jsonl`;
-    const filePath = join15(projectsDir, expectedFile);
+    const filePath = join17(projectsDir, expectedFile);
     const deadline = Date.now() + 12e4;
     let watcher = null;
     const cleanup = () => {
@@ -8250,26 +9348,28 @@ var StreamerServer = class {
         cleanup();
         return;
       }
-      let resolvedFilePath = existsSync8(filePath) ? filePath : null;
-      if (!resolvedFilePath && existsSync8(projectsDir)) {
+      let resolvedFilePath = existsSync10(filePath) ? filePath : null;
+      if (!resolvedFilePath && existsSync10(projectsDir)) {
         try {
           const now = Date.now();
-          const recent = readdirSync4(projectsDir).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, mtime: statSync6(join15(projectsDir, f)).mtimeMs })).filter(({ mtime }) => now - mtime < 5e3).sort((a, b) => b.mtime - a.mtime)[0];
-          if (recent) resolvedFilePath = join15(projectsDir, recent.f);
+          const match = readdirSync5(projectsDir).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, mtime: statSync8(join17(projectsDir, f)).mtimeMs })).filter(({ mtime }) => now - mtime < 5e3).filter(
+            ({ f }) => basename5(f, ".jsonl") === sessionId || this.readFirstLineSessionId(join17(projectsDir, f)) === sessionId
+          ).sort((a, b) => b.mtime - a.mtime)[0];
+          if (match) resolvedFilePath = join17(projectsDir, match.f);
         } catch {
         }
       }
       if (!resolvedFilePath) return;
       cleanup();
       this.sessionFileMap.set(sessionId, resolvedFilePath);
-      this.fileWatcher.watch(resolvedFilePath);
       try {
-        const existing = readFileSync7(resolvedFilePath, "utf8").split("\n").filter(Boolean);
+        const existing = readFileSync8(resolvedFilePath, "utf8").split("\n").filter(Boolean);
         if (existing.length > 0) {
           this.broadcastConversationLines(sessionId, existing);
         }
       } catch {
       }
+      this.fileWatcher.watch(resolvedFilePath);
       if (this.scannerReady) {
         this.scannerStale = true;
       } else {
@@ -8303,7 +9403,7 @@ var StreamerServer = class {
   watchForCodexRollout(sessionId, projectPath) {
     const deadline = Date.now() + 12e4;
     const now = /* @__PURE__ */ new Date();
-    const dateDir = join15(
+    const dateDir = join17(
       String(now.getFullYear()),
       String(now.getMonth() + 1).padStart(2, "0"),
       String(now.getDate()).padStart(2, "0")
@@ -8316,7 +9416,7 @@ var StreamerServer = class {
     };
     const matchesProjectPath = (candidatePath) => {
       try {
-        const firstLine = readFileSync7(candidatePath, "utf8").split("\n", 1)[0];
+        const firstLine = readFileSync8(candidatePath, "utf8").split("\n", 1)[0];
         if (!firstLine) return null;
         const parsed = JSON.parse(firstLine);
         if (parsed?.type !== "session_meta") return null;
@@ -8344,18 +9444,18 @@ var StreamerServer = class {
         this.sessionStore.listManaged().filter((s) => s.id !== sessionId && s.boundConversationId != null).map((s) => s.boundConversationId)
       );
       for (const root of this.codexRoots) {
-        const sessionsDir = join15(root, dateDir);
-        if (!existsSync8(sessionsDir)) continue;
+        const sessionsDir = join17(root, dateDir);
+        if (!existsSync10(sessionsDir)) continue;
         let candidateFiles;
         try {
-          candidateFiles = readdirSync4(sessionsDir).filter((f) => f.endsWith(".jsonl"));
+          candidateFiles = readdirSync5(sessionsDir).filter((f) => f.endsWith(".jsonl"));
         } catch {
           continue;
         }
         const nowMs = Date.now();
-        const recentCandidates = candidateFiles.map((f) => ({ f, mtime: statSync6(join15(sessionsDir, f)).mtimeMs })).filter(({ mtime }) => nowMs - mtime < 1e4).sort((a, b) => b.mtime - a.mtime);
+        const recentCandidates = candidateFiles.map((f) => ({ f, mtime: statSync8(join17(sessionsDir, f)).mtimeMs })).filter(({ mtime }) => nowMs - mtime < 1e4).sort((a, b) => b.mtime - a.mtime);
         for (const { f } of recentCandidates) {
-          const candidatePath = join15(sessionsDir, f);
+          const candidatePath = join17(sessionsDir, f);
           const match = matchesProjectPath(candidatePath);
           if (!match) continue;
           if (boundElsewhere.has(match.id)) continue;
@@ -8365,7 +9465,7 @@ var StreamerServer = class {
           this.sessionFileMap.set(sessionId, candidatePath);
           this.fileWatcher.watch(candidatePath);
           try {
-            const existing = readFileSync7(candidatePath, "utf8").split("\n").filter(Boolean);
+            const existing = readFileSync8(candidatePath, "utf8").split("\n").filter(Boolean);
             if (existing.length > 0) {
               this.broadcastConversationLines(sessionId, existing);
             }
@@ -8485,9 +9585,21 @@ var StreamerServer = class {
     json(res, 200, this.cache.listSessionNames());
   }
 };
+async function waitForProcessExit(pid, timeoutMs, pollMs = ADOPT_KILL_POLL_MS) {
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    try {
+      process.kill(pid, 0);
+    } catch {
+      return true;
+    }
+    if (Date.now() >= deadline) return false;
+    await new Promise((resolve2) => setTimeout(resolve2, pollMs));
+  }
+}
 function classifyResumability(cwd) {
   if (!cwd) return { resumable: true };
-  if (existsSync8(cwd)) return { resumable: true };
+  if (existsSync10(cwd)) return { resumable: true };
   const ranInWorktree = /\/\.worktrees\//.test(cwd) || /\/\.claude\/worktrees\//.test(cwd);
   return {
     resumable: false,
@@ -8502,6 +9614,9 @@ function conversationToResumableSession(c) {
     id: c.id,
     conversationId: c.id,
     status: "on_hold",
+    // A cached conversation with no process behind it. Distinguishes "nobody is
+    // running this" from an external session that IS live (ownership "external").
+    ownership: "historical",
     ptyAttached: false,
     projectId: c.projectId ?? void 0,
     projectPath: c.projectPath ?? "",