@threadbase-sh/streamer 1.29.2 → 1.31.0

package/dist/index.js

@@ -164,7 +164,7 @@ function verifySignature(rawBody, signature, secret) {
   }
 }
 function isWithinSkew(timestampHeader, skewSeconds) {
-  if (!timestampHeader) return false;
+  if (!timestampHeader) return true;
   const t = Number(timestampHeader);
   if (!Number.isFinite(t)) return false;
   const now = Math.floor(Date.now() / 1e3);
@@ -680,13 +680,80 @@ function isProviderResumable(_provider, availabilityResumable) {
   return availabilityResumable;
 }
 
+// src/services/questions/codexGateAnswers.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname3, join as join5 } from "path";
+function gateAnswersPath() {
+  const dir = process.env.THREADBASE_CONFIG_DIR ?? join5(homedir3(), ".threadbase");
+  return join5(dir, "gate-answers.json");
+}
+function loadGateAnswers() {
+  try {
+    const parsed = JSON.parse(readFileSync3(gateAnswersPath(), "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function saveGateAnswer(key, value) {
+  const path = gateAnswersPath();
+  mkdirSync2(dirname3(path), { recursive: true });
+  writeFileSync2(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 INPUT_HISTORY_MAX = 50;
 var PTY_COLS = 120;
 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) {
@@ -694,6 +761,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;
@@ -720,11 +821,12 @@ 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;
+  onUserMessage;
   log;
   // Tracks sessions whose PTY has spawned but Codex hasn't yet reached its
   // "Ready" status bar — i.e. onReady hasn't fired.
@@ -732,8 +834,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).
@@ -745,6 +857,7 @@ var CodexPtyRunner = class {
     this.onPermissionChange = options.onPermissionChange;
     this.onLiveQuestion = options.onLiveQuestion;
     this.onLiveQuestionGone = options.onLiveQuestionGone;
+    this.onUserMessage = options.onUserMessage;
     this.log = options.logger ?? getLogger("codex-pty");
   }
   // Resume an existing Codex session. sessionId is the Codex-persisted
@@ -788,10 +901,12 @@ var CodexPtyRunner = class {
       lastOutput: "",
       process: proc,
       outputBuffer: Buffer.alloc(0),
-      screen: createScreen()
+      screen: createScreen(),
+      inputHistory: []
     };
     this.sessions.set(sessionId, session);
     this.pendingReady.add(sessionId);
+    this.armReadyFallback(sessionId);
     proc.onData((data) => {
       this.handleOutput(sessionId, data);
     });
@@ -833,10 +948,12 @@ var CodexPtyRunner = class {
       lastOutput: "",
       process: proc,
       outputBuffer: Buffer.alloc(0),
-      screen: createScreen()
+      screen: createScreen(),
+      inputHistory: []
     };
     this.sessions.set(sessionId, session);
     this.pendingReady.add(sessionId);
+    this.armReadyFallback(sessionId);
     proc.onData((data) => {
       this.handleOutput(sessionId, data);
     });
@@ -846,6 +963,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);
@@ -857,13 +989,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}`);
@@ -901,6 +1067,7 @@ var CodexPtyRunner = class {
   // confirmed Codex accepts plain keystrokes), then submit \r after a short
   // delay so Codex's TUI gets an event-loop tick to process the input first.
   writeSubmit(sessionId, session, input, path, promptCount) {
+    this.recordUserMessage(session, input);
     this.log.info(
       `[codex.input.write] ${sessionId.slice(0, 8)} promptCount=${promptCount} bytes=${input.length} digest=${digestBytes(input)}`,
       {
@@ -933,8 +1100,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);
@@ -979,7 +1150,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 {
@@ -990,6 +1161,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}`);
@@ -1011,6 +1197,19 @@ var CodexPtyRunner = class {
     }
     return lines.slice(-maxLines);
   }
+  getInputHistory(sessionId) {
+    return this.sessions.get(sessionId)?.inputHistory ?? [];
+  }
+  // Record a submitted user message as ground truth and fire onUserMessage.
+  // Called from writeSubmit (direct and flush paths) — never from sendKeys.
+  recordUserMessage(session, text) {
+    const ts = Date.now();
+    session.inputHistory.push({ text, ts });
+    if (session.inputHistory.length > INPUT_HISTORY_MAX) {
+      session.inputHistory.shift();
+    }
+    this.onUserMessage?.(session.id, text, ts);
+  }
   getSession(sessionId) {
     const session = this.sessions.get(sessionId);
     return session ? toPublicSession(session) : null;
@@ -1029,10 +1228,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);
@@ -1047,44 +1255,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");
+    }
   }
-  markReady(sessionId, session) {
+  // 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, 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)) {
@@ -1110,7 +1366,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) {
@@ -1293,9 +1549,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);
@@ -1323,45 +1585,15 @@ 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 INPUT_HISTORY_MAX2 = 50;
 var PTY_COLS2 = 120;
 var PTY_ROWS2 = 40;
 var SCREEN_SCROLLBACK2 = 1e3;
 var CLAUDE_PROMPT_MARKERS = ["\u256D", "\u276F"];
 var PROMPT_MARKER_FALLBACK_MS = 1e4;
-var QUIET_DETECT_MS = 500;
+var QUIET_DETECT_MS2 = 500;
 function buildPasteBytes(input) {
   return `\x1B[200~${input}\x1B[201~`;
 }
