@threadbase-sh/streamer 1.29.1 → 1.30.0

package/dist/index.cjs

@@ -215,7 +215,7 @@ function verifySignature(rawBody, signature, secret) {
   }
 }
 function isWithinSkew(timestampHeader, skewSeconds) {
-  if (!timestampHeader) return true;
+  if (!timestampHeader) return false;
   const t = Number(timestampHeader);
   if (!Number.isFinite(t)) return false;
   const now = Math.floor(Date.now() / 1e3);
@@ -552,13 +552,13 @@ async function createPool(config) {
 }
 
 // src/live-session-manager.ts
-var import_path6 = require("path");
+var import_path7 = require("path");
 
 // src/codex-pty-runner.ts
 var import_headless = require("@xterm/headless");
 var import_crypto2 = require("crypto");
-var import_fs4 = require("fs");
-var import_path4 = require("path");
+var import_fs5 = require("fs");
+var import_path5 = require("path");
 
 // src/logger.ts
 var import_pino = __toESM(require("pino"), 1);
@@ -732,6 +732,69 @@ function isProviderResumable(_provider, availabilityResumable) {
   return availabilityResumable;
 }
 
+// src/services/questions/codexGateAnswers.ts
+var import_fs4 = require("fs");
+var import_os3 = require("os");
+var import_path4 = require("path");
+function gateAnswersPath() {
+  const dir = process.env.THREADBASE_CONFIG_DIR ?? (0, import_path4.join)((0, import_os3.homedir)(), ".threadbase");
+  return (0, import_path4.join)(dir, "gate-answers.json");
+}
+function loadGateAnswers() {
+  try {
+    const parsed = JSON.parse((0, import_fs4.readFileSync)(gateAnswersPath(), "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function saveGateAnswer(key, value) {
+  const path = gateAnswersPath();
+  (0, import_fs4.mkdirSync)((0, import_path4.dirname)(path), { recursive: true });
+  (0, import_fs4.writeFileSync)(path, `${JSON.stringify({ ...loadGateAnswers(), [key]: value }, null, 2)}
+`);
+}
+function rememberedGateDigit(gate) {
+  const answers = loadGateAnswers();
+  if (gate === "hooks") {
+    if (answers.codexHooksGate === "trust_all") return "2";
+    if (answers.codexHooksGate === "continue_untrusted") return "3";
+    return null;
+  }
+  return answers.codexTrustGate === "yes" ? "1" : null;
+}
+
+// src/utils/debounce.ts
+function debounce(fn, waitMs) {
+  let timer = null;
+  let lastArgs = null;
+  const run2 = () => {
+    timer = null;
+    if (lastArgs) {
+      const args = lastArgs;
+      lastArgs = null;
+      fn(...args);
+    }
+  };
+  const debounced = (...args) => {
+    lastArgs = args;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(run2, waitMs);
+  };
+  debounced.cancel = () => {
+    if (timer) clearTimeout(timer);
+    timer = null;
+    lastArgs = null;
+  };
+  debounced.flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      run2();
+    }
+  };
+  return debounced;
+}
+
 // src/codex-pty-runner.ts
 var OUTPUT_BUFFER_MAX = 65536;
 var PTY_COLS = 120;
@@ -739,6 +802,9 @@ var PTY_ROWS = 40;
 var SCREEN_SCROLLBACK = 1e3;
 var CODEX_PROMPT_READY_TEXT = "Ready";
 var CODEX_TRUST_GATE_REGEX = /trust the contents/i;
+var CODEX_HOOKS_GATE_REGEX = /hooks need review/i;
+var QUIET_DETECT_MS = 500;
+var CODEX_READY_FALLBACK_MS = 8e3;
 var SUBMIT_BYTES = "\r";
 var CODEX_SUBMIT_DELAY_MS = 16;
 function digestBytes(s) {
@@ -746,6 +812,40 @@ function digestBytes(s) {
   if (escaped.length <= 200) return escaped;
   return `${escaped.slice(0, 100)}\u2026[${escaped.length - 200}B omitted]\u2026${escaped.slice(-100)}`;
 }
+function gateCard(gate, lines) {
+  if (gate === "hooks") {
+    const countLine = lines.find((l) => /new or changed/i.test(l))?.trim();
+    return {
+      prompt: [
+        "Hooks need review",
+        countLine,
+        "Hooks can run outside the sandbox after you trust them."
+      ].filter(Boolean).join(" \u2014 "),
+      options: [
+        { index: 2, label: "Trust all and continue", answerKeys: "2\r" },
+        { index: 3, label: "Continue without trusting (hooks won't run)", answerKeys: "3\r" },
+        {
+          index: 4,
+          label: "Trust all and continue (remember for all projects)",
+          answerKeys: "4\r"
+        },
+        {
+          index: 5,
+          label: "Continue without trusting (remember for all projects)",
+          answerKeys: "5\r"
+        }
+      ]
+    };
+  }
+  return {
+    prompt: lines.find((l) => CODEX_TRUST_GATE_REGEX.test(l))?.trim() ?? "Do you trust the contents of this directory?",
+    options: [
+      { index: 1, label: "Yes, continue", answerKeys: "1\r" },
+      { index: 2, label: "No, quit", answerKeys: "2\r" },
+      { index: 3, label: "Yes, continue (remember for all projects)", answerKeys: "3\r" }
+    ]
+  };
+}
 var pty = null;
 async function loadPty() {
   if (pty) return pty;
@@ -772,8 +872,8 @@ var CodexPtyRunner = class {
   onOutput;
   onStatusChange;
   onReady;
-  // Accepted for shape-compatibility with PTYManagerOptions; Codex has no
-  // detected equivalent yet (Phase 0) — never invoked.
+  // Broadcasts Codex's blocking startup gates (directory trust, hooks review)
+  // as question cards; null dismisses the card once the gate leaves the screen.
   onPermissionChange;
   onLiveQuestion;
   onLiveQuestionGone;
@@ -784,8 +884,18 @@ var CodexPtyRunner = class {
   // Inputs received via sendInput() while the session was still pendingReady.
   // Flushed in arrival order once Codex reaches Ready.
   queuedInputs = /* @__PURE__ */ new Map();
-  // Per-session debounce so the directory-trust gate's \r is only written once.
-  trustGateAnswered = /* @__PURE__ */ new Set();
+  // Gate currently on a session's screen (card broadcast, unanswered). While
+  // set, queued-input flushes are held — a flushed digit would CONFIRM a
+  // dialog option — and sendKeys() intercepts remember-variant digits.
+  openGate = /* @__PURE__ */ new Map();
+  // `${sessionId}:${gate}` once a gate has been actioned (auto-answered or
+  // card broadcast) — dedupes repaints of the same dialog.
+  gateActioned = /* @__PURE__ */ new Set();
+  // Per-session trailing debounce re-armed on every chunk; on quiet, re-runs
+  // screen detection so a blocked/truncated boot still reaches ready.
+  quietCheckers = /* @__PURE__ */ new Map();
+  // Per-session flat backstop from spawn (CODEX_READY_FALLBACK_MS).
+  readyFallbackTimers = /* @__PURE__ */ new Map();
   // In-flight start()/startFresh() calls keyed by sessionId. A second
   // concurrent resume for the same session (double-tap, client retry) awaits
   // the first call's promise instead of spawning a duplicate PTY (CRITICAL #3).
@@ -815,7 +925,7 @@ var CodexPtyRunner = class {
   }
   async doStart(sessionId, options) {
     const nodePty = await loadPty();
-    const projectName = options.projectName ?? (0, import_path4.basename)(options.projectPath);
+    const projectName = options.projectName ?? (0, import_path5.basename)(options.projectPath);
     const proc = nodePty.spawn(
       resolveCodexExe(),
       ["resume", sessionId, "--cd", options.projectPath, "--no-alt-screen"],
@@ -844,6 +954,7 @@ var CodexPtyRunner = class {
     };
     this.sessions.set(sessionId, session);
     this.pendingReady.add(sessionId);
+    this.armReadyFallback(sessionId);
     proc.onData((data) => {
       this.handleOutput(sessionId, data);
     });
@@ -860,7 +971,7 @@ var CodexPtyRunner = class {
   async startFresh(options) {
     const nodePty = await loadPty();
     const sessionId = (0, import_crypto2.randomUUID)();
-    const projectName = options.projectName ?? (0, import_path4.basename)(options.projectPath);
+    const projectName = options.projectName ?? (0, import_path5.basename)(options.projectPath);
     const args = ["--cd", options.projectPath, "--no-alt-screen"];
     if (options.systemPrompt) {
       args.push(options.systemPrompt);
@@ -889,6 +1000,7 @@ var CodexPtyRunner = class {
     };
     this.sessions.set(sessionId, session);
     this.pendingReady.add(sessionId);
+    this.armReadyFallback(sessionId);
     proc.onData((data) => {
       this.handleOutput(sessionId, data);
     });
@@ -898,6 +1010,21 @@ var CodexPtyRunner = class {
     });
     return toPublicSession(session);
   }
+  // Flat backstop: if neither the "Ready" marker nor the quiet-checker settled
+  // the session within CODEX_READY_FALLBACK_MS of spawn, mark it ready anyway
+  // so start requests resolve and mobile can watch the boot live. unref() so a
+  // pending timer never holds the process open.
+  armReadyFallback(sessionId) {
+    const timer = setTimeout(() => {
+      this.readyFallbackTimers.delete(sessionId);
+      const session = this.sessions.get(sessionId);
+      if (session?.status === "running" && this.pendingReady.has(sessionId)) {
+        this.markReady(sessionId, session, "fallback:timeout");
+      }
+    }, CODEX_READY_FALLBACK_MS);
+    timer.unref?.();
+    this.readyFallbackTimers.set(sessionId, timer);
+  }
   // Write raw key bytes directly to the PTY, same as PTYManager.sendKeys.
   sendKeys(sessionId, keys) {
     const session = this.sessions.get(sessionId);
@@ -909,13 +1036,47 @@ var CodexPtyRunner = class {
       session.status = "running";
       this.onStatusChange?.(toPublicSession(session));
     }
+    const gate = this.openGate.get(sessionId);
+    const digit = gate ? /^([0-9])\r?$/.exec(keys)?.[1] : void 0;
+    const out = gate && digit ? this.resolveGateAnswer(sessionId, gate, digit) : keys;
     this.log.info(
-      `[codex.keys.write] ${sessionId.slice(0, 8)} bytes=${keys.length} digest=${digestBytes(keys)}`,
-      { event: "codex.keys_write", sessionId, byteLen: keys.length }
+      `[codex.keys.write] ${sessionId.slice(0, 8)} bytes=${out.length} digest=${digestBytes(out)}`,
+      { event: "codex.keys_write", sessionId, byteLen: out.length }
     );
-    session.process.write(keys);
+    session.process.write(out);
     session.lastActivityAt = /* @__PURE__ */ new Date();
   }
+  // Map a gate-card digit to the PTY bytes that answer the real dialog,
+  // persisting the choice when the digit was a synthetic "remember for all
+  // projects" option (those numbers don't exist on the actual dialog and must
+  // never reach codex). The trailing \r mobile sends is dropped: a digit alone
+  // selects AND confirms (live-probe verified), and a stray Enter would land
+  // on whatever screen follows.
+  resolveGateAnswer(sessionId, gate, digit) {
+    let real = digit;
+    let remembered = false;
+    if (gate === "hooks" && digit === "4") {
+      saveGateAnswer("codexHooksGate", "trust_all");
+      real = "2";
+      remembered = true;
+    } else if (gate === "hooks" && digit === "5") {
+      saveGateAnswer("codexHooksGate", "continue_untrusted");
+      real = "3";
+      remembered = true;
+    } else if (gate === "trust" && digit === "3") {
+      saveGateAnswer("codexTrustGate", "yes");
+      real = "1";
+      remembered = true;
+    }
+    this.log.info(`[codex.gate_answer] ${sessionId.slice(0, 8)} ${gate} digit=${real}`, {
+      event: "codex.gate_answer",
+      sessionId,
+      gate,
+      digit: real,
+      remembered
+    });
+    return real;
+  }
   sendInput(sessionId, input) {
     const session = this.sessions.get(sessionId);
     if (!session) throw new Error(`Session not found: ${sessionId}`);
@@ -985,8 +1146,12 @@ var CodexPtyRunner = class {
     }, CODEX_SUBMIT_DELAY_MS);
   }
   // Drain any inputs sent while the session was still pendingReady, writing
-  // them in arrival order now that Codex is Ready.
+  // them in arrival order now that Codex is Ready. No-op while a gate dialog
+  // is open (a flushed digit would confirm a dialog option) or while still
+  // pendingReady (markReady drains it) — the gate-close path re-drives it for
+  // the ready-with-gate-open case.
   flushQueuedInputs(sessionId) {
+    if (this.openGate.has(sessionId) || this.pendingReady.has(sessionId)) return;
     const queue = this.queuedInputs.get(sessionId);
     if (!queue || queue.length === 0) return;
     this.queuedInputs.delete(sessionId);
@@ -1031,7 +1196,7 @@ var CodexPtyRunner = class {
     if (!session) return;
     this.pendingReady.delete(sessionId);
     this.queuedInputs.delete(sessionId);
-    this.trustGateAnswered.delete(sessionId);
+    this.clearSessionDetectors(sessionId);
     try {
       session.process.kill("SIGINT");
     } catch {
@@ -1042,6 +1207,21 @@ var CodexPtyRunner = class {
     this.sessions.delete(sessionId);
     this.onStatusChange?.(toPublicSession(session));
   }
+  // Drop a session's detection state: quiet-checker, ready-fallback timer,
+  // gate bookkeeping — and dismiss a still-open gate card so mobile doesn't
+  // keep rendering a question for a dead PTY.
+  clearSessionDetectors(sessionId) {
+    this.quietCheckers.get(sessionId)?.cancel();
+    this.quietCheckers.delete(sessionId);
+    const timer = this.readyFallbackTimers.get(sessionId);
+    if (timer) clearTimeout(timer);
+    this.readyFallbackTimers.delete(sessionId);
+    if (this.openGate.delete(sessionId)) {
+      this.onPermissionChange?.(sessionId, null);
+    }
+    this.gateActioned.delete(`${sessionId}:hooks`);
+    this.gateActioned.delete(`${sessionId}:trust`);
+  }
   getOutput(sessionId) {
     const session = this.sessions.get(sessionId);
     if (!session) throw new Error(`Session not found: ${sessionId}`);
@@ -1081,10 +1261,19 @@ var CodexPtyRunner = class {
       }
       session.screen.dispose();
     }
+    for (const sessionId of Array.from(this.quietCheckers.keys())) {
+      this.clearSessionDetectors(sessionId);
+    }
+    for (const timer of this.readyFallbackTimers.values()) {
+      clearTimeout(timer);
+    }
     this.sessions.clear();
     this.pendingReady.clear();
     this.queuedInputs.clear();
-    this.trustGateAnswered.clear();
+    this.openGate.clear();
+    this.gateActioned.clear();
+    this.quietCheckers.clear();
+    this.readyFallbackTimers.clear();
   }
   handleOutput(sessionId, data) {
     const session = this.sessions.get(sessionId);
@@ -1099,44 +1288,92 @@ var CodexPtyRunner = class {
     session.screen.write(data);
     session.lastOutput = stripAnsi(data);
     this.onOutput?.(sessionId, data);
-    this.detectReady(sessionId, session).catch((err) => {
+    this.detectScreenState(sessionId, "chunk").catch((err) => {
       this.log.warn("[codex.ready_detect] failed", {
         event: "codex.ready_detect_failed",
         sessionId,
         err
       });
     });
+    let quiet = this.quietCheckers.get(sessionId);
+    if (!quiet) {
+      quiet = debounce(() => {
+        this.detectScreenState(sessionId, "quiet").catch((err) => {
+          this.log.warn("[codex.ready_detect] failed", {
+            event: "codex.ready_detect_failed",
+            sessionId,
+            err
+          });
+        });
+      }, QUIET_DETECT_MS);
+      this.quietCheckers.set(sessionId, quiet);
+    }
+    quiet();
   }
-  // Renders the session's headless screen and checks for the directory-trust
-  // gate (answered once, debounced) and the "Ready" status-bar text. Only
-  // transitions to waiting_input / fires onReady when the rendered status
-  // line literally contains "Ready" — `›` alone (visible during "Starting")
-  // is NOT a valid readiness signal (Phase 0).
-  async detectReady(sessionId, session) {
-    if (session.status !== "running" || !this.pendingReady.has(sessionId)) return;
+  // Renders the session's headless screen and drives both detections:
+  //   - Gates (directory trust, hooks review) — checked on EVERY pass,
+  //     independent of pendingReady, so a gate appearing after ready is still
+  //     surfaced and a gate leaving the screen closes its card.
+  //   - Readiness — the "Ready" status-bar marker while pendingReady, plus the
+  //     quiet path: after QUIET_DETECT_MS of PTY silence a still-pending
+  //     session is marked ready anyway (`›` alone is NOT a marker — Phase 0 —
+  //     but a quiet boot screen is more useful to the user live than a
+  //     spinner, and "Ready" may be truncated off the 120-col status bar).
+  async detectScreenState(sessionId, trigger) {
+    const session = this.sessions.get(sessionId);
+    if (!session || session.status === "idle") return;
     const lines = await this.getOutputLines(sessionId, PTY_ROWS);
     const screenText = lines.join("\n");
-    if (CODEX_TRUST_GATE_REGEX.test(screenText)) {
-      if (!this.trustGateAnswered.has(sessionId)) {
-        this.trustGateAnswered.add(sessionId);
-        this.log.info(`[codex.trust_gate] ${sessionId.slice(0, 8)} auto-answering`, {
-          event: "codex.trust_gate",
-          sessionId
-        });
-        session.process.write("\r");
-      }
-      return;
+    const gate = CODEX_HOOKS_GATE_REGEX.test(screenText) ? "hooks" : CODEX_TRUST_GATE_REGEX.test(screenText) ? "trust" : null;
+    if (gate) {
+      this.handleGate(sessionId, session, gate, lines);
+    } else if (this.openGate.delete(sessionId)) {
+      this.onPermissionChange?.(sessionId, null);
+      this.flushQueuedInputs(sessionId);
     }
+    if (session.status !== "running" || !this.pendingReady.has(sessionId)) return;
     const lastNonBlank2 = [...lines].reverse().find((l) => l.trim() !== "") ?? "";
-    if (!lastNonBlank2.includes(CODEX_PROMPT_READY_TEXT)) return;
-    this.markReady(sessionId, session);
+    if (lastNonBlank2.includes(CODEX_PROMPT_READY_TEXT)) {
+      this.markReady(sessionId, session, `marker:${CODEX_PROMPT_READY_TEXT}`);
+    } else if (trigger === "quiet") {
+      this.markReady(sessionId, session, "quiet:timeout");
+    }
+  }
+  // Answer a gate from the persisted remember-store, or surface it as a
+  // question card over the permission transport. Actioned once per session and
+  // gate type — repaints of the same dialog neither re-write nor re-broadcast.
+  handleGate(sessionId, session, gate, lines) {
+    const key = `${sessionId}:${gate}`;
+    if (this.gateActioned.has(key)) return;
+    this.gateActioned.add(key);
+    const remembered = rememberedGateDigit(gate);
+    if (remembered) {
+      this.log.info(`[codex.gate_auto_answer] ${sessionId.slice(0, 8)} ${gate} \u2192 ${remembered}`, {
+        event: "codex.gate_auto_answer",
+        sessionId,
+        gate,
+        digit: remembered
+      });
+      session.process.write(remembered);
+      return;
+    }
+    this.openGate.set(sessionId, gate);
+    const card = gateCard(gate, lines);
+    this.log.info(`[codex.gate_prompt] ${sessionId.slice(0, 8)} ${gate}`, {
+      event: "codex.gate_prompt",
+      sessionId,
+      gate,
+      prompt: card.prompt
+    });
+    this.onPermissionChange?.(sessionId, card);
   }
-  markReady(sessionId, session) {
+  markReady(sessionId, session, reason) {
     session.lastActivityAt = /* @__PURE__ */ new Date();
     session.status = "waiting_input";
-    this.log.info(`[codex.ready] ${sessionId.slice(0, 8)}`, {
+    this.log.info(`[codex.ready] ${sessionId.slice(0, 8)} ${reason}`, {
       event: "codex.ready",
-      sessionId
+      sessionId,
+      reason
     });
     this.onStatusChange?.(toPublicSession(session));
     if (this.pendingReady.has(sessionId)) {
@@ -1152,7 +1389,7 @@ var CodexPtyRunner = class {
     session.status = "idle";
     const elapsedMs = session.completedAt.getTime() - session.startedAt.getTime();
     if (exitCode !== 0 && elapsedMs < 2e3 && session.lastOutput === "") {
-      if (!(0, import_fs4.existsSync)(session.projectPath)) {
+      if (!(0, import_fs5.existsSync)(session.projectPath)) {
         session.failureReason = `Project directory not found: ${session.projectPath}`;
       } else {
         session.failureReason = `Codex process exited immediately (code ${exitCode}).`;
@@ -1162,7 +1399,7 @@ var CodexPtyRunner = class {
     session.screen.dispose();
     this.sessions.delete(sessionId);
     this.queuedInputs.delete(sessionId);
-    this.trustGateAnswered.delete(sessionId);
+    this.clearSessionDetectors(sessionId);
   }
 };
 function toPublicSession(s) {
@@ -1189,8 +1426,8 @@ function stripAnsi(str) {
 // src/pty-manager.ts
 var import_headless2 = require("@xterm/headless");
 var import_crypto3 = require("crypto");
-var import_fs5 = require("fs");
-var import_path5 = require("path");
+var import_fs6 = require("fs");
+var import_path6 = require("path");
 
 // src/services/questions/detectPermissionGate.ts
 var OSC_777_RE = /\x1b\]777;notify;Claude Code;[^\x07\x1b]*/;
@@ -1345,9 +1582,15 @@ function detectShellPrompt(lines) {
       ]
     };
   }
-  if (NUMBERED_RE.test(last.text)) {
+  const lastNumberedIdx = (() => {
+    for (let i = last.idx; i >= 0; i--) {
+      if (NUMBERED_RE.test(lines[i])) return i;
+    }
+    return -1;
+  })();
+  if (lastNumberedIdx >= 0) {
     const options = [];
-    for (let i = 0; i <= last.idx; i++) {
+    for (let i = 0; i <= lastNumberedIdx; i++) {
       const m = NUMBERED_RE.exec(lines[i]);
       if (!m) continue;
       const num = Number.parseInt(m[1], 10);
@@ -1375,37 +1618,6 @@ function detectShellPrompt(lines) {
   return null;
 }
 
-// src/utils/debounce.ts
-function debounce(fn, waitMs) {
-  let timer = null;
-  let lastArgs = null;
-  const run2 = () => {
-    timer = null;
-    if (lastArgs) {
-      const args = lastArgs;
-      lastArgs = null;
-      fn(...args);
-    }
-  };
-  const debounced = (...args) => {
-    lastArgs = args;
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(run2, waitMs);
-  };
-  debounced.cancel = () => {
-    if (timer) clearTimeout(timer);
-    timer = null;
-    lastArgs = null;
-  };
-  debounced.flush = () => {
-    if (timer) {
-      clearTimeout(timer);
-      run2();
-    }
-  };
-  return debounced;
-}
-
 // src/pty-manager.ts
 var OUTPUT_BUFFER_MAX2 = 65536;
 var PTY_COLS2 = 120;
@@ -1413,7 +1625,7 @@ var PTY_ROWS2 = 40;
 var SCREEN_SCROLLBACK2 = 1e3;
 var CLAUDE_PROMPT_MARKERS = ["\u256D", "\u276F"];
 var PROMPT_MARKER_FALLBACK_MS = 1e4;
-var QUIET_DETECT_MS = 500;
+var QUIET_DETECT_MS2 = 500;
 function buildPasteBytes(input) {
   return `\x1B[200~${input}\x1B[201~`;
 }
@@ -1541,7 +1753,7 @@ var PTYManager = class {
   }
   async doStart(sessionId, options) {
     const nodePty = await loadPty2();
-    const projectName = options.projectName ?? (0, import_path5.basename)(options.projectPath);
+    const projectName = options.projectName ?? (0, import_path6.basename)(options.projectPath);
     const proc = nodePty.spawn(
       resolveClaudeExe(),
       [
@@ -1592,7 +1804,7 @@ var PTYManager = class {
   async startFresh(options) {
     const nodePty = await loadPty2();
     const sessionId = (0, import_crypto3.randomUUID)();
-    const projectName = options.projectName ?? (0, import_path5.basename)(options.projectPath);
+    const projectName = options.projectName ?? (0, import_path6.basename)(options.projectPath);
     const args = [
       "--permission-mode",
       options.permissionMode ?? "acceptEdits",
@@ -1913,7 +2125,7 @@ var PTYManager = class {
     });
     let quiet = this.quietCheckers.get(sessionId);
     if (!quiet) {
-      quiet = debounce(() => this.handleQuiet(sessionId), QUIET_DETECT_MS);
+      quiet = debounce(() => this.handleQuiet(sessionId), QUIET_DETECT_MS2);
       this.quietCheckers.set(sessionId, quiet);
     }
     quiet();
@@ -2036,7 +2248,7 @@ var PTYManager = class {
     session.status = "idle";
     const elapsedMs = session.completedAt.getTime() - session.startedAt.getTime();
     if (exitCode !== 0 && elapsedMs < 2e3 && session.lastOutput === "") {
-      if (!(0, import_fs5.existsSync)(session.projectPath)) {
+      if (!(0, import_fs6.existsSync)(session.projectPath)) {
         session.failureReason = `Project directory not found: ${session.projectPath}`;
       } else {
         session.failureReason = `Process exited immediately (code ${exitCode}). Check that the Claude binary is installed and accessible.`;
@@ -2164,7 +2376,7 @@ var LiveSessionManager = class {
     const runner = this.runners.get(provider);
     if (runner) return runner;
     const err = new Error(
-      `Live ${provider} sessions are not implemented yet for ${(0, import_path6.basename)(projectPath)}`
+      `Live ${provider} sessions are not implemented yet for ${(0, import_path7.basename)(projectPath)}`
     );
     err.statusCode = 501;
     throw err;
@@ -2173,10 +2385,10 @@ var LiveSessionManager = class {
 
 // src/process-discovery.ts
 var import_child_process2 = require("child_process");
-var import_os3 = require("os");
-var import_path7 = require("path");
+var import_os4 = require("os");
+var import_path8 = require("path");
 async function discoverClaudeProcesses() {
-  if ((0, import_os3.platform)() === "win32") return discoverWindows();
+  if ((0, import_os4.platform)() === "win32") return discoverWindows();
   return discoverUnix();
 }
 async function discoverUnix() {
@@ -2193,7 +2405,7 @@ async function discoverUnix() {
         return {
           pid,
           projectPath: cwd,
-          projectName: (0, import_path7.basename)(cwd),
+          projectName: (0, import_path8.basename)(cwd),
           branch: await readGitBranch(cwd),
           conversationId,
           startedAt
@@ -2215,7 +2427,7 @@ async function discoverWindows() {
         return {
           pid,
           projectPath: info.cwd,
-          projectName: (0, import_path7.basename)(info.cwd),
+          projectName: (0, import_path8.basename)(info.cwd),
           branch: await readGitBranch(info.cwd),
           conversationId: extractResumeId(info.args),
           startedAt: info.startedAt
@@ -2296,7 +2508,7 @@ async function getProcessInfoWindows(pid) {
     const startedAt = /* @__PURE__ */ new Date(`${year}-${month}-${day}T${hour}:${min}:${sec}`);
     if (Number.isNaN(startedAt.getTime())) return null;
     const exePath = parts[3] ?? "";
-    const cwd = exePath ? (0, import_path7.dirname)(exePath) : "";
+    const cwd = exePath ? (0, import_path8.dirname)(exePath) : "";
     return { cwd, args, startedAt };
   } catch {
     return null;
@@ -2319,11 +2531,11 @@ var import_node_ws = require("@hono/node-ws");
 var import_client = require("@temporalio/client");
 var import_scanner3 = require("@threadbase-sh/scanner");
 var import_events = require("events");
-var import_fs12 = require("fs");
+var import_fs13 = require("fs");
 var import_promises7 = require("fs/promises");
 var import_http = require("http");
-var import_os6 = require("os");
-var import_path13 = require("path");
+var import_os7 = require("os");
+var import_path14 = require("path");
 var import_readline = require("readline");
 
 // node_modules/nanoid/index.js
@@ -2582,14 +2794,15 @@ async function handleStartAgentSession(body, deps) {
 }
 
 // src/api/app.ts
-var import_hono11 = require("hono");
+var import_hono12 = require("hono");
 
 // src/api/middleware/auth.middleware.ts
 function isLocalRequest(remoteAddr) {
   const addr = remoteAddr ?? "";
   return addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
 }
-var PUBLIC_PATHS = /* @__PURE__ */ new Set(["/healthz"]);
+var PUBLIC_PATHS = /* @__PURE__ */ new Set(["/healthz", "/ws"]);
+var LOCAL_ONLY_PATHS = /* @__PURE__ */ new Set(["/api/logs", "/api/logs/meta"]);
 var PUBLIC_POST_PATHS = /* @__PURE__ */ new Set(["/api/pair/exchange", "/api/__update"]);
 var PUBLIC_POST_PREFIXES = ["/internal/sessions/"];
 var authMiddleware = (deps) => async (c, next) => {
@@ -2600,8 +2813,12 @@ var authMiddleware = (deps) => async (c, next) => {
     await next();
     return;
   }
+  const remoteAddr = c.env.incoming?.socket?.remoteAddress;
+  if (LOCAL_ONLY_PATHS.has(path) && isLocalRequest(remoteAddr)) {
+    await next();
+    return;
+  }
   if (deps.localNoAuth) {
-    const remoteAddr = c.env.incoming?.socket?.remoteAddress;
     if (isLocalRequest(remoteAddr)) {
       await next();
       return;
@@ -2773,16 +2990,145 @@ var createHealthRoutes = () => {
   return app;
 };
 
+// src/api/routes/logs.routes.ts
+var import_node_fs3 = require("fs");
+var import_node_path5 = require("path");
+var import_hono5 = require("hono");
+
+// src/lifecycle/constants.ts
+var import_node_os = require("os");
+var import_node_path4 = require("path");
+var TASK_NAME = process.env.THREADBASE_TASK_NAME ?? "Threadbase";
+function installDir() {
+  return process.env.THREADBASE_INSTALL_DIR ?? (0, import_node_path4.join)((0, import_node_os.homedir)(), ".threadbase");
+}
+
+// src/api/routes/logs.routes.ts
+var logger2 = getLogger("logs-api");
+function resolveLogPath(source) {
+  return (0, import_node_path5.join)(installDir(), "logs", `${source}.log`);
+}
+function pickDefaultSource() {
+  for (const source of ["stdout", "stderr", "dev"]) {
+    const p = resolveLogPath(source);
+    if ((0, import_node_fs3.existsSync)(p) && (0, import_node_fs3.statSync)(p).size > 0) return source;
+  }
+  return "stdout";
+}
+function readLogLines(filePath, sinceOffset, limit) {
+  if (!(0, import_node_fs3.existsSync)(filePath)) {
+    return { lines: [], offset: 0, total: 0 };
+  }
+  const fd = (0, import_node_fs3.openSync)(filePath, "r");
+  try {
+    const { size } = (0, import_node_fs3.fstatSync)(fd);
+    if (size === 0) return { lines: [], offset: 0, total: 0 };
+    const maxBytes = Math.min(size, 2 * 1024 * 1024);
+    const start = size - maxBytes;
+    const buf = Buffer.alloc(maxBytes);
+    (0, import_node_fs3.readSync)(fd, buf, 0, maxBytes, start);
+    let text = buf.toString("utf8");
+    if (start > 0) {
+      const firstNl = text.indexOf("\n");
+      if (firstNl >= 0) text = text.slice(firstNl + 1);
+    }
+    const allLines = text.split("\n").filter((line) => line.trim() && !line.startsWith("==="));
+    let lines;
+    let newOffset;
+    if (sinceOffset > 0 && sinceOffset < allLines.length) {
+      lines = allLines.slice(sinceOffset, sinceOffset + limit);
+      newOffset = sinceOffset + lines.length;
+    } else if (sinceOffset >= allLines.length && sinceOffset > 0) {
+      lines = [];
+      newOffset = allLines.length;
+    } else {
+      lines = allLines.slice(-limit);
+      newOffset = allLines.length;
+    }
+    return { lines, offset: newOffset, total: allLines.length };
+  } finally {
+    (0, import_node_fs3.closeSync)(fd);
+  }
+}
+function createLogsRoutes() {
+  const app = new import_hono5.Hono();
+  app.get("/", (c) => {
+    try {
+      const sourceParam = (c.req.query("source") || "").toLowerCase();
+      const source = sourceParam === "stdout" || sourceParam === "stderr" || sourceParam === "dev" ? sourceParam : pickDefaultSource();
+      const logPath = resolveLogPath(source);
+      const sinceOffset = parseInt(c.req.query("since") || "0", 10);
+      const limit = Math.min(parseInt(c.req.query("limit") || "100", 10) || 100, 1e3);
+      if (!(0, import_node_fs3.existsSync)(logPath)) {
+        return c.json({
+          logs: [],
+          message: `No log file found for source=${source}`,
+          offset: 0,
+          total: 0,
+          source
+        });
+      }
+      const { lines, offset, total } = readLogLines(logPath, sinceOffset, limit);
+      const stats = (0, import_node_fs3.statSync)(logPath);
+      return c.json({
+        logs: lines,
+        offset,
+        total,
+        hasMore: offset < total,
+        source,
+        fileSize: stats.size,
+        fileModified: stats.mtime.toISOString()
+      });
+    } catch (error) {
+      logger2.error("Failed to read logs", { error: String(error) });
+      return c.json(
+        {
+          error: "Failed to read logs",
+          logs: [],
+          offset: 0,
+          total: 0
+        },
+        500
+      );
+    }
+  });
+  app.get("/meta", (c) => {
+    try {
+      const sources = ["stdout", "stderr", "dev"].map((source) => {
+        const logPath = resolveLogPath(source);
+        if (!(0, import_node_fs3.existsSync)(logPath)) {
+          return { source, exists: false, total: 0, fileSize: 0 };
+        }
+        const stats = (0, import_node_fs3.statSync)(logPath);
+        return {
+          source,
+          exists: true,
+          fileSize: stats.size,
+          fileModified: stats.mtime.toISOString()
+        };
+      });
+      return c.json({
+        defaultSource: pickDefaultSource(),
+        sources
+      });
+    } catch (error) {
+      logger2.error("Failed to read log metadata", { error: String(error) });
+      return c.json({ error: "Failed to read log metadata", exists: false }, 500);
+    }
+  });
+  return app;
+}
+
 // src/api/routes/misc.routes.ts
 var import_node_child_process = require("child_process");
 var import_node_crypto2 = require("crypto");
-var import_hono5 = require("hono");
-var import_os4 = require("os");
+var import_hono6 = require("hono");
+var import_os5 = require("os");
 
 // src/config/update-config.ts
-var import_node_fs3 = require("fs");
-var import_node_os = require("os");
-var import_node_path4 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_os2 = require("os");
+var import_node_path6 = require("path");
 var import_yaml = require("yaml");
 
 // src/schemas/updateConfig.schema.ts
@@ -2798,12 +3144,12 @@ var UpdateConfigSchema = import_zod.z.object({
 }).strict();
 
 // src/config/update-config.ts
-var DEFAULT_CONFIG_PATH = (0, import_node_path4.join)((0, import_node_os.homedir)(), ".threadbase", "update.yaml");
+var DEFAULT_CONFIG_PATH = (0, import_node_path6.join)((0, import_node_os2.homedir)(), ".threadbase", "update.yaml");
 function loadUpdateConfig(opts = {}) {
   const path = opts.path ?? DEFAULT_CONFIG_PATH;
   let raw;
   try {
-    raw = (0, import_node_fs3.readFileSync)(path, "utf-8");
+    raw = (0, import_node_fs4.readFileSync)(path, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw err;
@@ -2850,12 +3196,12 @@ function verifyWebhookSignature(body, header, secret) {
 }
 var clientLog = getLogger("client");
 var createMiscRoutes = (deps) => {
-  const app = new import_hono5.Hono();
+  const app = new import_hono6.Hono();
   app.get("/api/info", (c) => {
     const ptyIds = deps.ptyAttachedIds();
     return c.json({
       version: getVersion(),
-      machineName: (0, import_os4.hostname)(),
+      machineName: (0, import_os5.hostname)(),
       platform: process.platform,
       activeSessions: deps.sessionStore.list(ptyIds).filter((s) => s.status === "running").length,
       publicUrl: deps.publicUrl
@@ -2926,11 +3272,11 @@ var createMiscRoutes = (deps) => {
 };
 
 // src/api/routes/pair.routes.ts
-var import_hono6 = require("hono");
+var import_hono7 = require("hono");
 var ALREADY_HANDLED3 = 597;
 var alreadyHandled3 = () => new Response(null, { status: ALREADY_HANDLED3 });
 var createPairRoutes = (deps) => {
-  const app = new import_hono6.Hono();
+  const app = new import_hono7.Hono();
   app.post("/start", (c) => {
     deps.handlePairStart(c.env.outgoing);
     return alreadyHandled3();
@@ -2943,11 +3289,11 @@ var createPairRoutes = (deps) => {
 };
 
 // src/api/routes/projects.routes.ts
-var import_hono7 = require("hono");
+var import_hono8 = require("hono");
 var ALREADY_HANDLED4 = 597;
 var alreadyHandled4 = () => new Response(null, { status: ALREADY_HANDLED4 });
 var createProjectRoutes = (deps) => {
-  const app = new import_hono7.Hono();
+  const app = new import_hono8.Hono();
   app.get("/", (c) => {
     const url = new URL(c.req.url);
     deps.handleListProjects(url, c.env.outgoing);
@@ -2962,11 +3308,11 @@ var createProjectRoutes = (deps) => {
 };
 
 // src/api/routes/scanner.routes.ts
-var import_hono8 = require("hono");
+var import_hono9 = require("hono");
 var ALREADY_HANDLED5 = 597;
 var alreadyHandled5 = () => new Response(null, { status: ALREADY_HANDLED5 });
 var createScannerRoutes = (deps) => {
-  const app = new import_hono8.Hono();
+  const app = new import_hono9.Hono();
   app.get("/api/search", async (c) => {
     const url = new URL(c.req.url);
     await deps.handleSearch(url, c.env.outgoing);
@@ -2976,11 +3322,11 @@ var createScannerRoutes = (deps) => {
 };
 
 // src/api/routes/sessions.routes.ts
-var import_hono9 = require("hono");
+var import_hono10 = require("hono");
 var ALREADY_HANDLED6 = 597;
 var alreadyHandled6 = () => new Response(null, { status: ALREADY_HANDLED6 });
 var createSessionRoutes = (deps) => {
-  const app = new import_hono9.Hono();
+  const app = new import_hono10.Hono();
   app.get("/count", (c) => {
     deps.handleSessionsCount(c.env.outgoing);
     return alreadyHandled6();
@@ -3047,19 +3393,21 @@ var createSessionRoutes = (deps) => {
 };
 
 // src/api/routes/ws.routes.ts
-var import_hono10 = require("hono");
+var import_hono11 = require("hono");
 var createWsRoutes = (deps, upgradeWebSocket) => {
-  const app = new import_hono10.Hono();
+  const app = new import_hono11.Hono();
   app.get(
     "/ws",
-    upgradeWebSocket(() => {
+    upgradeWebSocket((c) => {
+      const key = c.req.query("key");
+      const preAuthed = typeof key === "string" && validateApiKey(key, deps.apiKey);
       let openWs = null;
       return {
         onOpen(_evt, ws) {
           const raw = ws.raw;
           if (!raw) return;
           openWs = raw;
-          deps.handleWsOpen(raw);
+          deps.handleWsOpen(raw, preAuthed);
         },
         onMessage(evt, _ws) {
           if (openWs) deps.handleWsMessage(openWs, evt.data);
@@ -3075,7 +3423,7 @@ var createWsRoutes = (deps, upgradeWebSocket) => {
 
 // src/api/app.ts
 var createHonoApp = (deps, upgradeWebSocket) => {
-  const app = new import_hono11.Hono();
+  const app = new import_hono12.Hono();
   const httpLog = getLogger("http");
   app.use("*", async (c, next) => {
     const start = Date.now();
@@ -3104,6 +3452,7 @@ var createHonoApp = (deps, upgradeWebSocket) => {
   app.route("/api", createBrowseRoutes(deps));
   app.route("/", createScannerRoutes(deps));
   app.route("/internal", createProgressRoutes(deps));
+  app.route("/api/logs", createLogsRoutes());
   if (upgradeWebSocket) {
     app.route("/", createWsRoutes(deps, upgradeWebSocket));
   }
@@ -3112,7 +3461,7 @@ var createHonoApp = (deps, upgradeWebSocket) => {
 
 // src/browse.ts
 var import_promises2 = require("fs/promises");
-var import_path8 = require("path");
+var import_path9 = require("path");
 var BrowsePathNotFoundError = class extends Error {
   constructor(message) {
     super(message);
@@ -3120,15 +3469,15 @@ var BrowsePathNotFoundError = class extends Error {
   }
 };
 async function resolveBrowsePath(browseRoot, relativePath) {
-  const normalizedRoot = (0, import_path8.resolve)(browseRoot);
+  const normalizedRoot = (0, import_path9.resolve)(browseRoot);
   let sanitized;
   if (process.platform !== "win32" && relativePath.startsWith("/") && relativePath.length > 1 && relativePath.includes("/", 1)) {
     sanitized = relativePath;
   } else {
     sanitized = relativePath.replace(/^[/\\]+/, "");
   }
-  const target = sanitized ? (0, import_path8.resolve)(normalizedRoot, sanitized) : normalizedRoot;
-  const rootPrefix = normalizedRoot.endsWith(import_path8.sep) ? normalizedRoot : `${normalizedRoot}${import_path8.sep}`;
+  const target = sanitized ? (0, import_path9.resolve)(normalizedRoot, sanitized) : normalizedRoot;
+  const rootPrefix = normalizedRoot.endsWith(import_path9.sep) ? normalizedRoot : `${normalizedRoot}${import_path9.sep}`;
   if (!target.startsWith(rootPrefix) && target !== normalizedRoot) {
     throw new Error("Path outside browse root");
   }
@@ -3150,7 +3499,7 @@ async function createDirectory(parentAbsolutePath, name) {
   if (name.includes("/") || name.includes("\\") || name === ".." || name === ".") {
     throw new Error("Invalid directory name");
   }
-  const target = (0, import_path8.join)(parentAbsolutePath, name);
+  const target = (0, import_path9.join)(parentAbsolutePath, name);
   try {
     const s = await (0, import_promises2.stat)(target);
     if (s.isDirectory()) throw new Error("Directory already exists");
@@ -3164,19 +3513,19 @@ async function createDirectory(parentAbsolutePath, name) {
 // src/conversation-cache.ts
 var import_scanner2 = require("@threadbase-sh/scanner");
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
-var import_fs8 = require("fs");
+var import_fs9 = require("fs");
 var import_promises3 = require("fs/promises");
-var import_path10 = require("path");
+var import_path11 = require("path");
 var import_promises4 = require("timers/promises");
 
 // src/db/sqlite-migrate.ts
-var import_fs6 = require("fs");
-var import_path9 = require("path");
+var import_fs7 = require("fs");
+var import_path10 = require("path");
 var import_url2 = require("url");
 var import_meta2 = {};
 function getMigrationsDir2() {
   if (typeof import_meta2 !== "undefined" && import_meta2.url) {
-    return (0, import_path9.dirname)((0, import_url2.fileURLToPath)(import_meta2.url));
+    return (0, import_path10.dirname)((0, import_url2.fileURLToPath)(import_meta2.url));
   }
   return __dirname;
 }
@@ -3188,8 +3537,8 @@ CREATE TABLE IF NOT EXISTS schema_migrations (
 `;
 function runSqliteMigrations(db, migrationsDir) {
   db.exec(SCHEMA_MIGRATIONS_SQL);
-  const dir = migrationsDir ?? (0, import_path9.join)(getMigrationsDir2(), "migrations");
-  const files = (0, import_fs6.readdirSync)(dir).filter((f) => f.endsWith(".sql")).sort();
+  const dir = migrationsDir ?? (0, import_path10.join)(getMigrationsDir2(), "migrations");
+  const files = (0, import_fs7.readdirSync)(dir).filter((f) => f.endsWith(".sql")).sort();
   const appliedRows = db.prepare("SELECT id FROM schema_migrations").all();
   const appliedSet = new Set(appliedRows.map((r) => r.id));
   const recordApplied = db.prepare("INSERT INTO schema_migrations (id, applied_at) VALUES (?, ?)");
@@ -3200,7 +3549,7 @@ function runSqliteMigrations(db, migrationsDir) {
       skipped.push(file);
       continue;
     }
-    const sql = (0, import_fs6.readFileSync)((0, import_path9.join)(dir, file), "utf-8");
+    const sql = (0, import_fs7.readFileSync)((0, import_path10.join)(dir, file), "utf-8");
     const tx = db.transaction(() => {
       db.exec(sql);
       recordApplied.run(file, (/* @__PURE__ */ new Date()).toISOString());
@@ -3212,7 +3561,7 @@ function runSqliteMigrations(db, migrationsDir) {
 }
 
 // src/services/conversations/isAgentConversation.ts
-var import_fs7 = require("fs");
+var import_fs8 = require("fs");
 var DEFAULT_AGENT_ENTRYPOINTS = /* @__PURE__ */ new Set(["sdk-cli", "claude-vscode"]);
 var CHUNK_BYTES = 64 * 1024;
 var ENTRYPOINT_PROBE = `"entrypoint":`;
@@ -3234,12 +3583,12 @@ function isAgentFile(filePath, entrypoints = DEFAULT_AGENT_ENTRYPOINTS) {
   if (cached2 !== void 0) return cached2;
   let fd;
   try {
-    fd = (0, import_fs7.openSync)(filePath, "r");
+    fd = (0, import_fs8.openSync)(filePath, "r");
   } catch {
     return false;
   }
   try {
-    const fileSize = (0, import_fs7.statSync)(filePath).size;
+    const fileSize = (0, import_fs8.statSync)(filePath).size;
     if (fileSize === 0) {
       fileDecisionCache.set(key, false);
       return false;
@@ -3250,7 +3599,7 @@ function isAgentFile(filePath, entrypoints = DEFAULT_AGENT_ENTRYPOINTS) {
     let carry = "";
     while (offset < fileSize) {
       const toRead = Math.min(CHUNK_BYTES, fileSize - offset);
-      const got = (0, import_fs7.readSync)(fd, buf, 0, toRead, offset);
+      const got = (0, import_fs8.readSync)(fd, buf, 0, toRead, offset);
       if (got <= 0) break;
       const chunk = carry + buf.toString("utf8", 0, got);
       for (const marker of markers) {
@@ -3271,7 +3620,7 @@ function isAgentFile(filePath, entrypoints = DEFAULT_AGENT_ENTRYPOINTS) {
   } catch {
     return false;
   } finally {
-    (0, import_fs7.closeSync)(fd);
+    (0, import_fs8.closeSync)(fd);
   }
 }
 function parseAgentEntrypointsEnv(raw) {
@@ -3808,7 +4157,7 @@ var ConversationCache = class _ConversationCache {
     if (!fileState) return null;
     let stat3;
     try {
-      stat3 = (0, import_fs8.statSync)(filePath);
+      stat3 = (0, import_fs9.statSync)(filePath);
     } catch {
       return null;
     }
@@ -3829,17 +4178,17 @@ var ConversationCache = class _ConversationCache {
     );
     if (rows.length === 0) return { messages: [], total, fromIndex: from };
     const messages = [];
-    const fd = (0, import_fs8.openSync)(filePath, "r");
+    const fd = (0, import_fs9.openSync)(filePath, "r");
     try {
       const state = (0, import_scanner2.createJsonlParseState)();
       for (const row of rows) {
         const buf = Buffer.alloc(row.byte_length);
-        (0, import_fs8.readSync)(fd, buf, 0, row.byte_length, row.byte_offset);
+        (0, import_fs9.readSync)(fd, buf, 0, row.byte_length, row.byte_offset);
         const msg = (0, import_scanner2.parseJsonlLine)(buf.toString("utf-8"), state);
         if (msg) messages.push(msg);
       }
     } finally {
-      (0, import_fs8.closeSync)(fd);
+      (0, import_fs9.closeSync)(fd);
     }
     return { messages, total, fromIndex: from };
   }
@@ -3867,14 +4216,14 @@ var ConversationCache = class _ConversationCache {
   isAgentFileCached(filePath) {
     let s;
     try {
-      s = (0, import_fs8.statSync)(filePath);
+      s = (0, import_fs9.statSync)(filePath);
     } catch {
       return false;
     }
     return this.classifyAgentFile(filePath, s.mtimeMs, s.size);
   }
   static open(dbPath, tailSize = 10, migrationsDir, options) {
-    (0, import_fs8.mkdirSync)((0, import_path10.dirname)(dbPath), { recursive: true });
+    (0, import_fs9.mkdirSync)((0, import_path11.dirname)(dbPath), { recursive: true });
     const db = new import_better_sqlite3.default(dbPath);
     db.pragma("journal_mode = WAL");
     db.pragma("foreign_keys = ON");
@@ -4055,7 +4404,7 @@ var ConversationCache = class _ConversationCache {
         let mtimeMs = null;
         let fileSize = null;
         try {
-          const s = (0, import_fs8.statSync)(m.filePath);
+          const s = (0, import_fs9.statSync)(m.filePath);
           mtimeMs = s.mtimeMs;
           fileSize = s.size;
         } catch {
@@ -4114,8 +4463,8 @@ var ConversationCache = class _ConversationCache {
     let fileSize;
     let fd;
     try {
-      fileSize = (0, import_fs8.statSync)(filePath).size;
-      fd = (0, import_fs8.openSync)(filePath, "r");
+      fileSize = (0, import_fs9.statSync)(filePath).size;
+      fd = (0, import_fs9.openSync)(filePath, "r");
     } catch {
       return false;
     }
@@ -4128,7 +4477,7 @@ var ConversationCache = class _ConversationCache {
       while (pos > 0 && lines.length < this.tailSize * 4) {
         const toRead = Math.min(CHUNK, pos);
         pos -= toRead;
-        (0, import_fs8.readSync)(fd, buf, 0, toRead, pos);
+        (0, import_fs9.readSync)(fd, buf, 0, toRead, pos);
         const chunk = buf.subarray(0, toRead).toString("utf8");
         const combined = chunk + partial;
         const parts = combined.split("\n");
@@ -4139,7 +4488,7 @@ var ConversationCache = class _ConversationCache {
       }
       if (partial) lines.push(partial);
     } finally {
-      (0, import_fs8.closeSync)(fd);
+      (0, import_fs9.closeSync)(fd);
     }
     const msgs = [];
     for (let i = 0; i < lines.length && msgs.length < this.tailSize; i++) {
@@ -4341,7 +4690,7 @@ var ConversationCache = class _ConversationCache {
    * `handleGetConversation` can still serve the cached tail even when the
    * JSONL has been deleted.
    */
-  pruneGhostFiles(exists = import_fs8.existsSync) {
+  pruneGhostFiles(exists = import_fs9.existsSync) {
     const rows = this.stmts.allFilePaths.all();
     const ghosts = [];
     const prune = this.db.transaction((ids) => {
@@ -4396,7 +4745,7 @@ var ConversationCache = class _ConversationCache {
    * Returns the removed IDs.
    */
   reconcileDeletions(livePaths, opts) {
-    const exists = opts?.exists ?? import_fs8.existsSync;
+    const exists = opts?.exists ?? import_fs9.existsSync;
     const rows = this.stmts.allFilePaths.all();
     const removed = [];
     const drop = this.db.transaction((ids) => {
@@ -4625,23 +4974,23 @@ async function recordUpload(pool2, instanceId, row) {
 }
 
 // src/handlers/handleListProjects.ts
-var import_fs9 = require("fs");
-var import_os5 = require("os");
-var import_path11 = require("path");
+var import_fs10 = require("fs");
+var import_os6 = require("os");
+var import_path12 = require("path");
 function decodeProjectPath(dirName) {
   return dirName.replace(/-/g, "/");
 }
 function handleListProjects(url, res) {
   const limit = Math.max(1, parseInt(url.searchParams.get("limit") ?? "50", 10) || 50);
   const offset = Math.max(0, parseInt(url.searchParams.get("offset") ?? "0", 10) || 0);
-  const projectsDir = (0, import_path11.join)((0, import_os5.homedir)(), ".claude", "projects");
+  const projectsDir = (0, import_path12.join)((0, import_os6.homedir)(), ".claude", "projects");
   let entries;
   try {
-    entries = (0, import_fs9.readdirSync)(projectsDir).map((dirName) => {
-      const fullPath = (0, import_path11.join)(projectsDir, dirName);
+    entries = (0, import_fs10.readdirSync)(projectsDir).map((dirName) => {
+      const fullPath = (0, import_path12.join)(projectsDir, dirName);
       let mtime = 0;
       try {
-        mtime = (0, import_fs9.statSync)(fullPath).mtimeMs;
+        mtime = (0, import_fs10.statSync)(fullPath).mtimeMs;
       } catch {
       }
       const path = decodeProjectPath(dirName);
@@ -4736,7 +5085,7 @@ function seal(plaintext, recipientPublicKeyBase64) {
 
 // src/services/conversations/conversationWatcher.ts
 var import_chokidar = __toESM(require("chokidar"), 1);
-var import_fs10 = require("fs");
+var import_fs11 = require("fs");
 var import_promises5 = require("fs/promises");
 var ConversationWatcher = class {
   files = /* @__PURE__ */ new Map();
@@ -4759,7 +5108,7 @@ var ConversationWatcher = class {
     if (this.files.has(filePath)) return;
     let offset;
     try {
-      offset = (0, import_fs10.statSync)(filePath).size;
+      offset = (0, import_fs11.statSync)(filePath).size;
     } catch {
       offset = 0;
     }
@@ -4934,14 +5283,14 @@ function findSearchTarget(messages, query) {
 }
 
 // src/services/conversations/pruneAgentConversations.ts
-var import_fs11 = require("fs");
+var import_fs12 = require("fs");
 function pruneAgentConversations(cache) {
   const db = cache.getDatabase();
   const rows = db.prepare("SELECT id, file_path FROM conversation_meta").all();
   let pruned = 0;
   let missing = 0;
   for (const row of rows) {
-    if (!(0, import_fs11.existsSync)(row.file_path)) {
+    if (!(0, import_fs12.existsSync)(row.file_path)) {
       missing += 1;
       continue;
     }
@@ -4964,6 +5313,13 @@ function deriveProjectChatTitle(input) {
   return `Untitled \xB7 ${input.id.slice(0, 8)}`;
 }
 
+// src/services/questions/permissionAnswerKeys.ts
+var ANSWER_KEYS_ALLOWLIST = /^(?:\r|[yn]\r|\x03|\d+\r)$/;
+function sanitizeAnswerKeys(keys) {
+  if (keys === void 0) return void 0;
+  return ANSWER_KEYS_ALLOWLIST.test(keys) ? keys : void 0;
+}
+
 // src/services/questions/detectAskUserQuestion.ts
 function normalizeContent2(raw) {
   if (Array.isArray(raw)) return raw;
@@ -5277,7 +5633,7 @@ function discoveredToResponse(d, conversationId) {
 var import_crypto8 = require("crypto");
 var import_promises6 = require("fs/promises");
 var import_heic_convert = __toESM(require("heic-convert"), 1);
-var import_path12 = require("path");
+var import_path13 = require("path");
 var UPLOAD_DIR_NAME = ".threadbase-uploads";
 var MAX_BYTES = 25 * 1024 * 1024;
 var HEIC_MIMES = /* @__PURE__ */ new Set(["image/heic", "image/heif"]);
@@ -5310,9 +5666,9 @@ async function saveUploadFile(input) {
   }
   const id = `up_${(0, import_crypto8.randomBytes)(8).toString("hex")}`;
   const safeName = sanitizeFilename(originalName) || `file${MIME_TO_EXT[mimeType] ?? ""}`;
-  const dir = (0, import_path12.join)(input.projectPath, UPLOAD_DIR_NAME, input.sessionId);
+  const dir = (0, import_path13.join)(input.projectPath, UPLOAD_DIR_NAME, input.sessionId);
   await (0, import_promises6.mkdir)(dir, { recursive: true });
-  const filePath = (0, import_path12.join)(dir, `${Date.now()}-${id}-${safeName}`);
+  const filePath = (0, import_path13.join)(dir, `${Date.now()}-${id}-${safeName}`);
   await (0, import_promises6.writeFile)(filePath, buffer);
   return {
     id,
@@ -5568,8 +5924,10 @@ 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 DEFAULT_WS_AUTH_TIMEOUT_MS = 5e3;
+var WS_CLOSE_UNAUTHORIZED = 4401;
 var REFRESH_TTL_MS = 2e3;
-var START_READY_TIMEOUT_MS = 15e3;
+var START_READY_TIMEOUT_MS = 1e4;
 function parseIncludeAgentsEnv(raw) {
   if (raw === void 0) return false;
   const v = raw.trim().toLowerCase();
@@ -5658,6 +6016,14 @@ var StreamerServer = class {
   clientIdToWs = /* @__PURE__ */ new Map();
   // Reverse map for cleanup on close
   wsToClientId = /* @__PURE__ */ new Map();
+  // M1 — WS auth. Sockets that have authenticated (via ?key= at upgrade OR a
+  // { type: "auth", token } first message). Only authed sockets are added to
+  // the hub and receive broadcasts.
+  // Plan: https://github.com/RonenMars/threadbase-streamer/blob/a251353bfa417bd48ce3f15086bc336a2c622629/docs/plans/2026-06-24-security-hardening.md#L40
+  wsAuthed = /* @__PURE__ */ new Set();
+  // Keyless sockets awaiting their first-message auth handshake → close timer.
+  wsAuthPending = /* @__PURE__ */ new Map();
+  wsAuthTimeoutMs;
   cache = null;
   projectsRepo = null;
   conversationsRepo = null;
@@ -5695,11 +6061,12 @@ var StreamerServer = class {
     this.disableDb = config.disableDb ?? false;
     this.scannerPersistenceDisabled = config.scannerPersistent === false;
     this.scanProfiles = config.scanProfiles;
-    this.codexRoots = config.codexRoots ?? [(0, import_path13.join)((0, import_os6.homedir)(), ".codex", "sessions")];
+    this.codexRoots = config.codexRoots ?? [(0, import_path14.join)((0, import_os7.homedir)(), ".codex", "sessions")];
     this.ptyGracePeriodMs = config.ptyGracePeriodMs ?? DEFAULT_PTY_GRACE_PERIOD_MS;
+    this.wsAuthTimeoutMs = config.wsAuthTimeoutMs ?? DEFAULT_WS_AUTH_TIMEOUT_MS;
     this.defaultSystemPrompt = config.defaultSystemPrompt ?? DEFAULT_SYSTEM_PROMPT;
     this.defaultPermissionMode = config.defaultPermissionMode ?? loadDefaultPermissionMode() ?? "acceptEdits";
-    this.cacheDir = config.cacheDir ?? loadCacheDir() ?? (0, import_path13.join)((0, import_os6.homedir)(), ".threadbase", "cache");
+    this.cacheDir = config.cacheDir ?? loadCacheDir() ?? (0, import_path14.join)((0, import_os7.homedir)(), ".threadbase", "cache");
     this.tailSize = config.tailSize ?? loadTailSize() ?? 10;
     this.directoryDebounceMs = parseDirScanDebounceEnv(process.env.THREADBASE_DIR_SCAN_DEBOUNCE_MS) ?? config.directoryScanDebounceMs ?? 1e3;
     this.markScannerStaleDebounced = debounce(() => {
@@ -5740,7 +6107,7 @@ var StreamerServer = class {
           const seqs = cache.extendMessageIndex(
             filePath,
             spans,
-            (0, import_fs12.statSync)(filePath),
+            (0, import_fs13.statSync)(filePath),
             readFrom,
             endOffset
           );
@@ -5901,7 +6268,7 @@ var StreamerServer = class {
         temporalClient,
         taskQueue: agentConfig.temporal.taskQueue
       });
-      const conversationsBaseDir = agentConfig.conversationsDir || (0, import_path13.join)((0, import_path13.dirname)(this.cacheDir), "conversations");
+      const conversationsBaseDir = agentConfig.conversationsDir || (0, import_path14.join)((0, import_path14.dirname)(this.cacheDir), "conversations");
       conversationWriter = createConversationWriter({
         baseDir: conversationsBaseDir
       });
@@ -5954,17 +6321,39 @@ var StreamerServer = class {
       handlePairExchange: (req, res) => this.handlePairExchange(req, res),
       handleBrowse: (url, res) => this.handleBrowse(url, res),
       handleMkdir: (req, res) => this.handleMkdir(req, res),
-      handleWsOpen: (ws) => {
-        this.wsHub.addClient(ws);
-        const sessions = this.sessionStore.list(this.ptyAttachedIds());
-        ws.send(JSON.stringify({ type: "session_list", sessions }));
-        if (this.cacheReady) {
-          ws.send(JSON.stringify({ type: "cache_ready" }));
+      handleWsOpen: (ws, preAuthed) => {
+        if (preAuthed) {
+          this.completeWsAuth(ws);
+          return;
         }
+        const timer = setTimeout(() => {
+          this.wsAuthPending.delete(ws);
+          try {
+            ws.close(WS_CLOSE_UNAUTHORIZED, "auth timeout");
+          } catch {
+          }
+        }, this.wsAuthTimeoutMs);
+        this.wsAuthPending.set(ws, timer);
       },
       handleWsMessage: async (ws, raw) => {
         try {
           const msg = JSON.parse(String(raw));
+          if (!this.wsAuthed.has(ws)) {
+            if (msg.type === "auth" && typeof msg.token === "string") {
+              const t = this.wsAuthPending.get(ws);
+              if (t) clearTimeout(t);
+              this.wsAuthPending.delete(ws);
+              if (validateApiKey(msg.token, this.apiKey)) {
+                this.completeWsAuth(ws);
+              } else {
+                try {
+                  ws.close(WS_CLOSE_UNAUTHORIZED, "unauthorized");
+                } catch {
+                }
+              }
+            }
+            return;
+          }
           if (msg.type === "register" && typeof msg.clientId === "string") {
             const oldClientId = this.wsToClientId.get(ws);
             if (oldClientId) this.clientIdToWs.delete(oldClientId);
@@ -5977,14 +6366,54 @@ var StreamerServer = class {
               const lines = await this.ptyManager.getOutputLines(msg.sessionId, 200);
               ws.send(JSON.stringify({ type: "terminal_replay", sessionId: msg.sessionId, lines }));
             }
+            const pendingGate = this.pendingPermission.get(msg.sessionId);
+            if (pendingGate) {
+              this.log.info(`[ws.replay_permission] ${msg.sessionId.slice(0, 8)}`, {
+                event: "ws.replay_permission",
+                sessionId: msg.sessionId
+              });
+              ws.send(
+                JSON.stringify({
+                  type: "permission",
+                  sessionId: msg.sessionId,
+                  ...pendingGate.prompt ? { prompt: pendingGate.prompt } : {},
+                  ...pendingGate.detail ? { detail: pendingGate.detail } : {},
+                  options: pendingGate.options,
+                  ...pendingGate.cursor !== void 0 ? { cursor: pendingGate.cursor } : {}
+                })
+              );
+            }
+            const pendingQuestion = this.pendingQuestions.get(msg.sessionId);
+            if (pendingQuestion) {
+              this.log.info(`[ws.replay_question] ${msg.sessionId.slice(0, 8)}`, {
+                event: "ws.replay_question",
+                sessionId: msg.sessionId
+              });
+              ws.send(
+                JSON.stringify({
+                  type: "question",
+                  sessionId: msg.sessionId,
+                  toolUseId: pendingQuestion.toolUseId,
+                  questions: pendingQuestion.questions
+                })
+              );
+            }
           }
           if (msg.type === "hold_session" && typeof msg.sessionId === "string") {
-            this.startGraceTimer(msg.sessionId, 0);
+            if (this.sessionSubscribers.get(msg.sessionId)?.has(ws)) {
+              this.startGraceTimer(msg.sessionId, 0);
+            }
           }
         } catch {
         }
       },
       handleWsClose: (ws) => {
+        const pendingTimer = this.wsAuthPending.get(ws);
+        if (pendingTimer) {
+          clearTimeout(pendingTimer);
+          this.wsAuthPending.delete(ws);
+        }
+        this.wsAuthed.delete(ws);
         const clientId = this.wsToClientId.get(ws);
         if (clientId) {
           this.clientIdToWs.delete(clientId);
@@ -6054,6 +6483,20 @@ var StreamerServer = class {
       this.wsHub.broadcast(payload);
     }
   }
+  // M1: finalize a WebSocket auth (via ?key= at upgrade or a first-message
+  // handshake) — register it with the hub and send the initial snapshot. Only
+  // authed sockets reach this, so no unauthenticated client ever receives a
+  // broadcast.
+  // Plan: https://github.com/RonenMars/threadbase-streamer/blob/a251353bfa417bd48ce3f15086bc336a2c622629/docs/plans/2026-06-24-security-hardening.md#L40
+  completeWsAuth(ws) {
+    this.wsAuthed.add(ws);
+    this.wsHub.addClient(ws);
+    const sessions = this.sessionStore.list(this.ptyAttachedIds());
+    ws.send(JSON.stringify({ type: "session_list", sessions }));
+    if (this.cacheReady) {
+      ws.send(JSON.stringify({ type: "cache_ready" }));
+    }
+  }
   addSessionSubscriber(sessionId, ws) {
     let subs = this.sessionSubscribers.get(sessionId);
     if (!subs) {
@@ -6125,7 +6568,7 @@ var StreamerServer = class {
         });
         try {
           this.cache = ConversationCache.open(
-            (0, import_path13.join)(this.cacheDir, "cache.db"),
+            (0, import_path14.join)(this.cacheDir, "cache.db"),
             this.tailSize,
             void 0,
             {
@@ -6151,11 +6594,11 @@ var StreamerServer = class {
           if (this.scanProfiles && this.scanProfiles.length > 0) {
             for (const profile of this.scanProfiles) {
               if (profile.enabled) {
-                this.fileWatcher.watchDirectory((0, import_path13.join)(profile.configDir, "projects"));
+                this.fileWatcher.watchDirectory((0, import_path14.join)(profile.configDir, "projects"));
               }
             }
           } else {
-            this.fileWatcher.watchDirectory((0, import_path13.join)((0, import_os6.homedir)(), ".claude", "projects"));
+            this.fileWatcher.watchDirectory((0, import_path14.join)((0, import_os7.homedir)(), ".claude", "projects"));
           }
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
@@ -6340,6 +6783,9 @@ var StreamerServer = class {
     this.ptyManager.dispose();
     this.fileWatcher.dispose();
     this.wsHub.dispose();
+    for (const timer of this.wsAuthPending.values()) clearTimeout(timer);
+    this.wsAuthPending.clear();
+    this.wsAuthed.clear();
     this.pairTokens.dispose();
     if (this.dbPool) {
       await this.dbPool.end();
@@ -6737,17 +7183,17 @@ var StreamerServer = class {
     return scanner;
   }
   findJsonlPath(uuid) {
-    const projectsDir = (0, import_path13.join)((0, import_os6.homedir)(), ".claude", "projects");
-    if (!(0, import_fs12.existsSync)(projectsDir)) return null;
+    const projectsDir = (0, import_path14.join)((0, import_os7.homedir)(), ".claude", "projects");
+    if (!(0, import_fs13.existsSync)(projectsDir)) return null;
     const filename = `${uuid}.jsonl`;
-    for (const dir of (0, import_fs12.readdirSync)(projectsDir)) {
-      const fp = (0, import_path13.join)(projectsDir, dir, filename);
-      if ((0, import_fs12.existsSync)(fp)) return fp;
-      const projectDir = (0, import_path13.join)(projectsDir, dir);
+    for (const dir of (0, import_fs13.readdirSync)(projectsDir)) {
+      const fp = (0, import_path14.join)(projectsDir, dir, filename);
+      if ((0, import_fs13.existsSync)(fp)) return fp;
+      const projectDir = (0, import_path14.join)(projectsDir, dir);
       try {
-        for (const sub of (0, import_fs12.readdirSync)(projectDir)) {
-          const subagentPath = (0, import_path13.join)(projectDir, sub, "subagents", filename);
-          if ((0, import_fs12.existsSync)(subagentPath)) return subagentPath;
+        for (const sub of (0, import_fs13.readdirSync)(projectDir)) {
+          const subagentPath = (0, import_path14.join)(projectDir, sub, "subagents", filename);
+          if ((0, import_fs13.existsSync)(subagentPath)) return subagentPath;
         }
       } catch {
       }
@@ -6756,7 +7202,7 @@ var StreamerServer = class {
   }
   async readCwdFromJsonl(filePath) {
     return new Promise((resolve2) => {
-      const rl = (0, import_readline.createInterface)({ input: (0, import_fs12.createReadStream)(filePath), crlfDelay: Infinity });
+      const rl = (0, import_readline.createInterface)({ input: (0, import_fs13.createReadStream)(filePath), crlfDelay: Infinity });
       let found = false;
       rl.on("line", (line) => {
         if (found) return;
@@ -6894,7 +7340,7 @@ var StreamerServer = class {
     if (!conv.filePath) return false;
     let mtimeMs = null;
     try {
-      mtimeMs = (0, import_fs12.statSync)(conv.filePath).mtimeMs;
+      mtimeMs = (0, import_fs13.statSync)(conv.filePath).mtimeMs;
     } catch {
       return false;
     }
@@ -7262,7 +7708,7 @@ var StreamerServer = class {
   handleGetSession(sessionId, res) {
     const session = this.sessionStore.get(sessionId, this.ptyAttachedIds());
     if (session) {
-      if (!(0, import_fs12.existsSync)(session.projectPath)) {
+      if (!(0, import_fs13.existsSync)(session.projectPath)) {
         session.failureReason = `Project directory not found: ${session.projectPath}`;
       }
       json(res, 200, session);
@@ -7466,12 +7912,21 @@ var StreamerServer = class {
       return;
     }
     this.pendingPermission.set(sessionId, gate);
+    const safeOptions = gate.options.map((o) => {
+      const answerKeys = sanitizeAnswerKeys(o.answerKeys);
+      return answerKeys === void 0 ? { index: o.index, label: o.label } : { ...o, answerKeys };
+    });
+    const subscriberCount = this.sessionSubscribers.get(sessionId)?.size ?? 0;
+    this.log.info(
+      `[ws.broadcast_permission] ${sessionId.slice(0, 8)} subscribers=${subscriberCount}`,
+      { event: "ws.broadcast_permission", sessionId, subscriberCount }
+    );
     this.wsHub.broadcast({
       type: "permission",
       sessionId,
       ...gate.prompt ? { prompt: gate.prompt } : {},
       ...gate.detail ? { detail: gate.detail } : {},
-      options: gate.options,
+      options: safeOptions,
       ...gate.cursor !== void 0 ? { cursor: gate.cursor } : {}
     });
   }
@@ -7658,7 +8113,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 ? (0, import_path13.join)((0, import_path13.dirname)(this.cacheDir), "conversations") : "",
+        conversationsDir: this.cacheDir ? (0, import_path14.join)((0, import_path14.dirname)(this.cacheDir), "conversations") : "",
         agentConfig: this.agentConfig
       });
       json(res, result.status, result.body);
@@ -7799,9 +8254,9 @@ var StreamerServer = class {
   // was passed to Claude via --session-id so the filename matches from the start.
   watchForJsonl(sessionId, projectPath) {
     const encoded = projectPath.replace(/[/\\:.]/g, "-");
-    const projectsDir = (0, import_path13.join)((0, import_os6.homedir)(), ".claude", "projects", encoded);
+    const projectsDir = (0, import_path14.join)((0, import_os7.homedir)(), ".claude", "projects", encoded);
     const expectedFile = `${sessionId}.jsonl`;
-    const filePath = (0, import_path13.join)(projectsDir, expectedFile);
+    const filePath = (0, import_path14.join)(projectsDir, expectedFile);
     const deadline = Date.now() + 12e4;
     let watcher = null;
     const cleanup = () => {
@@ -7819,12 +8274,12 @@ var StreamerServer = class {
         cleanup();
         return;
       }
-      let resolvedFilePath = (0, import_fs12.existsSync)(filePath) ? filePath : null;
-      if (!resolvedFilePath && (0, import_fs12.existsSync)(projectsDir)) {
+      let resolvedFilePath = (0, import_fs13.existsSync)(filePath) ? filePath : null;
+      if (!resolvedFilePath && (0, import_fs13.existsSync)(projectsDir)) {
         try {
           const now = Date.now();
-          const recent = (0, import_fs12.readdirSync)(projectsDir).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, mtime: (0, import_fs12.statSync)((0, import_path13.join)(projectsDir, f)).mtimeMs })).filter(({ mtime }) => now - mtime < 5e3).sort((a, b) => b.mtime - a.mtime)[0];
-          if (recent) resolvedFilePath = (0, import_path13.join)(projectsDir, recent.f);
+          const recent = (0, import_fs13.readdirSync)(projectsDir).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, mtime: (0, import_fs13.statSync)((0, import_path14.join)(projectsDir, f)).mtimeMs })).filter(({ mtime }) => now - mtime < 5e3).sort((a, b) => b.mtime - a.mtime)[0];
+          if (recent) resolvedFilePath = (0, import_path14.join)(projectsDir, recent.f);
         } catch {
         }
       }
@@ -7833,7 +8288,7 @@ var StreamerServer = class {
       this.sessionFileMap.set(sessionId, resolvedFilePath);
       this.fileWatcher.watch(resolvedFilePath);
       try {
-        const existing = (0, import_fs12.readFileSync)(resolvedFilePath, "utf8").split("\n").filter(Boolean);
+        const existing = (0, import_fs13.readFileSync)(resolvedFilePath, "utf8").split("\n").filter(Boolean);
         if (existing.length > 0) {
           this.broadcastConversationLines(sessionId, existing);
         }
@@ -7856,7 +8311,7 @@ var StreamerServer = class {
     if (this.sessionFileMap.has(sessionId)) return;
     try {
       require("fs").mkdirSync(projectsDir, { recursive: true });
-      watcher = (0, import_fs12.watch)(projectsDir, tryWire);
+      watcher = (0, import_fs13.watch)(projectsDir, tryWire);
       watcher.on("error", cleanup);
     } catch {
     }
@@ -7872,7 +8327,7 @@ var StreamerServer = class {
   watchForCodexRollout(sessionId, projectPath) {
     const deadline = Date.now() + 12e4;
     const now = /* @__PURE__ */ new Date();
-    const dateDir = (0, import_path13.join)(
+    const dateDir = (0, import_path14.join)(
       String(now.getFullYear()),
       String(now.getMonth() + 1).padStart(2, "0"),
       String(now.getDate()).padStart(2, "0")
@@ -7885,7 +8340,7 @@ var StreamerServer = class {
     };
     const matchesProjectPath = (candidatePath) => {
       try {
-        const firstLine = (0, import_fs12.readFileSync)(candidatePath, "utf8").split("\n", 1)[0];
+        const firstLine = (0, import_fs13.readFileSync)(candidatePath, "utf8").split("\n", 1)[0];
         if (!firstLine) return null;
         const parsed = JSON.parse(firstLine);
         if (parsed?.type !== "session_meta") return null;
@@ -7913,18 +8368,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 = (0, import_path13.join)(root, dateDir);
-        if (!(0, import_fs12.existsSync)(sessionsDir)) continue;
+        const sessionsDir = (0, import_path14.join)(root, dateDir);
+        if (!(0, import_fs13.existsSync)(sessionsDir)) continue;
         let candidateFiles;
         try {
-          candidateFiles = (0, import_fs12.readdirSync)(sessionsDir).filter((f) => f.endsWith(".jsonl"));
+          candidateFiles = (0, import_fs13.readdirSync)(sessionsDir).filter((f) => f.endsWith(".jsonl"));
         } catch {
           continue;
         }
         const nowMs = Date.now();
-        const recentCandidates = candidateFiles.map((f) => ({ f, mtime: (0, import_fs12.statSync)((0, import_path13.join)(sessionsDir, f)).mtimeMs })).filter(({ mtime }) => nowMs - mtime < 1e4).sort((a, b) => b.mtime - a.mtime);
+        const recentCandidates = candidateFiles.map((f) => ({ f, mtime: (0, import_fs13.statSync)((0, import_path14.join)(sessionsDir, f)).mtimeMs })).filter(({ mtime }) => nowMs - mtime < 1e4).sort((a, b) => b.mtime - a.mtime);
         for (const { f } of recentCandidates) {
-          const candidatePath = (0, import_path13.join)(sessionsDir, f);
+          const candidatePath = (0, import_path14.join)(sessionsDir, f);
           const match = matchesProjectPath(candidatePath);
           if (!match) continue;
           if (boundElsewhere.has(match.id)) continue;
@@ -7934,7 +8389,7 @@ var StreamerServer = class {
           this.sessionFileMap.set(sessionId, candidatePath);
           this.fileWatcher.watch(candidatePath);
           try {
-            const existing = (0, import_fs12.readFileSync)(candidatePath, "utf8").split("\n").filter(Boolean);
+            const existing = (0, import_fs13.readFileSync)(candidatePath, "utf8").split("\n").filter(Boolean);
             if (existing.length > 0) {
               this.broadcastConversationLines(sessionId, existing);
             }
@@ -8056,7 +8511,7 @@ var StreamerServer = class {
 };
 function classifyResumability(cwd) {
   if (!cwd) return { resumable: true };
-  if ((0, import_fs12.existsSync)(cwd)) return { resumable: true };
+  if ((0, import_fs13.existsSync)(cwd)) return { resumable: true };
   const ranInWorktree = /\/\.worktrees\//.test(cwd) || /\/\.claude\/worktrees\//.test(cwd);
   return {
     resumable: false,