@threadbase-sh/streamer 1.27.3 → 1.28.1

package/dist/cli.cjs

@@ -30931,7 +30931,7 @@ var require_websocket = __commonJS({
     var http = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes: randomBytes4, createHash: createHash4 } = require("crypto");
+    var { randomBytes: randomBytes4, createHash: createHash5 } = require("crypto");
     var { Duplex, Readable: Readable3 } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -31599,7 +31599,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash4("sha1").update(key + GUID).digest("base64");
+        const digest = createHash5("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -31968,7 +31968,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter6 = require("events");
     var http = require("http");
     var { Duplex } = require("stream");
-    var { createHash: createHash4 } = require("crypto");
+    var { createHash: createHash5 } = require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -32275,7 +32275,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash4("sha1").update(key + GUID).digest("base64");
+        const digest = createHash5("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -123750,14 +123750,14 @@ __export(prompt_exports, {
   interactivePermissionModePrompt: () => interactivePermissionModePrompt,
   interactivePrompt: () => interactivePrompt
 });
-var import_node_process2, import_promises20, interactivePrompt, interactivePermissionModePrompt;
+var import_node_process2, import_promises22, interactivePrompt, interactivePermissionModePrompt;
 var init_prompt = __esm({
   "src/lifecycle/prompt.ts"() {
     "use strict";
     import_node_process2 = require("process");
-    import_promises20 = require("readline/promises");
+    import_promises22 = require("readline/promises");
     interactivePrompt = async ({ prodPort, suggestedAltPort, prodActive }) => {
-      const rl = (0, import_promises20.createInterface)({ input: import_node_process2.stdin, output: import_node_process2.stdout });
+      const rl = (0, import_promises22.createInterface)({ input: import_node_process2.stdin, output: import_node_process2.stdout });
       try {
         if (!prodActive) {
           import_node_process2.stdout.write(
@@ -123792,7 +123792,7 @@ The supervised prod streamer is already holding port ${prodPort}.
       }
     };
     interactivePermissionModePrompt = async () => {
-      const rl = (0, import_promises20.createInterface)({ input: import_node_process2.stdin, output: import_node_process2.stdout });
+      const rl = (0, import_promises22.createInterface)({ input: import_node_process2.stdin, output: import_node_process2.stdout });
       try {
         import_node_process2.stdout.write(
           "\nWhich permission mode should spawned Claude Code sessions use?\n  [a] acceptEdits \u2014 auto-approve file edits, still prompt for shell commands (default)\n  [m] manual \u2014 prompt for every edit and command\n"
@@ -130940,6 +130940,17 @@ function reduceConvLine(state, entry) {
     attachment: entry.attachment !== void 0 ? entry.attachment : void 0
   };
 }
+function parseJsonlLine(line, state = initialConvState()) {
+  const text = line.trimEnd();
+  if (text.trim().length === 0) return null;
+  let entry;
+  try {
+    entry = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  return reduceConvLine(state, entry);
+}
 function applyTeamInfo(messages, state) {
   if (Object.keys(state.teamInfo).length === 0) return;
   for (const m2 of messages) {
@@ -133520,7 +133531,7 @@ async function search(query, options, scanner) {
 // src/server.ts
 var import_events3 = require("events");
 var import_fs25 = require("fs");
-var import_promises17 = require("fs/promises");
+var import_promises19 = require("fs/promises");
 var import_http = require("http");
 var import_os10 = require("os");
 var import_path22 = require("path");
@@ -136666,7 +136677,9 @@ async function createDirectory(parentAbsolutePath, name) {
 // src/conversation-cache.ts
 var import_better_sqlite32 = __toESM(require("better-sqlite3"), 1);
 var import_fs17 = require("fs");
+var import_promises12 = require("fs/promises");
 var import_path13 = require("path");
+var import_promises13 = require("timers/promises");
 
 // src/db/sqlite-migrate.ts
 var import_fs15 = require("fs");
@@ -136792,6 +136805,33 @@ function parseAgentEntrypointsEnv(raw2) {
   return new Set(parts);
 }
 
+// src/utils/fileIdentity.ts
+var import_crypto5 = require("crypto");
+function fileIdentity(stat10, headBytes) {
+  if (stat10.ino && stat10.ino > 0) return `inode:${stat10.dev}:${stat10.ino}`;
+  const head = headBytes ?? Buffer.alloc(0);
+  return `fp:${(0, import_crypto5.createHash)("sha1").update(head).digest("hex")}`;
+}
+function splitCompleteLines(buf, baseOffset) {
+  const spans = [];
+  let lineStart = 0;
+  let consumed = 0;
+  for (let i = 0; i < buf.length; i++) {
+    if (buf[i] !== 10) continue;
+    const lineLen = i - lineStart;
+    if (lineLen > 0) {
+      spans.push({
+        byteOffset: baseOffset + lineStart,
+        byteLength: lineLen,
+        text: buf.toString("utf-8", lineStart, i)
+      });
+    }
+    lineStart = i + 1;
+    consumed = lineStart;
+  }
+  return { spans, consumed };
+}
+
 // src/conversation-cache.ts
 function shortProjectName(fullPath) {
   const parts = fullPath.split(/[/\\]/).filter(Boolean);
@@ -136840,6 +136880,14 @@ var ConversationCache = class _ConversationCache {
   tailSize;
   fileIndex = /* @__PURE__ */ new Map();
   fileIndexLoaded = false;
+  // Per-file scanner parse state for the incremental offset-index writer. The
+  // reducer is stateful across lines (pending tool_uses, latest timestamp), so
+  // it must persist between watcher reads of the same file. Cleared on
+  // truncation/backfill.
+  indexParseState = /* @__PURE__ */ new Map();
+  // Single-flight guard for backfillIndex — concurrent detail requests for the
+  // same cold file await one walk, not N. Entry dropped on settle.
+  backfillInFlight = /* @__PURE__ */ new Map();
   // Monotonically increasing counter for tail updated_at — guarantees strict
   // ordering even when multiple updateFromLine() calls land within the same ms.
   tailSeq = Date.now();
@@ -137003,6 +137051,42 @@ var ConversationCache = class _ConversationCache {
          GROUP BY project_path
          ORDER BY cnt DESC
          LIMIT ?`
+      ),
+      getFileState: db.prepare("SELECT * FROM conversation_file_state WHERE path = ?"),
+      upsertFileState: db.prepare(
+        `INSERT INTO conversation_file_state
+           (path, identity, size, mtime_ms, byte_offset, last_message_index)
+         VALUES (@path, @identity, @size, @mtime_ms, @byte_offset, @last_message_index)
+         ON CONFLICT(path) DO UPDATE SET
+           identity           = excluded.identity,
+           size               = excluded.size,
+           mtime_ms           = excluded.mtime_ms,
+           byte_offset        = excluded.byte_offset,
+           last_message_index = excluded.last_message_index`
+      ),
+      deleteFileState: db.prepare("DELETE FROM conversation_file_state WHERE path = ?"),
+      deleteMessageIndex: db.prepare(
+        "DELETE FROM conversation_message_index WHERE conversation_id = ?"
+      ),
+      insertMessageIndexRow: db.prepare(
+        `INSERT INTO conversation_message_index
+           (conversation_id, message_index, byte_offset, byte_length, uuid, role, ts)
+         VALUES (@conversation_id, @message_index, @byte_offset, @byte_length, @uuid, @role, @ts)
+         ON CONFLICT(conversation_id, message_index) DO UPDATE SET
+           byte_offset = excluded.byte_offset,
+           byte_length = excluded.byte_length,
+           uuid        = excluded.uuid,
+           role        = excluded.role,
+           ts          = excluded.ts`
+      ),
+      getMessageIndexWindow: db.prepare(
+        `SELECT message_index, byte_offset, byte_length, uuid, role, ts
+         FROM conversation_message_index
+         WHERE conversation_id = ? AND message_index >= ? AND message_index < ?
+         ORDER BY message_index ASC`
+      ),
+      getIndexedMessageCount: db.prepare(
+        "SELECT COUNT(*) as cnt FROM conversation_message_index WHERE conversation_id = ?"
       )
     };
   }
@@ -137013,6 +137097,273 @@ var ConversationCache = class _ConversationCache {
   getDatabase() {
     return this.db;
   }
+  // ── Offset index (design 1b) ────────────────────────────────────────────
+  // conversation_file_state + conversation_message_index back the windowed
+  // detail read path (SQL window select + pread of byte ranges). All methods
+  // are thin wrappers over the prepared statements above.
+  getFileState(path2) {
+    return this.stmts.getFileState.get(path2) ?? null;
+  }
+  upsertFileState(row) {
+    this.stmts.upsertFileState.run(row);
+  }
+  /** Drop a file's index rows + file_state (truncation / identity change). */
+  deleteFileIndex(path2, conversationId) {
+    const tx = this.db.transaction(() => {
+      this.stmts.deleteMessageIndex.run(conversationId);
+      this.stmts.deleteFileState.run(path2);
+    });
+    tx();
+    this.indexParseState.delete(path2);
+  }
+  /** Append/replace index rows in one transaction. */
+  appendMessageIndexRows(rows) {
+    const tx = this.db.transaction((batch) => {
+      for (const r of batch) this.stmts.insertMessageIndexRow.run(r);
+    });
+    tx(rows);
+  }
+  /** Rows for message_index in [fromIndex, toIndex), ordered ascending. */
+  getMessageIndexWindow(conversationId, fromIndex, toIndex) {
+    return this.stmts.getMessageIndexWindow.all(
+      conversationId,
+      fromIndex,
+      toIndex
+    );
+  }
+  getIndexedMessageCount(conversationId) {
+    return this.stmts.getIndexedMessageCount.get(conversationId).cnt;
+  }
+  /**
+   * Conversation id for a JSONL path — the filename stem (matches the pseudo-id
+   * updateFromLine derives and the uuid the detail read path resolves). The
+   * offset index keys on this so the window select and the cursor agree.
+   */
+  static conversationIdForFile(filePath) {
+    return filePath.split(/[/\\]/).pop()?.replace(/\.jsonl$/, "") ?? filePath;
+  }
+  // The offset index understands only claude-code JSONL: parseJsonlLine is the
+  // claude-code reducer, so a codex file "indexes" as zero messages and the
+  // resulting file_state serves empty windows for a real conversation (the
+  // silent-wrong-data bug hotfixed after 1.28.0). Non-claude providers are
+  // excluded from the index entirely; the scanner serves them (it routes each
+  // provider to its own parser).
+  isIndexableFile(filePath) {
+    const meta3 = this.getMetaById(_ConversationCache.conversationIdForFile(filePath));
+    return (meta3?.provider ?? CLAUDE_CODE_PROVIDER2) === CLAUDE_CODE_PROVIDER2;
+  }
+  /**
+   * Incremental offset-index writer: extend the index for a burst of appended
+   * lines (one watcher read) using their byte spans. Each line is classified
+   * with the scanner's parseJsonlLine (a running per-file reducer state), so the
+   * message ordering can never drift from the scanner's. Message lines get an
+   * index row at the next message_index; non-message lines (summary/sidecar)
+   * get no row but still advance byte_offset. file_state is updated to the end
+   * of the last consumed span.
+   *
+   * Requires an up-to-date `stat` (identity/size/mtime) for the file so the read
+   * path can detect truncation/replacement.
+   *
+   * `readFrom` is the absolute byte offset the watcher read started at, and
+   * `endOffset` is where it ended (readFrom + consumed, i.e. the watcher's new
+   * entry.offset). CONTIGUITY GUARD: the read must begin exactly where the index
+   * left off (`readFrom === existing.byte_offset`, or 0 with no state). If it
+   * doesn't — the watcher attached at EOF after the server was down, or an
+   * append raced an in-flight backfill — extending would assign wrong
+   * message_index values over a hole. In that case this writes nothing and
+   * returns null so the caller drops the index and backfills.
+   *
+   * On success returns the message_index assigned to each input span (null for a
+   * non-message line) so the caller can stamp WS `seq`. Empty array when spans
+   * is empty. `endOffset` is stored verbatim as byte_offset so the watcher's
+   * offset and file_state.byte_offset are the same number by construction.
+   */
+  extendMessageIndex(filePath, spans, stat10, readFrom, endOffset) {
+    if (!this.isIndexableFile(filePath)) return spans.map(() => null);
+    const existing = this.getFileState(filePath);
+    const expectedStart = existing?.byte_offset ?? 0;
+    if (readFrom !== expectedStart) return null;
+    if (spans.length === 0) return [];
+    const convId = _ConversationCache.conversationIdForFile(filePath);
+    let state = this.indexParseState.get(filePath);
+    if (!state) {
+      state = initialConvState();
+      this.indexParseState.set(filePath, state);
+    }
+    let nextIndex = existing ? existing.last_message_index + 1 : 0;
+    const rows = [];
+    const seqs = [];
+    for (const span of spans) {
+      const msg = parseJsonlLine(span.text, state);
+      if (!msg) {
+        seqs.push(null);
+        continue;
+      }
+      rows.push({
+        conversation_id: convId,
+        message_index: nextIndex,
+        byte_offset: span.byteOffset,
+        byte_length: span.byteLength,
+        uuid: msg.uuid ?? null,
+        role: msg.role ?? null,
+        ts: msg.timestamp ? Date.parse(msg.timestamp) || null : null
+      });
+      seqs.push(nextIndex);
+      nextIndex++;
+    }
+    const tx = this.db.transaction(() => {
+      for (const r of rows) this.stmts.insertMessageIndexRow.run(r);
+      this.stmts.upsertFileState.run({
+        path: filePath,
+        identity: fileIdentity(stat10),
+        size: stat10.size,
+        mtime_ms: Math.round(stat10.mtimeMs),
+        // Store the watcher's end offset verbatim — same number as entry.offset,
+        // so the next read's contiguity check compares like-for-like (never
+        // false-positive on a read that ended in trailing empty lines).
+        byte_offset: endOffset,
+        last_message_index: nextIndex - 1
+      });
+    });
+    tx();
+    return seqs;
+  }
+  clearIndexParseState(filePath) {
+    this.indexParseState.delete(filePath);
+  }
+  /**
+   * On-demand full backfill of the offset index for a file with no/stale
+   * file_state (cold conversation, or after a truncation/replacement). Rebuilds
+   * from byte 0: drops any existing rows, walks the whole file in chunks with a
+   * running parse state, yields to the event loop every ~1000 lines so a large
+   * file never blocks, and writes index rows + file_state.
+   *
+   * Single-flighted per path: concurrent callers await the same walk. The
+   * triggering detail request is served by the scanner fallback while this runs.
+   */
+  backfillIndex(filePath) {
+    const inFlight = this.backfillInFlight.get(filePath);
+    if (inFlight) return inFlight;
+    const walk = this.runBackfill(filePath).finally(() => {
+      this.backfillInFlight.delete(filePath);
+    });
+    this.backfillInFlight.set(filePath, walk);
+    return walk;
+  }
+  async runBackfill(filePath) {
+    const convId = _ConversationCache.conversationIdForFile(filePath);
+    this.deleteFileIndex(filePath, convId);
+    this.indexParseState.delete(filePath);
+    if (!this.isIndexableFile(filePath)) return;
+    const CHUNK = 256 * 1024;
+    const YIELD_EVERY = 1e3;
+    const state = initialConvState();
+    const fh = await (0, import_promises12.open)(filePath, "r");
+    let fileOffset = 0;
+    let carry = Buffer.alloc(0);
+    let nextIndex = 0;
+    let linesSinceYield = 0;
+    let lastConsumedEnd = 0;
+    let stat10;
+    try {
+      stat10 = await fh.stat();
+      const buf = Buffer.alloc(CHUNK);
+      for (; ; ) {
+        const { bytesRead } = await fh.read(buf, 0, CHUNK, null);
+        if (bytesRead === 0) break;
+        const combined = carry.length > 0 ? Buffer.concat([carry, buf.subarray(0, bytesRead)]) : buf.subarray(0, bytesRead);
+        const { spans, consumed } = splitCompleteLines(combined, fileOffset);
+        const rows = [];
+        for (const span of spans) {
+          const msg = parseJsonlLine(span.text, state);
+          linesSinceYield++;
+          if (msg) {
+            rows.push({
+              conversation_id: convId,
+              message_index: nextIndex,
+              byte_offset: span.byteOffset,
+              byte_length: span.byteLength,
+              uuid: msg.uuid ?? null,
+              role: msg.role ?? null,
+              ts: msg.timestamp ? Date.parse(msg.timestamp) || null : null
+            });
+            nextIndex++;
+          }
+          if (linesSinceYield >= YIELD_EVERY) {
+            linesSinceYield = 0;
+            await (0, import_promises13.setImmediate)();
+          }
+        }
+        if (rows.length > 0) this.appendMessageIndexRows(rows);
+        lastConsumedEnd = fileOffset + consumed;
+        carry = Buffer.from(combined.subarray(consumed));
+        fileOffset += consumed;
+      }
+    } finally {
+      await fh.close();
+    }
+    this.upsertFileState({
+      path: filePath,
+      identity: fileIdentity(stat10),
+      size: stat10.size,
+      mtime_ms: Math.round(stat10.mtimeMs),
+      byte_offset: lastConsumedEnd,
+      last_message_index: nextIndex - 1
+    });
+    this.indexParseState.set(filePath, state);
+  }
+  /**
+   * Windowed detail read straight from the offset index — the hot path.
+   * Returns the parsed messages for message_index in [fromIndex, toIndex) plus
+   * the total indexed count, or null when the index can't serve this file (no
+   * file_state, identity/size mismatch = truncation/replacement, or cold index)
+   * so the caller falls back to the scanner and enqueues a backfill.
+   *
+   * On a match it SQL-selects the window's byte ranges and preads exactly those
+   * ranges from the JSONL (never the whole file), parsing only the sliced lines.
+   * Returns messages in the same ConversationMessage shape parseJsonlLine
+   * produces during a scan, so the payload is identical to the scanner path.
+   */
+  readMessageWindow(filePath, fromIndex, toIndex) {
+    const fileState = this.getFileState(filePath);
+    if (!fileState) return null;
+    let stat10;
+    try {
+      stat10 = (0, import_fs17.statSync)(filePath);
+    } catch {
+      return null;
+    }
+    if (fileIdentity(stat10) !== fileState.identity || stat10.size !== fileState.byte_offset) {
+      return null;
+    }
+    if (fileState.last_message_index < 0 || !this.isIndexableFile(filePath)) {
+      return null;
+    }
+    const total = fileState.last_message_index + 1;
+    const from = Math.max(0, fromIndex);
+    const to2 = Math.min(toIndex, total);
+    if (to2 <= from) return { messages: [], total, fromIndex: from };
+    const rows = this.getMessageIndexWindow(
+      _ConversationCache.conversationIdForFile(filePath),
+      from,
+      to2
+    );
+    if (rows.length === 0) return { messages: [], total, fromIndex: from };
+    const messages = [];
+    const fd = (0, import_fs17.openSync)(filePath, "r");
+    try {
+      const state = initialConvState();
+      for (const row of rows) {
+        const buf = Buffer.alloc(row.byte_length);
+        (0, import_fs17.readSync)(fd, buf, 0, row.byte_length, row.byte_offset);
+        const msg = parseJsonlLine(buf.toString("utf-8"), state);
+        if (msg) messages.push(msg);
+      }
+    } finally {
+      (0, import_fs17.closeSync)(fd);
+    }
+    return { messages, total, fromIndex: from };
+  }
   agentEntrypointsKey() {
     return [...this.agentEntrypoints].sort().join(",");
   }
@@ -137736,7 +138087,7 @@ var ConversationsRepository = class {
 };
 
 // src/db/repositories/projects.repository.ts
-var import_crypto5 = require("crypto");
+var import_crypto6 = require("crypto");
 
 // src/utils/canonicalizeProjectPath.ts
 function canonicalizeProjectPath(projectPath) {
@@ -137829,7 +138180,7 @@ var ProjectsRepository = class {
       });
       return rowToProject(this.getById.get(existing.id));
     }
-    const id = (0, import_crypto5.randomUUID)();
+    const id = (0, import_crypto6.randomUUID)();
     this.insert.run({
       id,
       path: path2,
@@ -137924,7 +138275,7 @@ var import_path19 = require("path");
 
 // src/codex-pty-runner.ts
 var import_headless = __toESM(require_xterm_headless(), 1);
-var import_crypto6 = require("crypto");
+var import_crypto7 = require("crypto");
 var import_fs21 = require("fs");
 var import_path17 = require("path");
 init_logger();
@@ -138179,7 +138530,7 @@ var CodexPtyRunner = class {
   // ManagedSession handle only.
   async startFresh(options) {
     const nodePty = await loadPty();
-    const sessionId = (0, import_crypto6.randomUUID)();
+    const sessionId = (0, import_crypto7.randomUUID)();
     const projectName = options.projectName ?? (0, import_path17.basename)(options.projectPath);
     const args = ["--cd", options.projectPath, "--no-alt-screen"];
     if (options.systemPrompt) {
@@ -138508,7 +138859,7 @@ function stripAnsi(str) {
 
 // src/pty-manager.ts
 var import_headless2 = __toESM(require_xterm_headless(), 1);
-var import_crypto7 = require("crypto");
+var import_crypto8 = require("crypto");
 var import_fs22 = require("fs");
 var import_path18 = require("path");
 init_logger();
@@ -138912,7 +139263,7 @@ var PTYManager = class {
   // onReady fires once Claude reaches its first prompt (waiting_input).
   async startFresh(options) {
     const nodePty = await loadPty2();
-    const sessionId = (0, import_crypto7.randomUUID)();
+    const sessionId = (0, import_crypto8.randomUUID)();
     const projectName = options.projectName ?? (0, import_path18.basename)(options.projectPath);
     const args = [
       "--permission-mode",
@@ -139496,7 +139847,7 @@ var LiveSessionManager = class {
 init_logger();
 
 // src/pair-store.ts
-var import_crypto8 = require("crypto");
+var import_crypto9 = require("crypto");
 var DEFAULT_TTL_SECONDS = 180;
 var SWEEP_INTERVAL_MS = 6e4;
 var PairTokenStore = class {
@@ -139511,7 +139862,7 @@ var PairTokenStore = class {
     }
   }
   mint() {
-    const token = `pt_${(0, import_crypto8.randomBytes)(16).toString("hex")}`;
+    const token = `pt_${(0, import_crypto9.randomBytes)(16).toString("hex")}`;
     const expiresAt = Date.now() + this.ttlMs;
     this.current = { token, expiresAt, used: false };
     return {
@@ -139716,11 +140067,11 @@ function seal(plaintext, recipientPublicKeyBase64) {
 // node_modules/chokidar/index.js
 var import_node_events2 = require("events");
 var import_node_fs7 = require("fs");
-var import_promises14 = require("fs/promises");
+var import_promises16 = require("fs/promises");
 var sp2 = __toESM(require("path"), 1);
 
 // node_modules/readdirp/index.js
-var import_promises12 = require("fs/promises");
+var import_promises14 = require("fs/promises");
 var import_node_path9 = require("path");
 var import_node_stream2 = require("stream");
 var EntryTypes2 = {
@@ -139801,7 +140152,7 @@ var ReaddirpStream2 = class extends import_node_stream2.Readable {
     const { root, type } = opts;
     this._fileFilter = normalizeFilter2(opts.fileFilter);
     this._directoryFilter = normalizeFilter2(opts.directoryFilter);
-    const statMethod = opts.lstat ? import_promises12.lstat : import_promises12.stat;
+    const statMethod = opts.lstat ? import_promises14.lstat : import_promises14.stat;
     if (wantBigintFsStats2) {
       this._stat = (path2) => statMethod(path2, { bigint: true });
     } else {
@@ -139872,7 +140223,7 @@ var ReaddirpStream2 = class extends import_node_stream2.Readable {
   async _exploreDir(path2, depth) {
     let files;
     try {
-      files = await (0, import_promises12.readdir)(path2, this._rdOptions);
+      files = await (0, import_promises14.readdir)(path2, this._rdOptions);
     } catch (error51) {
       this._onError(error51);
     }
@@ -139910,8 +140261,8 @@ var ReaddirpStream2 = class extends import_node_stream2.Readable {
     if (stats && stats.isSymbolicLink()) {
       const full = entry.fullPath;
       try {
-        const entryRealPath = await (0, import_promises12.realpath)(full);
-        const entryRealPathStats = await (0, import_promises12.lstat)(entryRealPath);
+        const entryRealPath = await (0, import_promises14.realpath)(full);
+        const entryRealPathStats = await (0, import_promises14.lstat)(entryRealPath);
         if (entryRealPathStats.isFile()) {
           return "file";
         }
@@ -139954,7 +140305,7 @@ function readdirp2(root, options = {}) {
 
 // node_modules/chokidar/handler.js
 var import_node_fs6 = require("fs");
-var import_promises13 = require("fs/promises");
+var import_promises15 = require("fs/promises");
 var import_node_os3 = require("os");
 var sp = __toESM(require("path"), 1);
 var STR_DATA2 = "data";
@@ -139981,7 +140332,7 @@ var EVENTS2 = {
 };
 var EV2 = EVENTS2;
 var THROTTLE_MODE_WATCH2 = "watch";
-var statMethods2 = { lstat: import_promises13.lstat, stat: import_promises13.stat };
+var statMethods2 = { lstat: import_promises15.lstat, stat: import_promises15.stat };
 var KEY_LISTENERS2 = "listeners";
 var KEY_ERR2 = "errHandlers";
 var KEY_RAW2 = "rawEmitters";
@@ -140338,7 +140689,7 @@ var setFsWatchListener2 = (path2, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows3 && error51.code === "EPERM") {
         try {
-          const fd = await (0, import_promises13.open)(path2, "r");
+          const fd = await (0, import_promises15.open)(path2, "r");
           await fd.close();
           broadcastErr(error51);
         } catch (err) {
@@ -140469,7 +140820,7 @@ var NodeFsHandler2 = class {
         return;
       if (!newStats || newStats.mtimeMs === 0) {
         try {
-          const newStats2 = await (0, import_promises13.stat)(file2);
+          const newStats2 = await (0, import_promises15.stat)(file2);
           if (this.fsw.closed)
             return;
           const at2 = newStats2.atimeMs;
@@ -140524,7 +140875,7 @@ var NodeFsHandler2 = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises13.realpath)(path2);
+        linkPath = await (0, import_promises15.realpath)(path2);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -140673,7 +141024,7 @@ var NodeFsHandler2 = class {
       let closer;
       if (stats.isDirectory()) {
         const absPath = sp.resolve(path2);
-        const targetPath = follow ? await (0, import_promises13.realpath)(path2) : path2;
+        const targetPath = follow ? await (0, import_promises15.realpath)(path2) : path2;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -140683,7 +141034,7 @@ var NodeFsHandler2 = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises13.realpath)(path2) : path2;
+        const targetPath = follow ? await (0, import_promises15.realpath)(path2) : path2;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
@@ -140843,7 +141194,7 @@ var DirEntry2 = class {
       return;
     const dir = this.path;
     try {
-      await (0, import_promises14.readdir)(dir);
+      await (0, import_promises16.readdir)(dir);
     } catch (err) {
       if (this._removeWatcher) {
         this._removeWatcher(sp2.dirname(dir), sp2.basename(dir));
@@ -141193,7 +141544,7 @@ var FSWatcher2 = class extends import_node_events2.EventEmitter {
       const fullPath = opts.cwd ? sp2.join(opts.cwd, path2) : path2;
       let stats2;
       try {
-        stats2 = await (0, import_promises14.stat)(fullPath);
+        stats2 = await (0, import_promises16.stat)(fullPath);
       } catch (err) {
       }
       if (!stats2 || this.closed)
@@ -141447,18 +141798,20 @@ var chokidar_default = { watch: watch2, FSWatcher: FSWatcher2 };
 
 // src/services/conversations/conversationWatcher.ts
 var import_fs23 = require("fs");
-var import_promises15 = require("fs/promises");
+var import_promises17 = require("fs/promises");
 var ConversationWatcher = class {
   files = /* @__PURE__ */ new Map();
   directories = /* @__PURE__ */ new Map();
   onNewLine;
   onNewLines;
+  onNewLineSpans;
   onConversationChanged;
   onFileDeleted;
   onError;
   constructor(events = {}) {
     this.onNewLine = events.onNewLine;
     this.onNewLines = events.onNewLines;
+    this.onNewLineSpans = events.onNewLineSpans;
     this.onConversationChanged = events.onConversationChanged;
     this.onFileDeleted = events.onFileDeleted;
     this.onError = events.onError;
@@ -141551,20 +141904,24 @@ var ConversationWatcher = class {
     entry.reading = true;
     try {
       for (; ; ) {
-        const st2 = await (0, import_promises15.stat)(filePath);
+        const st2 = await (0, import_promises17.stat)(filePath);
         if (st2.size <= entry.offset) break;
         const readFrom = entry.offset;
         const bytesToRead = st2.size - readFrom;
         const buf = Buffer.alloc(bytesToRead);
-        const fh = await (0, import_promises15.open)(filePath, "r");
+        const fh = await (0, import_promises17.open)(filePath, "r");
         try {
           await fh.read(buf, 0, bytesToRead, readFrom);
         } finally {
           await fh.close();
         }
-        entry.offset = readFrom + bytesToRead;
+        const { spans, consumed } = splitCompleteLines(buf, readFrom);
+        entry.offset = readFrom + consumed;
         if (!this.files.has(filePath)) return;
-        const lines = buf.toString("utf-8").split("\n").filter(Boolean);
+        const lines = spans.map((s3) => s3.text);
+        if (spans.length > 0) {
+          this.onNewLineSpans?.(filePath, spans, readFrom, entry.offset);
+        }
         if (this.onNewLines) {
           this.onNewLines(filePath, lines);
         } else {
@@ -142004,8 +142361,8 @@ function discoveredToResponse(d, conversationId) {
 }
 
 // src/uploads.ts
-var import_crypto9 = require("crypto");
-var import_promises16 = require("fs/promises");
+var import_crypto10 = require("crypto");
+var import_promises18 = require("fs/promises");
 var import_heic_convert = __toESM(require_heic_convert(), 1);
 var import_path21 = require("path");
 var UPLOAD_DIR_NAME = ".threadbase-uploads";
@@ -142038,12 +142395,12 @@ async function saveUploadFile(input) {
     mimeType = "image/jpeg";
     originalName = originalName.replace(/\.(heic|heif)$/i, ".jpg");
   }
-  const id = `up_${(0, import_crypto9.randomBytes)(8).toString("hex")}`;
+  const id = `up_${(0, import_crypto10.randomBytes)(8).toString("hex")}`;
   const safeName = sanitizeFilename(originalName) || `file${MIME_TO_EXT[mimeType] ?? ""}`;
   const dir = (0, import_path21.join)(input.projectPath, UPLOAD_DIR_NAME, input.sessionId);
-  await (0, import_promises16.mkdir)(dir, { recursive: true });
+  await (0, import_promises18.mkdir)(dir, { recursive: true });
   const filePath = (0, import_path21.join)(dir, `${Date.now()}-${id}-${safeName}`);
-  await (0, import_promises16.writeFile)(filePath, buffer);
+  await (0, import_promises18.writeFile)(filePath, buffer);
   return {
     id,
     filePath,
@@ -142442,6 +142799,10 @@ var StreamerServer = class {
   fileWatcher;
   sessionFileMap = /* @__PURE__ */ new Map();
   // sessionId → JSONL filePath
+  // Per-file seq assignments from the most recent onNewLineSpans (offset index),
+  // handed to the immediately-following onNewLines so it can stamp WS `seq` on
+  // the matching conversation_events entries. Same read → same lines order.
+  pendingLineSeqs = /* @__PURE__ */ new Map();
   pendingQuestions = /* @__PURE__ */ new Map();
   // Content key of the AskUserQuestion currently broadcast for a session (from
   // either the rendered screen or JSONL), used to de-dupe the two paths: when
@@ -142565,7 +142926,7 @@ var StreamerServer = class {
     this.agentEntrypoints = parseAgentEntrypointsEnv(process.env.THREADBASE_AGENT_ENTRYPOINTS);
     const rawRoot = process.env.THREADBASE_BROWSE_ROOT ?? loadBrowseRoot() ?? config2.browseRoot;
     if (rawRoot) {
-      (0, import_promises17.realpath)(rawRoot).then((resolved) => {
+      (0, import_promises19.realpath)(rawRoot).then((resolved) => {
         this.browseRoot = resolved;
         if (this.verbose) this.log.info(`Browse root: ${resolved}`, { browseRoot: resolved });
       }).catch(() => {
@@ -142587,6 +142948,42 @@ var StreamerServer = class {
     this.sessionStore = new SessionStore();
     this.wsHub = new WSHub();
     this.fileWatcher = new ConversationWatcher({
+      onNewLineSpans: (filePath, spans, readFrom, endOffset) => {
+        if (!this.cache) return;
+        const cache = this.cache;
+        this.pendingLineSeqs.delete(filePath);
+        try {
+          const seqs = cache.extendMessageIndex(
+            filePath,
+            spans,
+            (0, import_fs25.statSync)(filePath),
+            readFrom,
+            endOffset
+          );
+          if (seqs === null) {
+            cache.deleteFileIndex(filePath, ConversationCache.conversationIdForFile(filePath));
+            cache.clearIndexParseState(filePath);
+            this.trackCacheWrite(
+              cache.backfillIndex(filePath).catch((err) => {
+                this.log.warn("offset-index.backfill_failed", {
+                  event: "offset_index.backfill_failed",
+                  filePath,
+                  trigger: "noncontiguous-append",
+                  err
+                });
+              })
+            );
+            return;
+          }
+          this.pendingLineSeqs.set(filePath, seqs);
+        } catch (err) {
+          this.log.warn("offset-index.extend_failed", {
+            event: "offset_index.extend_failed",
+            filePath,
+            err
+          });
+        }
+      },
       onNewLines: (filePath, lines) => {
         this.cache?.updateFromLines(filePath, lines);
         for (const [sessionId, watchedPath] of this.sessionFileMap) {
@@ -142613,13 +143010,20 @@ var StreamerServer = class {
               this.pendingQuestionKey.set(sessionId, key);
               if (broadcast) this.wsHub.broadcast(m2);
             }
-            this.wsHub.broadcast({ type: "conversation_events", sessionId, lines });
+            const seqs = this.pendingLineSeqs.get(filePath);
+            this.wsHub.broadcast({
+              type: "conversation_events",
+              sessionId,
+              lines,
+              ...seqs && seqs.length === lines.length ? { seqs } : {}
+            });
             for (const line of lines) {
               this.wsHub.broadcast({ type: "conversation_event", sessionId, line });
             }
             break;
           }
         }
+        this.pendingLineSeqs.delete(filePath);
       },
       onConversationChanged: (filePath) => {
         this.fileWatcher.poke(filePath);
@@ -143703,9 +144107,13 @@ var StreamerServer = class {
       return;
     }
     const etagSource = conversation;
+    const indexedCount = etagSource.filePath && this.cache ? this.cache.getIndexedMessageCount(
+      ConversationCache.conversationIdForFile(etagSource.filePath)
+    ) : 0;
+    const etagMessageCount = Math.max(etagSource.messageCount, indexedCount);
     const etag = computeConversationEtag({
       filePath: etagSource.filePath,
-      messageCount: etagSource.messageCount,
+      messageCount: etagMessageCount,
       timestamp: etagSource.timestamp
     });
     const isFirstPage = !url2.searchParams.has("before_index") && !url2.searchParams.has("anchor_index") && !url2.searchParams.has("after_index");
@@ -143722,12 +144130,14 @@ var StreamerServer = class {
     let slice = filtered;
     let fromIdx = 0;
     let messagePagination;
+    let indexTotal = null;
     if (usePaging) {
       const limit = Math.min(Math.max(intParam(url2, "msg_limit", 80), 1), 500);
       let beforeIndex = total;
       let scanLimit = limit;
       let anchorIndex = null;
       let newerPaging = false;
+      let usedAfterIndex = false;
       if (url2.searchParams.has("before_index")) {
         beforeIndex = intParam(url2, "before_index", total);
         beforeIndex = Math.min(Math.max(beforeIndex, 0), total);
@@ -143736,6 +144146,7 @@ var StreamerServer = class {
         beforeIndex = Math.min(total, from + limit);
         scanLimit = beforeIndex - from;
         newerPaging = true;
+        usedAfterIndex = true;
       } else if (hasAnchor) {
         anchorIndex = Math.min(
           Math.max(intParam(url2, "anchor_index", 0), 0),
@@ -143745,9 +144156,34 @@ var StreamerServer = class {
         beforeIndex = Math.min(total, from + limit);
         newerPaging = true;
       }
-      const pagedScanner = this.scannerReady ? await this.getScanner(true) : null;
-      const page = scanLimit > 0 && pagedScanner && typeof pagedScanner.getConversationPage === "function" ? await pagedScanner.getConversationPage(id, { beforeIndex, limit: scanLimit }) : null;
-      const start = page?.fromIndex ?? Math.max(0, beforeIndex - scanLimit);
+      const isTailRequest = !url2.searchParams.has("before_index") && !hasAfter && !hasAnchor;
+      const indexFilePath = conversation.filePath;
+      if (isTailRequest && indexFilePath && this.cache) {
+        const indexed = this.cache.getIndexedMessageCount(
+          ConversationCache.conversationIdForFile(indexFilePath)
+        );
+        if (indexed > beforeIndex) {
+          beforeIndex = indexed;
+        }
+      }
+      const windowStart = Math.max(0, beforeIndex - scanLimit);
+      const indexWindow = scanLimit > 0 && !hasAnchor && indexFilePath && this.cache ? this.cache.readMessageWindow(indexFilePath, windowStart, beforeIndex) : null;
+      if (!indexWindow && indexFilePath && this.cache && !hasAnchor) {
+        this.trackCacheWrite(
+          this.cache.backfillIndex(indexFilePath).catch((err) => {
+            this.log.warn("offset-index.backfill_failed", {
+              event: "offset_index.backfill_failed",
+              conversationId: id,
+              filePath: indexFilePath,
+              err
+            });
+          })
+        );
+      }
+      const pagedScanner = !indexWindow && this.scannerReady ? await this.getScanner(true) : null;
+      const page = indexWindow ?? (scanLimit > 0 && pagedScanner && typeof pagedScanner.getConversationPage === "function" ? await pagedScanner.getConversationPage(id, { beforeIndex, limit: scanLimit }) : null);
+      if (indexWindow) indexTotal = indexWindow.total;
+      const start = page?.fromIndex ?? windowStart;
       slice = page?.messages ?? filtered.slice(start, beforeIndex);
       fromIdx = start;
       const effectiveTotal = page?.total ?? total;
@@ -143763,6 +144199,9 @@ var StreamerServer = class {
         messagePagination.has_more_newer = beforeIndex < effectiveTotal;
         messagePagination.next_after_index = beforeIndex < effectiveTotal ? beforeIndex : null;
       }
+      if (usedAfterIndex) {
+        messagePagination.etag = etag;
+      }
     }
     const messagesPayload = slice.map((m2, localIdx) => {
       const content = [];
@@ -143804,6 +144243,8 @@ var StreamerServer = class {
     const cachedConvMeta = this.cache?.getMetaById(id);
     const convProvider = coerceProviderForRunner(conv.provider ?? cachedConvMeta?.provider);
     const availability = classifyResumability(conv.projectPath);
+    const metaMessageCount = indexTotal != null && indexTotal > conv.messageCount ? indexTotal : conv.messageCount;
+    const metaLastUpdatedAt = indexTotal != null && indexTotal > conv.messageCount ? slice.at(-1)?.timestamp ?? conv.timestamp : conv.timestamp;
     const body = {
       meta: {
         id,
@@ -143811,8 +144252,8 @@ var StreamerServer = class {
         project_name: conv.projectName,
         project_path: conv.projectPath,
         file_path: conv.filePath,
-        last_updated_at: conv.timestamp,
-        message_count: conv.messageCount,
+        last_updated_at: metaLastUpdatedAt,
+        message_count: metaMessageCount,
         last_prompt: conv.lastPrompt ?? void 0,
         provider: convProvider,
         resumable: isProviderResumable(convProvider, availability.resumable),
@@ -145094,7 +145535,7 @@ function isBrewInstall(scriptPath = process.argv[1] ?? "") {
 var import_node_crypto4 = require("crypto");
 var import_node_fs8 = require("fs");
 var import_node_path10 = require("path");
-var import_promises18 = require("stream/promises");
+var import_promises20 = require("stream/promises");
 
 // src/updater/manifest.ts
 init_zod();
@@ -145169,7 +145610,7 @@ async function downloadAndVerify(opts) {
     }
   });
   try {
-    await (0, import_promises18.pipeline)(res.body.pipeThrough(measured), out);
+    await (0, import_promises20.pipeline)(res.body.pipeThrough(measured), out);
   } catch (err) {
     (0, import_node_fs8.rmSync)(targetPath, { force: true });
     throw err;
@@ -145383,7 +145824,7 @@ var import_fs29 = __toESM(require("fs"), 1);
 var import_node_fs14 = __toESM(require("fs"), 1);
 var import_node_path19 = __toESM(require("path"), 1);
 var import_node_fs15 = __toESM(require("fs"), 1);
-var import_promises19 = __toESM(require("fs/promises"), 1);
+var import_promises21 = __toESM(require("fs/promises"), 1);
 var import_node_path20 = __toESM(require("path"), 1);
 var import_node_path21 = require("path");
 var import_node_fs16 = __toESM(require("fs"), 1);
@@ -147615,7 +148056,7 @@ var gr = (s3, t2, e) => {
     E2 ? e(E2) : x2 && a ? Es(x2, o, h, (Le) => S2(Le)) : n ? import_node_fs15.default.chmod(s3, r, e) : e();
   };
   if (s3 === d) return no(s3, S2);
-  if (l) return import_promises19.default.mkdir(s3, { mode: r, recursive: true }).then((E2) => S2(null, E2 ?? void 0), S2);
+  if (l) return import_promises21.default.mkdir(s3, { mode: r, recursive: true }).then((E2) => S2(null, E2 ?? void 0), S2);
   let D2 = f(import_node_path20.default.relative(d, s3)).split("/");
   Ss(d, D2, r, c, d, void 0, S2);
 };