@@ -1414,6 +1646,7 @@ var PTYManager = class {
   onPermissionChange;
   onLiveQuestion;
   onLiveQuestionGone;
+  onUserMessage;
   // Per-session permission-gate state. True between an OSC 777 (gate open) and
   // the next prompt-ready without a fresh 777 (gate closed). Prevents
   // re-broadcasting open/close on every chunk.
@@ -1459,6 +1692,7 @@ var PTYManager = class {
     this.onPermissionChange = options.onPermissionChange;
     this.onLiveQuestion = options.onLiveQuestion;
     this.onLiveQuestionGone = options.onLiveQuestionGone;
+    this.onUserMessage = options.onUserMessage;
     this.log = options.logger ?? getLogger("pty");
   }
   // Resume an existing Claude conversation. sessionId is the JSONL UUID.
@@ -1521,7 +1755,8 @@ var PTYManager = class {
       lastOutput: "",
       process: proc,
       outputBuffer: Buffer.alloc(0),
-      screen: createScreen2()
+      screen: createScreen2(),
+      inputHistory: []
     };
     this.sessions.set(sessionId, session);
     this.pendingReady.add(sessionId);
@@ -1572,7 +1807,8 @@ var PTYManager = class {
       lastOutput: "",
       process: proc,
       outputBuffer: Buffer.alloc(0),
-      screen: createScreen2()
+      screen: createScreen2(),
+      inputHistory: []
     };
     this.sessions.set(sessionId, session);
     this.pendingReady.add(sessionId);
@@ -1652,6 +1888,7 @@ var PTYManager = class {
   // step gives the TUI as many extra ticks as it needs, capped at
   // SUBMIT_MAX_WAIT_MS so a silent/wedged PTY still gets its \r eventually.
   writeSubmit(sessionId, session, input, path, promptCount) {
+    this.recordUserMessage(session, input);
     const pasteBytes = buildPasteBytes(input);
     this.log.info(
       `[pty.input.write] ${sessionId.slice(0, 8)} promptCount=${promptCount} bytes=${pasteBytes.length} digest=${digestBytes2(pasteBytes)}`,
@@ -1782,6 +2019,20 @@ var PTYManager = class {
     }
     return lines.slice(-maxLines);
   }
+  getInputHistory(sessionId) {
+    return this.sessions.get(sessionId)?.inputHistory ?? [];
+  }
+  // Record a submitted user message as ground truth and fire onUserMessage.
+  // Called from writeSubmit (both direct and flush paths) — never from
+  // sendKeys, so raw keystrokes aren't logged as messages.
+  recordUserMessage(session, text) {
+    const ts = Date.now();
+    session.inputHistory.push({ text, ts });
+    if (session.inputHistory.length > INPUT_HISTORY_MAX2) {
+      session.inputHistory.shift();
+    }
+    this.onUserMessage?.(session.id, text, ts);
+  }
   getSession(sessionId) {
     const session = this.sessions.get(sessionId);
     return session ? toPublicSession2(session) : null;
@@ -1861,7 +2112,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();
@@ -2078,6 +2329,9 @@ var LiveSessionManager = class {
   getOutputLines(sessionId, maxLines) {
     return this.runnerFor(sessionId).getOutputLines(sessionId, maxLines);
   }
+  getInputHistory(sessionId) {
+    return this.runnerFor(sessionId).getInputHistory(sessionId);
+  }
   getSession(sessionId) {
     for (const runner of this.runners.values()) {
       const session = runner.getSession(sessionId);
@@ -2122,7 +2376,7 @@ var LiveSessionManager = class {
 // src/process-discovery.ts
 import { execFile } from "child_process";
 import { platform as platform2 } from "os";
-import { basename as basename4, dirname as dirname3 } from "path";
+import { basename as basename4, dirname as dirname4 } from "path";
 async function discoverClaudeProcesses() {
   if (platform2() === "win32") return discoverWindows();
   return discoverUnix();
@@ -2244,7 +2498,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 ? dirname3(exePath) : "";
+    const cwd = exePath ? dirname4(exePath) : "";
     return { cwd, args, startedAt };
   } catch {
     return null;
@@ -2276,16 +2530,16 @@ import {
 import { EventEmitter } from "events";
 import {
   createReadStream,
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   watch as fsWatch,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync6,
-  statSync as statSync5
+  readFileSync as readFileSync7,
+  statSync as statSync6
 } from "fs";
 import { realpath as realpath2 } from "fs/promises";
 import { createServer } from "http";
-import { homedir as homedir5 } from "os";
-import { dirname as dirname7, join as join12 } from "path";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname8, join as join15 } from "path";
 import { createInterface } from "readline";
 
 // node_modules/nanoid/index.js
@@ -2469,7 +2723,7 @@ async function handleSendAgentInput(sessionId, body, deps) {
 
 // src/agent/handle-start-agent-session.ts
 import { existsSync as existsSync4 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 function validateBody(body) {
   if (body === null || body === void 0 || typeof body !== "object") {
     return { ok: false };
@@ -2499,7 +2753,7 @@ async function handleStartAgentSession(body, deps) {
   }
   let conversationId = parsed.conversationId;
   if (conversationId) {
-    const jsonlPath = join5(deps.conversationsDir, `${conversationId}.jsonl`);
+    const jsonlPath = join6(deps.conversationsDir, `${conversationId}.jsonl`);
     if (!existsSync4(jsonlPath)) {
       return {
         status: 404,
@@ -2544,14 +2798,15 @@ async function handleStartAgentSession(body, deps) {
 }
 
 // src/api/app.ts
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono12 } from "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", "/ws"]);
+var PUBLIC_PATHS = /* @__PURE__ */ new Set(["/healthz"]);
+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) => {
@@ -2562,8 +2817,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;
@@ -2696,8 +2955,8 @@ var createConversationRoutes = (deps) => {
 import { Hono as Hono4 } from "hono";
 
 // src/version.ts
-import { readFileSync as readFileSync3, realpathSync } from "fs";
-import { dirname as dirname4, join as join6 } from "path";
+import { readFileSync as readFileSync4, realpathSync } from "fs";
+import { dirname as dirname5, join as join7 } from "path";
 var cached;
 function getVersion() {
   if (cached !== void 0) return cached;
@@ -2706,22 +2965,22 @@ function getVersion() {
 }
 function resolveVersion() {
   const scriptPath = process.argv[1] ?? "";
-  const here = scriptPath ? dirname4(scriptPath) : process.cwd();
+  const here = scriptPath ? dirname5(scriptPath) : process.cwd();
   let realHere = here;
   try {
-    realHere = dirname4(realpathSync(scriptPath));
+    realHere = dirname5(realpathSync(scriptPath));
   } catch {
   }
-  const searchDirs = realHere === here ? [here, join6(here, "..")] : [here, join6(here, ".."), realHere, join6(realHere, "..")];
+  const searchDirs = realHere === here ? [here, join7(here, "..")] : [here, join7(here, ".."), realHere, join7(realHere, "..")];
   for (const dir of searchDirs) {
     try {
-      const v = readFileSync3(join6(dir, "version.txt"), "utf8").trim();
+      const v = readFileSync4(join7(dir, "version.txt"), "utf8").trim();
       if (v) return v;
     } catch {
     }
   }
   try {
-    const pkg = JSON.parse(readFileSync3(join6(here, "..", "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync4(join7(here, "..", "package.json"), "utf8"));
     if (pkg.version) return `${pkg.version}+source`;
   } catch {
   }
@@ -2735,16 +2994,145 @@ var createHealthRoutes = () => {
   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";
+
+// src/lifecycle/constants.ts
+import { homedir as homedir4 } from "os";
+import { join as join8 } from "path";
+var TASK_NAME = process.env.THREADBASE_TASK_NAME ?? "Threadbase";
+function installDir() {
+  return process.env.THREADBASE_INSTALL_DIR ?? join8(homedir4(), ".threadbase");
+}
+
+// src/api/routes/logs.routes.ts
+var logger2 = getLogger("logs-api");
+function resolveLogPath(source) {
+  return join9(installDir(), "logs", `${source}.log`);
+}
+function pickDefaultSource() {
+  for (const source of ["stdout", "stderr", "dev"]) {
+    const p = resolveLogPath(source);
+    if (existsSync5(p) && statSync(p).size > 0) return source;
+  }
+  return "stdout";
+}
+function readLogLines(filePath, sinceOffset, limit) {
+  if (!existsSync5(filePath)) {
+    return { lines: [], offset: 0, total: 0 };
+  }
+  const fd = openSync(filePath, "r");
+  try {
+    const { size } = 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);
+    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 {
+    closeSync(fd);
+  }
+}
+function createLogsRoutes() {
+  const app = new Hono5();
+  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 (!existsSync5(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 = 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 (!existsSync5(logPath)) {
+          return { source, exists: false, total: 0, fileSize: 0 };
+        }
+        const stats = 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
 import { spawn } from "child_process";
 import { createHmac, timingSafeEqual as timingSafeEqual2 } from "crypto";
-import { Hono as Hono5 } from "hono";
+import { Hono as Hono6 } from "hono";
 import { hostname } from "os";
 
 // src/config/update-config.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join10 } from "path";
 import { parse as parseYaml } from "yaml";
 
 // src/schemas/updateConfig.schema.ts
@@ -2760,12 +3148,12 @@ var UpdateConfigSchema = z.object({
 }).strict();
 
 // src/config/update-config.ts
-var DEFAULT_CONFIG_PATH = join7(homedir3(), ".threadbase", "update.yaml");
+var DEFAULT_CONFIG_PATH = join10(homedir5(), ".threadbase", "update.yaml");
 function loadUpdateConfig(opts = {}) {
   const path = opts.path ?? DEFAULT_CONFIG_PATH;
   let raw;
   try {
-    raw = readFileSync4(path, "utf-8");
+    raw = readFileSync5(path, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw err;
@@ -2812,7 +3200,7 @@ function verifyWebhookSignature(body, header, secret) {
 }
 var clientLog = getLogger("client");
 var createMiscRoutes = (deps) => {
-  const app = new Hono5();
+  const app = new Hono6();
   app.get("/api/info", (c) => {
     const ptyIds = deps.ptyAttachedIds();
     return c.json({
@@ -2888,11 +3276,11 @@ var createMiscRoutes = (deps) => {
 };
 
 // src/api/routes/pair.routes.ts
-import { Hono as Hono6 } from "hono";
+import { Hono as Hono7 } from "hono";
 var ALREADY_HANDLED3 = 597;
 var alreadyHandled3 = () => new Response(null, { status: ALREADY_HANDLED3 });
 var createPairRoutes = (deps) => {
-  const app = new Hono6();
+  const app = new Hono7();
   app.post("/start", (c) => {
     deps.handlePairStart(c.env.outgoing);
     return alreadyHandled3();
@@ -2905,11 +3293,11 @@ var createPairRoutes = (deps) => {
 };
 
 // src/api/routes/projects.routes.ts
-import { Hono as Hono7 } from "hono";
+import { Hono as Hono8 } from "hono";
 var ALREADY_HANDLED4 = 597;
 var alreadyHandled4 = () => new Response(null, { status: ALREADY_HANDLED4 });
 var createProjectRoutes = (deps) => {
-  const app = new Hono7();
+  const app = new Hono8();
   app.get("/", (c) => {
     const url = new URL(c.req.url);
     deps.handleListProjects(url, c.env.outgoing);
@@ -2924,11 +3312,11 @@ var createProjectRoutes = (deps) => {
 };
 
 // src/api/routes/scanner.routes.ts
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono9 } from "hono";
 var ALREADY_HANDLED5 = 597;
 var alreadyHandled5 = () => new Response(null, { status: ALREADY_HANDLED5 });
 var createScannerRoutes = (deps) => {
-  const app = new Hono8();
+  const app = new Hono9();
   app.get("/api/search", async (c) => {
     const url = new URL(c.req.url);
     await deps.handleSearch(url, c.env.outgoing);
@@ -2938,11 +3326,11 @@ var createScannerRoutes = (deps) => {
 };
 
 // src/api/routes/sessions.routes.ts
-import { Hono as Hono9 } from "hono";
+import { Hono as Hono10 } from "hono";
 var ALREADY_HANDLED6 = 597;
 var alreadyHandled6 = () => new Response(null, { status: ALREADY_HANDLED6 });
 var createSessionRoutes = (deps) => {
-  const app = new Hono9();
+  const app = new Hono10();
   app.get("/count", (c) => {
     deps.handleSessionsCount(c.env.outgoing);
     return alreadyHandled6();
@@ -3009,21 +3397,19 @@ var createSessionRoutes = (deps) => {
 };
 
 // src/api/routes/ws.routes.ts
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono11 } from "hono";
 var createWsRoutes = (deps, upgradeWebSocket) => {
-  const app = new Hono10();
+  const app = new Hono11();
   app.get(
     "/ws",
-    upgradeWebSocket((c) => {
-      const key = c.req.query("key");
-      const preAuthed = typeof key === "string" && validateApiKey(key, deps.apiKey);
+    upgradeWebSocket(() => {
       let openWs = null;
       return {
         onOpen(_evt, ws) {
           const raw = ws.raw;
           if (!raw) return;
           openWs = raw;
-          deps.handleWsOpen(raw, preAuthed);
+          deps.handleWsOpen(raw);
         },
         onMessage(evt, _ws) {
           if (openWs) deps.handleWsMessage(openWs, evt.data);
@@ -3039,7 +3425,7 @@ var createWsRoutes = (deps, upgradeWebSocket) => {
 
 // src/api/app.ts
 var createHonoApp = (deps, upgradeWebSocket) => {
-  const app = new Hono11();
+  const app = new Hono12();
   const httpLog = getLogger("http");
   app.use("*", async (c, next) => {
     const start = Date.now();
@@ -3068,6 +3454,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));
   }
@@ -3076,7 +3463,7 @@ var createHonoApp = (deps, upgradeWebSocket) => {
 
 // src/browse.ts
 import { mkdir as mkdir2, readdir, realpath, stat } from "fs/promises";
-import { join as join8, resolve, sep } from "path";
+import { join as join11, resolve, sep } from "path";
 var BrowsePathNotFoundError = class extends Error {
   constructor(message) {
     super(message);
@@ -3114,7 +3501,7 @@ async function createDirectory(parentAbsolutePath, name) {
   if (name.includes("/") || name.includes("\\") || name === ".." || name === ".") {
     throw new Error("Invalid directory name");
   }
-  const target = join8(parentAbsolutePath, name);
+  const target = join11(parentAbsolutePath, name);
   try {
     const s = await stat(target);
     if (s.isDirectory()) throw new Error("Directory already exists");
@@ -3131,18 +3518,18 @@ import {
   parseJsonlLine
 } from "@threadbase-sh/scanner";
 import Database from "better-sqlite3";
-import { closeSync as closeSync2, existsSync as existsSync5, mkdirSync as mkdirSync2, openSync as openSync2, readSync as readSync2, statSync as statSync2 } from "fs";
+import { closeSync as closeSync3, existsSync as existsSync6, mkdirSync as mkdirSync3, openSync as openSync3, readSync as readSync3, statSync as statSync3 } from "fs";
 import { open as openAsync } from "fs/promises";
-import { dirname as dirname6 } from "path";
+import { dirname as dirname7 } from "path";
 import { setImmediate as yieldToEventLoop } from "timers/promises";
 
 // src/db/sqlite-migrate.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname5, join as join9 } from "path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname6, join as join12 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getMigrationsDir2() {
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    return dirname5(fileURLToPath2(import.meta.url));
+    return dirname6(fileURLToPath2(import.meta.url));
   }
   return __dirname;
 }
@@ -3154,7 +3541,7 @@ CREATE TABLE IF NOT EXISTS schema_migrations (
 `;
 function runSqliteMigrations(db, migrationsDir) {
   db.exec(SCHEMA_MIGRATIONS_SQL);
-  const dir = migrationsDir ?? join9(getMigrationsDir2(), "migrations");
+  const dir = migrationsDir ?? join12(getMigrationsDir2(), "migrations");
   const files = readdirSync2(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));
@@ -3166,7 +3553,7 @@ function runSqliteMigrations(db, migrationsDir) {
       skipped.push(file);
       continue;
     }
-    const sql = readFileSync5(join9(dir, file), "utf-8");
+    const sql = readFileSync6(join12(dir, file), "utf-8");
     const tx = db.transaction(() => {
       db.exec(sql);
       recordApplied.run(file, (/* @__PURE__ */ new Date()).toISOString());
@@ -3178,7 +3565,7 @@ function runSqliteMigrations(db, migrationsDir) {
 }
 
 // src/services/conversations/isAgentConversation.ts
-import { closeSync, openSync, readSync, statSync } from "fs";
+import { closeSync as closeSync2, openSync as openSync2, readSync as readSync2, statSync as statSync2 } from "fs";
 var DEFAULT_AGENT_ENTRYPOINTS = /* @__PURE__ */ new Set(["sdk-cli", "claude-vscode"]);
 var CHUNK_BYTES = 64 * 1024;
 var ENTRYPOINT_PROBE = `"entrypoint":`;
@@ -3200,12 +3587,12 @@ function isAgentFile(filePath, entrypoints = DEFAULT_AGENT_ENTRYPOINTS) {
   if (cached2 !== void 0) return cached2;
   let fd;
   try {
-    fd = openSync(filePath, "r");
+    fd = openSync2(filePath, "r");
   } catch {
     return false;
   }
   try {
-    const fileSize = statSync(filePath).size;
+    const fileSize = statSync2(filePath).size;
     if (fileSize === 0) {
       fileDecisionCache.set(key, false);
       return false;
@@ -3216,7 +3603,7 @@ function isAgentFile(filePath, entrypoints = DEFAULT_AGENT_ENTRYPOINTS) {
     let carry = "";
     while (offset < fileSize) {
       const toRead = Math.min(CHUNK_BYTES, fileSize - offset);
-      const got = readSync(fd, buf, 0, toRead, offset);
+      const got = readSync2(fd, buf, 0, toRead, offset);
       if (got <= 0) break;
       const chunk = carry + buf.toString("utf8", 0, got);
       for (const marker of markers) {
@@ -3237,7 +3624,7 @@ function isAgentFile(filePath, entrypoints = DEFAULT_AGENT_ENTRYPOINTS) {
   } catch {
     return false;
   } finally {
-    closeSync(fd);
+    closeSync2(fd);
   }
 }
 function parseAgentEntrypointsEnv(raw) {
@@ -3774,7 +4161,7 @@ var ConversationCache = class _ConversationCache {
     if (!fileState) return null;
     let stat3;
     try {
-      stat3 = statSync2(filePath);
+      stat3 = statSync3(filePath);
     } catch {
       return null;
     }
@@ -3795,17 +4182,17 @@ var ConversationCache = class _ConversationCache {
     );
     if (rows.length === 0) return { messages: [], total, fromIndex: from };
     const messages = [];
-    const fd = openSync2(filePath, "r");
+    const fd = openSync3(filePath, "r");
     try {
       const state = createJsonlParseState();
       for (const row of rows) {
         const buf = Buffer.alloc(row.byte_length);
-        readSync2(fd, buf, 0, row.byte_length, row.byte_offset);
+        readSync3(fd, buf, 0, row.byte_length, row.byte_offset);
         const msg = parseJsonlLine(buf.toString("utf-8"), state);
         if (msg) messages.push(msg);
       }
     } finally {
-      closeSync2(fd);
+      closeSync3(fd);
     }
     return { messages, total, fromIndex: from };
   }
@@ -3833,14 +4220,14 @@ var ConversationCache = class _ConversationCache {
   isAgentFileCached(filePath) {
     let s;
     try {
-      s = statSync2(filePath);
+      s = statSync3(filePath);
     } catch {
       return false;
     }
     return this.classifyAgentFile(filePath, s.mtimeMs, s.size);
   }
   static open(dbPath, tailSize = 10, migrationsDir, options) {
-    mkdirSync2(dirname6(dbPath), { recursive: true });
+    mkdirSync3(dirname7(dbPath), { recursive: true });
     const db = new Database(dbPath);
     db.pragma("journal_mode = WAL");
     db.pragma("foreign_keys = ON");
@@ -4021,7 +4408,7 @@ var ConversationCache = class _ConversationCache {
         let mtimeMs = null;
         let fileSize = null;
         try {
-          const s = statSync2(m.filePath);
+          const s = statSync3(m.filePath);
           mtimeMs = s.mtimeMs;
           fileSize = s.size;
         } catch {
@@ -4080,8 +4467,8 @@ var ConversationCache = class _ConversationCache {
     let fileSize;
     let fd;
     try {
-      fileSize = statSync2(filePath).size;
-      fd = openSync2(filePath, "r");
+      fileSize = statSync3(filePath).size;
+      fd = openSync3(filePath, "r");
     } catch {
       return false;
     }
@@ -4094,7 +4481,7 @@ var ConversationCache = class _ConversationCache {
       while (pos > 0 && lines.length < this.tailSize * 4) {
         const toRead = Math.min(CHUNK, pos);
         pos -= toRead;
-        readSync2(fd, buf, 0, toRead, pos);
+        readSync3(fd, buf, 0, toRead, pos);
         const chunk = buf.subarray(0, toRead).toString("utf8");
         const combined = chunk + partial;
         const parts = combined.split("\n");
@@ -4105,7 +4492,7 @@ var ConversationCache = class _ConversationCache {
       }
       if (partial) lines.push(partial);
     } finally {
-      closeSync2(fd);
+      closeSync3(fd);
     }
     const msgs = [];
     for (let i = 0; i < lines.length && msgs.length < this.tailSize; i++) {
@@ -4307,7 +4694,7 @@ var ConversationCache = class _ConversationCache {
    * `handleGetConversation` can still serve the cached tail even when the
    * JSONL has been deleted.
    */
-  pruneGhostFiles(exists = existsSync5) {
+  pruneGhostFiles(exists = existsSync6) {
     const rows = this.stmts.allFilePaths.all();
     const ghosts = [];
     const prune = this.db.transaction((ids) => {
@@ -4362,7 +4749,7 @@ var ConversationCache = class _ConversationCache {
    * Returns the removed IDs.
    */
   reconcileDeletions(livePaths, opts) {
-    const exists = opts?.exists ?? existsSync5;
+    const exists = opts?.exists ?? existsSync6;
     const rows = this.stmts.allFilePaths.all();
     const removed = [];
     const drop = this.db.transaction((ids) => {
@@ -4591,23 +4978,23 @@ async function recordUpload(pool2, instanceId, row) {
 }
 
 // src/handlers/handleListProjects.ts
-import { readdirSync as readdirSync3, statSync as statSync3 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join10 } from "path";
+import { readdirSync as readdirSync3, statSync as statSync4 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join13 } from "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 = join10(homedir4(), ".claude", "projects");
+  const projectsDir = join13(homedir6(), ".claude", "projects");
   let entries;
   try {
     entries = readdirSync3(projectsDir).map((dirName) => {
-      const fullPath = join10(projectsDir, dirName);
+      const fullPath = join13(projectsDir, dirName);
       let mtime = 0;
       try {
-        mtime = statSync3(fullPath).mtimeMs;
+        mtime = statSync4(fullPath).mtimeMs;
       } catch {
       }
       const path = decodeProjectPath(dirName);
@@ -4702,7 +5089,7 @@ function seal(plaintext, recipientPublicKeyBase64) {
 
 // src/services/conversations/conversationWatcher.ts
 import chokidar from "chokidar";
-import { statSync as statSync4 } from "fs";
+import { statSync as statSync5 } from "fs";
 import { open, stat as stat2 } from "fs/promises";
 var ConversationWatcher = class {
   files = /* @__PURE__ */ new Map();
@@ -4725,7 +5112,7 @@ var ConversationWatcher = class {
     if (this.files.has(filePath)) return;
     let offset;
     try {
-      offset = statSync4(filePath).size;
+      offset = statSync5(filePath).size;
     } catch {
       offset = 0;
     }
@@ -4900,14 +5287,14 @@ function findSearchTarget(messages, query) {
 }
 
 // src/services/conversations/pruneAgentConversations.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } 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 (!existsSync6(row.file_path)) {
+    if (!existsSync7(row.file_path)) {
       missing += 1;
       continue;
     }
@@ -4930,13 +5317,6 @@ 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;
@@ -5250,7 +5630,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 join11 } from "path";
+import { join as join14 } from "path";
 var UPLOAD_DIR_NAME = ".threadbase-uploads";
 var MAX_BYTES = 25 * 1024 * 1024;
 var HEIC_MIMES = /* @__PURE__ */ new Set(["image/heic", "image/heif"]);
@@ -5283,9 +5663,9 @@ async function saveUploadFile(input) {
   }
   const id = `up_${randomBytes3(8).toString("hex")}`;
   const safeName = sanitizeFilename(originalName) || `file${MIME_TO_EXT[mimeType] ?? ""}`;
-  const dir = join11(input.projectPath, UPLOAD_DIR_NAME, input.sessionId);
+  const dir = join14(input.projectPath, UPLOAD_DIR_NAME, input.sessionId);
   await mkdir3(dir, { recursive: true });
-  const filePath = join11(dir, `${Date.now()}-${id}-${safeName}`);
+  const filePath = join14(dir, `${Date.now()}-${id}-${safeName}`);
   await writeFile(filePath, buffer);
   return {
     id,
@@ -5541,10 +5921,8 @@ 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();
@@ -5633,14 +6011,6 @@ 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;
@@ -5678,12 +6048,11 @@ var StreamerServer = class {
     this.disableDb = config.disableDb ?? false;
     this.scannerPersistenceDisabled = config.scannerPersistent === false;
     this.scanProfiles = config.scanProfiles;
-    this.codexRoots = config.codexRoots ?? [join12(homedir5(), ".codex", "sessions")];
+    this.codexRoots = config.codexRoots ?? [join15(homedir7(), ".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() ?? join12(homedir5(), ".threadbase", "cache");
+    this.cacheDir = config.cacheDir ?? loadCacheDir() ?? join15(homedir7(), ".threadbase", "cache");
     this.tailSize = config.tailSize ?? loadTailSize() ?? 10;
     this.directoryDebounceMs = parseDirScanDebounceEnv(process.env.THREADBASE_DIR_SCAN_DEBOUNCE_MS) ?? config.directoryScanDebounceMs ?? 1e3;
     this.markScannerStaleDebounced = debounce(() => {
@@ -5724,7 +6093,7 @@ var StreamerServer = class {
           const seqs = cache.extendMessageIndex(
             filePath,
             spans,
-            statSync5(filePath),
+            statSync6(filePath),
             readFrom,
             endOffset
           );
@@ -5809,6 +6178,9 @@ var StreamerServer = class {
       onOutput: (sessionId, data) => {
         this.wsHub.broadcast({ type: "terminal_output", sessionId, data });
       },
+      onUserMessage: (sessionId, text, ts) => {
+        this.wsHub.broadcast({ type: "user_message", sessionId, text, ts });
+      },
       onPermissionChange: (sessionId, gate) => {
         this.handlePermissionChange(sessionId, gate);
       },
@@ -5885,7 +6257,7 @@ var StreamerServer = class {
         temporalClient,
         taskQueue: agentConfig.temporal.taskQueue
       });
-      const conversationsBaseDir = agentConfig.conversationsDir || join12(dirname7(this.cacheDir), "conversations");
+      const conversationsBaseDir = agentConfig.conversationsDir || join15(dirname8(this.cacheDir), "conversations");
       conversationWriter = createConversationWriter({
         baseDir: conversationsBaseDir
       });
@@ -5938,39 +6310,17 @@ 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, preAuthed) => {
-        if (preAuthed) {
-          this.completeWsAuth(ws);
-          return;
+      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" }));
         }
-        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);
@@ -5981,24 +6331,56 @@ var StreamerServer = class {
             this.addSessionSubscriber(msg.sessionId, ws);
             if (this.ptyManager.hasSession(msg.sessionId)) {
               const lines = await this.ptyManager.getOutputLines(msg.sessionId, 200);
-              ws.send(JSON.stringify({ type: "terminal_replay", sessionId: msg.sessionId, lines }));
+              const userMessages = this.ptyManager.getInputHistory(msg.sessionId);
+              ws.send(
+                JSON.stringify({
+                  type: "terminal_replay",
+                  sessionId: msg.sessionId,
+                  lines,
+                  userMessages
+                })
+              );
+            }
+            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") {
-            if (this.sessionSubscribers.get(msg.sessionId)?.has(ws)) {
-              this.startGraceTimer(msg.sessionId, 0);
-            }
+            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);
@@ -6068,20 +6450,6 @@ 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) {
@@ -6153,7 +6521,7 @@ var StreamerServer = class {
         });
         try {
           this.cache = ConversationCache.open(
-            join12(this.cacheDir, "cache.db"),
+            join15(this.cacheDir, "cache.db"),
             this.tailSize,
             void 0,
             {
@@ -6179,11 +6547,11 @@ var StreamerServer = class {
           if (this.scanProfiles && this.scanProfiles.length > 0) {
             for (const profile of this.scanProfiles) {
               if (profile.enabled) {
-                this.fileWatcher.watchDirectory(join12(profile.configDir, "projects"));
+                this.fileWatcher.watchDirectory(join15(profile.configDir, "projects"));
               }
             }
           } else {
-            this.fileWatcher.watchDirectory(join12(homedir5(), ".claude", "projects"));
+            this.fileWatcher.watchDirectory(join15(homedir7(), ".claude", "projects"));
           }
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
@@ -6368,9 +6736,6 @@ 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();
@@ -6768,17 +7133,17 @@ var StreamerServer = class {
     return scanner;
   }
   findJsonlPath(uuid) {
-    const projectsDir = join12(homedir5(), ".claude", "projects");
-    if (!existsSync7(projectsDir)) return null;
+    const projectsDir = join15(homedir7(), ".claude", "projects");
+    if (!existsSync8(projectsDir)) return null;
     const filename = `${uuid}.jsonl`;
     for (const dir of readdirSync4(projectsDir)) {
-      const fp = join12(projectsDir, dir, filename);
-      if (existsSync7(fp)) return fp;
-      const projectDir = join12(projectsDir, dir);
+      const fp = join15(projectsDir, dir, filename);
+      if (existsSync8(fp)) return fp;
+      const projectDir = join15(projectsDir, dir);
       try {
         for (const sub of readdirSync4(projectDir)) {
-          const subagentPath = join12(projectDir, sub, "subagents", filename);
-          if (existsSync7(subagentPath)) return subagentPath;
+          const subagentPath = join15(projectDir, sub, "subagents", filename);
+          if (existsSync8(subagentPath)) return subagentPath;
         }
       } catch {
       }
@@ -6925,7 +7290,7 @@ var StreamerServer = class {
     if (!conv.filePath) return false;
     let mtimeMs = null;
     try {
-      mtimeMs = statSync5(conv.filePath).mtimeMs;
+      mtimeMs = statSync6(conv.filePath).mtimeMs;
     } catch {
       return false;
     }
@@ -7293,7 +7658,7 @@ var StreamerServer = class {
   handleGetSession(sessionId, res) {
     const session = this.sessionStore.get(sessionId, this.ptyAttachedIds());
     if (session) {
-      if (!existsSync7(session.projectPath)) {
+      if (!existsSync8(session.projectPath)) {
         session.failureReason = `Project directory not found: ${session.projectPath}`;
       }
       json(res, 200, session);
@@ -7497,16 +7862,17 @@ 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: safeOptions,
+      options: gate.options,
       ...gate.cursor !== void 0 ? { cursor: gate.cursor } : {}
     });
   }
@@ -7693,7 +8059,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 ? join12(dirname7(this.cacheDir), "conversations") : "",
+        conversationsDir: this.cacheDir ? join15(dirname8(this.cacheDir), "conversations") : "",
         agentConfig: this.agentConfig
       });
       json(res, result.status, result.body);
@@ -7834,9 +8200,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 = join12(homedir5(), ".claude", "projects", encoded);
+    const projectsDir = join15(homedir7(), ".claude", "projects", encoded);
     const expectedFile = `${sessionId}.jsonl`;
-    const filePath = join12(projectsDir, expectedFile);
+    const filePath = join15(projectsDir, expectedFile);
     const deadline = Date.now() + 12e4;
     let watcher = null;
     const cleanup = () => {
@@ -7854,12 +8220,12 @@ var StreamerServer = class {
         cleanup();
         return;
       }
-      let resolvedFilePath = existsSync7(filePath) ? filePath : null;
-      if (!resolvedFilePath && existsSync7(projectsDir)) {
+      let resolvedFilePath = existsSync8(filePath) ? filePath : null;
+      if (!resolvedFilePath && existsSync8(projectsDir)) {
         try {
           const now = Date.now();
-          const recent = readdirSync4(projectsDir).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, mtime: statSync5(join12(projectsDir, f)).mtimeMs })).filter(({ mtime }) => now - mtime < 5e3).sort((a, b) => b.mtime - a.mtime)[0];
-          if (recent) resolvedFilePath = join12(projectsDir, recent.f);
+          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);
         } catch {
         }
       }
@@ -7868,7 +8234,7 @@ var StreamerServer = class {
       this.sessionFileMap.set(sessionId, resolvedFilePath);
       this.fileWatcher.watch(resolvedFilePath);
       try {
-        const existing = readFileSync6(resolvedFilePath, "utf8").split("\n").filter(Boolean);
+        const existing = readFileSync7(resolvedFilePath, "utf8").split("\n").filter(Boolean);
         if (existing.length > 0) {
           this.broadcastConversationLines(sessionId, existing);
         }
@@ -7907,7 +8273,7 @@ var StreamerServer = class {
   watchForCodexRollout(sessionId, projectPath) {
     const deadline = Date.now() + 12e4;
     const now = /* @__PURE__ */ new Date();
-    const dateDir = join12(
+    const dateDir = join15(
       String(now.getFullYear()),
       String(now.getMonth() + 1).padStart(2, "0"),
       String(now.getDate()).padStart(2, "0")
@@ -7920,7 +8286,7 @@ var StreamerServer = class {
     };
     const matchesProjectPath = (candidatePath) => {
       try {
-        const firstLine = readFileSync6(candidatePath, "utf8").split("\n", 1)[0];
+        const firstLine = readFileSync7(candidatePath, "utf8").split("\n", 1)[0];
         if (!firstLine) return null;
         const parsed = JSON.parse(firstLine);
         if (parsed?.type !== "session_meta") return null;
@@ -7948,8 +8314,8 @@ 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 = join12(root, dateDir);
-        if (!existsSync7(sessionsDir)) continue;
+        const sessionsDir = join15(root, dateDir);
+        if (!existsSync8(sessionsDir)) continue;
         let candidateFiles;
         try {
           candidateFiles = readdirSync4(sessionsDir).filter((f) => f.endsWith(".jsonl"));
@@ -7957,9 +8323,9 @@ var StreamerServer = class {
           continue;
         }
         const nowMs = Date.now();
-        const recentCandidates = candidateFiles.map((f) => ({ f, mtime: statSync5(join12(sessionsDir, f)).mtimeMs })).filter(({ mtime }) => nowMs - mtime < 1e4).sort((a, b) => b.mtime - a.mtime);
+        const recentCandidates = candidateFiles.map((f) => ({ f, mtime: statSync6(join15(sessionsDir, f)).mtimeMs })).filter(({ mtime }) => nowMs - mtime < 1e4).sort((a, b) => b.mtime - a.mtime);
         for (const { f } of recentCandidates) {
-          const candidatePath = join12(sessionsDir, f);
+          const candidatePath = join15(sessionsDir, f);
           const match = matchesProjectPath(candidatePath);
           if (!match) continue;
           if (boundElsewhere.has(match.id)) continue;
@@ -7969,7 +8335,7 @@ var StreamerServer = class {
           this.sessionFileMap.set(sessionId, candidatePath);
           this.fileWatcher.watch(candidatePath);
           try {
-            const existing = readFileSync6(candidatePath, "utf8").split("\n").filter(Boolean);
+            const existing = readFileSync7(candidatePath, "utf8").split("\n").filter(Boolean);
             if (existing.length > 0) {
               this.broadcastConversationLines(sessionId, existing);
             }
@@ -8091,7 +8457,7 @@ var StreamerServer = class {
 };
 function classifyResumability(cwd) {
   if (!cwd) return { resumable: true };
-  if (existsSync7(cwd)) return { resumable: true };
+  if (existsSync8(cwd)) return { resumable: true };
   const ranInWorktree = /\/\.worktrees\//.test(cwd) || /\/\.claude\/worktrees\//.test(cwd);
   return {
     resumable: false,