cc-viewer 1.7.1 → 1.7.2

package/dist/index.html

@@ -21,7 +21,7 @@
     // 整体显示大小已弃用 CSS zoom：Electron 改用 webFrame.setZoomFactor（首屏抢占见
     // electron/tab-content-preload.js），纯浏览器交由用户用浏览器自带快捷键缩放，故此处不再设 zoom。
   </script>
-  <script type="module" crossorigin src="./assets/index-B51Ci0GL.js"></script>
+  <script type="module" crossorigin src="./assets/index-CjsQEQc2.js"></script>
   <link rel="modulepreload" crossorigin href="./assets/vendor-antd-DI7JL-mE.js">
   <link rel="modulepreload" crossorigin href="./assets/vendor-codemirror-B9c49dtM.js">
   <link rel="modulepreload" crossorigin href="./assets/vendor-mdxeditor-B6cpBtIE.js">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-viewer",
-  "version": "1.7.1",
+  "version": "1.7.2",
   "description": "Claude Code logging, visualization, and management toolkit — launch a web viewer alongside Claude Code with full request/response tracing, proxy, and mobile support",
   "license": "MIT",
   "main": "server.js",

package/server/lib/log-management.js

@@ -99,6 +99,7 @@ export function listV2Logs(logDir, currentProjectName) {
       for (const s of listV2Sessions(join(logDir, project))) {
         if (s.leader) continue;
         if (s.size === 0) continue;
+        if (s.discard) continue; // quota-probe orphans: never listed (2026-07-16)
         if (!grouped[project]) grouped[project] = [];
         grouped[project].push({
           file: `v2:${project}/${s.sid}`,

package/server/lib/stats-worker.js

@@ -9,6 +9,8 @@ import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from '
 import { join, basename } from 'node:path';
 import { readJsonlTolerant, listSessionIds } from './v2/replay.js';
 import { dirSizeSync } from './v2/layout.js';
+import { isDiscardableSession } from './v2/session-select.js';
+import { reportSwallowed } from './error-report.js';
 import {
   INTER_SESSION_TYPES, isSystemText, extractUserTexts, isSuggestionMode,
   collectPromptsFromEvents, sortEpochFiles,
@@ -23,7 +25,11 @@ export { INTER_SESSION_TYPES, isSystemText, extractUserTexts };
 // v9: v2 session-dir units (files map keyed `sessions/<sid>`), journal-based counts
 // v10: per-session `size` = recursive session-dir bytes (was journal-only);
 //      `journalSize` carries the incremental-cache key
-const STATS_VERSION = 10;
+// v11: discardable sessions (quota-probe orphans) excluded — the bump
+//      invalidates pre-discard caches so their probe units can't be reused
+//      back into filesStats, which lets the discard check sit AFTER the
+//      cache-reuse branch (cache hits skip the journal head scan entirely)
+const STATS_VERSION = 11;
 
 /**
  * Parse one v2 session directory into the same stats shape parseJsonlFile
@@ -199,7 +205,20 @@ function generateProjectStats(projectDir, projectName, onlyFile) {
     }
 
     const sessionDir = join(projectDir, 'sessions', sid);
-    const parsed = parseSessionDir(sessionDir);
+    // Discardable sessions (quota-probe orphans — no main/teammate req, no
+    // leader) never count toward stats. Runs only on cache misses: v11+
+    // caches are written exclusively by post-discard code, so a cache hit can
+    // never resurrect a probe unit (the v10→v11 bump invalidated older ones).
+    if (isDiscardableSession(sessionDir)) continue;
+    let parsed;
+    try {
+      parsed = parseSessionDir(sessionDir);
+    } catch (err) {
+      // One unreadable session must not kill the whole worker (issue #129) —
+      // skip its stats and keep counting the healthy ones.
+      reportSwallowed('stats-worker.session-parse-failed', new Error(`${sid}: ${err.message}`));
+      continue;
+    }
     filesStats[unitKey] = {
       models: parsed.models,
       summary: parsed.summary,

package/server/lib/v2/adapter.js

@@ -33,6 +33,8 @@ import { reportSwallowed } from '../error-report.js';
 import { isMainAgentRequest } from '../interceptor-core.js';
 import { readPromptsHead, collectPromptsFromEvents } from '../user-prompt-extract.js';
 import { readSession, readJsonlTolerant, listSessionIds } from './replay.js';
+import { iterateJsonlLines } from './jsonl-read.js';
+import { isDiscardableSession } from './session-select.js';
 import { blobPath, isSupportedWireFormat, dirSizeSync } from './layout.js';
 import { SingleFlight } from './singleflight.js';
 
@@ -59,16 +61,17 @@ export function isV2SessionDir(p) {
 function readResponsesRaw(sessionDir) {
   const bySeq = new Map();
   const p = join(sessionDir, 'responses.jsonl');
-  if (!existsSync(p)) return bySeq;
-  let raw = '';
-  try { raw = readFileSync(p, 'utf-8'); } catch { return bySeq; }
-  for (const line of raw.split('\n')) {
-    const t = line.trim();
-    if (!t) continue;
-    const m = t.match(/"seq":\s*(\d+)/);
-    if (!m) continue;
-    const seq = Number(m[1]);
-    if (!bySeq.has(seq)) bySeq.set(seq, t);
+  try {
+    // streamed line-by-line (issue #129): responses.jsonl is the most likely
+    // file to outgrow Node's string cap (full response bodies, one per request)
+    for (const t of iterateJsonlLines(p)) {
+      const m = t.match(/"seq":\s*(\d+)/);
+      if (!m) continue;
+      const seq = Number(m[1]);
+      if (!bySeq.has(seq)) bySeq.set(seq, t);
+    }
+  } catch (err) {
+    reportSwallowed('v2-read.responses-read-failed', err);
   }
   return bySeq;
 }
@@ -491,6 +494,14 @@ export class SessionSynthesizer {
       phase: 'placeholder',
       entry,
       isMain: isMainKind,
+      // Journal-truth request identity for the live row builder (live-feed
+      // _rowFrom): conv/evt are the V3.S5 assembler inputs the cold fold
+      // (meta-rows foldDir) already carries — without them on live rows the
+      // client rebuilds entries with EMPTY messages and the chat vanished at
+      // stream end until a cold reload (2026-07-16 live-render regression).
+      kind: req.kind,
+      ...(req.conv && { conv: req.conv }),
+      ...(req.evt && { evt: req.evt }),
       stateRef: conv ? conv.state : null,
     };
     this._await.set(seq, item);
@@ -563,7 +574,15 @@ export class SessionSynthesizer {
 function* iterateSessionItems(sessionDir, opts = {}) {
   const projectDir = dirname(dirname(sessionDir));
   const sessionId = basename(sessionDir);
-  const session = readSession(projectDir, sessionId);
+  let session;
+  try {
+    session = readSession(projectDir, sessionId);
+  } catch (err) {
+    // One unreadable session must degrade to "not rendered", never crash the
+    // whole scan (issue #129: an oversized file crash-looped every startup).
+    reportSwallowed('v2-read.session-read-failed', new Error(`${sessionId}: ${err.message}`));
+    return;
+  }
   if (session.unsupported) {
     reportSwallowed('v2-read.unsupported-wire-format', new Error(`${sessionId}: wireFormat=${session.wireFormat}`));
     return;
@@ -628,6 +647,12 @@ export function findTeammateSessionDirs(sessionDir, leaderUuid) {
         continue;
       }
       if (!l) {
+        // Discardable dirs (quota-probe orphans — no main/teammate req) must
+        // never act as leader candidates: a probe fires at process startup,
+        // so its startTs sits right next to the real leader's and can win the
+        // orphan tie-break below, stealing the teammate's traffic from the
+        // real leader's folded stream.
+        if (isDiscardableSession(dir, meta)) continue;
         leaderStarts.push({ sid: name, startTs: (meta && meta.startTs) || '' });
         continue;
       }
@@ -1081,8 +1106,12 @@ export function listV2Sessions(projectDir) {
       const reqKind = new Map();
       let turns = 0;
       let sentinelVersion = null;
+      let hasMainOrTeammate = false;
       for (const line of readJsonlTolerant(join(dir, 'journal.jsonl'))) {
-        if (line.ph === 'req') reqKind.set(line.seq, line.kind);
+        if (line.ph === 'req') {
+          reqKind.set(line.seq, line.kind);
+          if (line.kind === 'main' || line.kind === 'teammate') hasMainOrTeammate = true;
+        }
         else if (line.ph === 'done' && reqKind.get(line.seq) === 'main') {
           turns++;
           reqKind.delete(line.seq); // fold duplicate done lines (§14)
@@ -1117,6 +1146,17 @@ export function listV2Sessions(projectDir) {
         turns,
         size: dirSizeSync(dir),
         preview,
+        // Discardable-session verdict. KEEP IN SYNC: session-select.js
+        // isDiscardableSession is the canonical rule; this fold pre-computes
+        // it for free over the FULL journal (the canonical scan is 8MB-
+        // budgeted — intentional asymmetry, a first main sits at the head).
+        // When the fold says discard, the canonical predicate CONFIRMS it:
+        // readJsonlTolerant swallows an I/O error (Windows EBUSY/EPERM lock)
+        // into zero lines, which must KEEP the session, not hide it — the
+        // canonical path carries that error→keep direction (ioErrorResult).
+        // Main-bearing sessions never pay the extra read; probe journals are
+        // ~3 lines.
+        discard: !(meta && meta.leader) && !hasMainOrTeammate && isDiscardableSession(dir, meta),
       });
     } catch { /* one unreadable session must not break the list */ }
   }

package/server/lib/v2/journal.js

@@ -8,7 +8,7 @@
 // The reader folds the two phases by seq; a req without a done is in-flight
 // (or the process died) — that IS the v1 placeholder, minus the duplicated body.
 
-import { existsSync, readFileSync } from 'node:fs';
+import { iterateJsonlLines } from './jsonl-read.js';
 
 export class Journal {
   /**
@@ -29,11 +29,15 @@ export class Journal {
 
   static _maxSeqIn(journalPath) {
     try {
-      if (!existsSync(journalPath)) return 0;
       let max = 0;
-      // Regex scan instead of per-line JSON.parse: tolerant of a truncated
-      // tail line and ~10x cheaper on large journals.
-      for (const m of readFileSync(journalPath, 'utf-8').matchAll(/"seq":\s*(\d+)/g)) {
+      // Per-line regex instead of JSON.parse: tolerant of a truncated tail
+      // line and ~10x cheaper on large journals. Streamed line-by-line
+      // (issue #129): a whole-file read past Node's string cap would land in
+      // the catch below and silently RESET seq to 0 — colliding with every
+      // existing line, which the reader folds into corrupted sessions.
+      for (const line of iterateJsonlLines(journalPath)) {
+        const m = /"seq":\s*(\d+)/.exec(line);
+        if (!m) continue;
         const n = Number(m[1]);
         if (n > max) max = n;
       }

package/server/lib/v2/jsonl-read.js

@@ -0,0 +1,127 @@
+// Wire Format v2 — streaming JSONL line reader (issue #129).
+//
+// `readFileSync(path, 'utf-8')` materializes the WHOLE file as one JS string
+// and throws ERR_STRING_TOO_LONG past Node's ~512MiB string cap — a single
+// oversized session file (giant conv epoch / journal / responses.jsonl, seen
+// in the wild after migrating very large v1 logs) crash-looped the server on
+// every startup scan. This reader never builds a whole-file string: it reads
+// fixed-size chunks and splits lines at the BYTE level (scanning for 0x0A
+// before decoding), so multi-byte UTF-8 characters straddling a chunk
+// boundary are never torn, and only one line at a time ever becomes a string.
+//
+// A single line at/above the string cap can never be decoded at all — it is
+// skipped (reported once per file via reportSwallowed) instead of throwing,
+// mirroring readJsonlTolerant's torn-tail tolerance (spec §14).
+
+import { existsSync, openSync, readSync, closeSync, statSync } from 'node:fs';
+import { reportSwallowed } from '../error-report.js';
+
+const DEFAULT_CHUNK_BYTES = 8 * 1024 * 1024;
+// Node's max string length is 0x1fffffe8 (~512MiB) — a line this long can
+// never become a JS string, so it is unreadable by construction.
+const DEFAULT_MAX_LINE_BYTES = 0x1fffffe8;
+
+/**
+ * Iterate a JSONL file's lines as trimmed strings (blank lines skipped),
+ * without ever holding the whole file in one string.
+ *
+ * @param {string} path
+ * @param {{maxLineBytes?: number, chunkBytes?: number}} [opts] - test seams;
+ *   production callers use the defaults.
+ * @yields {string} one trimmed non-empty line
+ */
+export function* iterateJsonlLines(path, opts = {}) {
+  const maxLineBytes = opts.maxLineBytes || DEFAULT_MAX_LINE_BYTES;
+  const chunkBytes = opts.chunkBytes || DEFAULT_CHUNK_BYTES;
+  if (!existsSync(path)) return;
+  let fd;
+  try {
+    fd = openSync(path, 'r');
+  } catch (err) {
+    // ENOENT = vanished mid-scan (benign TOCTOU); anything else (EBUSY/EPERM
+    // Windows locks, EMFILE) silently rendering a session empty is
+    // diagnostic-worthy — CLAUDE.md swallow rule.
+    if (err && err.code !== 'ENOENT') reportSwallowed('v2-read.open-failed', err);
+    return;
+  }
+  try {
+    // Cap the chunk to the file's actual size (like the sibling readers):
+    // a fixed 8MB zero-filled alloc per call is a ~2600x regression over the
+    // old readFileSync for the KB-scale journals startup scans walk.
+    let capBytes = chunkBytes;
+    try { capBytes = Math.min(chunkBytes, Math.max(statSync(path).size, 1)); }
+    catch { /* stat raced a delete — keep the full chunk; the read loop decides */ }
+    const chunk = Buffer.alloc(capBytes);
+    let carry = [];       // Buffer fragments of the current (incomplete) line
+    let carryBytes = 0;
+    let skipping = false; // inside an oversized line — drop bytes until \n
+    let reported = false; // one report per file, not per oversized line
+    let pos = 0;
+    const reportOnce = (err) => {
+      if (reported) return;
+      reported = true;
+      reportSwallowed('v2-read.jsonl-line-too-long', err);
+    };
+    while (true) {
+      const n = readSync(fd, chunk, 0, chunk.length, pos);
+      if (n === 0) break;
+      pos += n;
+      const view = chunk.subarray(0, n);
+      let from = 0;
+      while (from < n) {
+        const nl = view.indexOf(10, from);
+        if (nl === -1) {
+          // no newline in the rest of this chunk — carry (or keep skipping)
+          if (!skipping) {
+            const restLen = n - from;
+            if (carryBytes + restLen > maxLineBytes) {
+              skipping = true;
+              carry = [];
+              carryBytes = 0;
+              reportOnce(new Error(`${path}: line exceeds ${maxLineBytes} bytes — skipped`));
+            } else {
+              // chunk is reused by the next readSync — the carried slice must own its bytes
+              carry.push(Buffer.from(view.subarray(from)));
+              carryBytes += restLen;
+            }
+          }
+          break;
+        }
+        if (skipping) {
+          skipping = false; // the oversized line ends at this newline
+        } else {
+          const seg = view.subarray(from, nl);
+          let text = null;
+          try {
+            if (carry.length > 0) {
+              carry.push(seg);
+              text = Buffer.concat(carry).toString('utf-8');
+            } else {
+              text = seg.toString('utf-8');
+            }
+          } catch (err) {
+            reportOnce(err); // decode failed (line at the string cap) — skip it
+          }
+          carry = [];
+          carryBytes = 0;
+          if (text !== null) {
+            const t = text.trim();
+            if (t) yield t;
+          }
+        }
+        from = nl + 1;
+      }
+    }
+    // trailing line without a final newline (torn tail is the caller's concern)
+    if (!skipping && carry.length > 0) {
+      let text = null;
+      try { text = Buffer.concat(carry).toString('utf-8'); } catch (err) { reportOnce(err); }
+      if (text !== null) {
+        const t = text.trim();
+        if (t) yield t;
+      }
+    }
+  } finally {
+    closeSync(fd);
+  }
+}

package/server/lib/v2/live-feed.js

@@ -28,6 +28,7 @@ import { reportSwallowed } from '../error-report.js';
 import { createIncrementalReconstructor } from '../delta-reconstructor.js';
 import { processWatchedEntry, sendEventToClients, sendEventRawToClients } from '../log-watcher.js';
 import { SessionSynthesizer } from './adapter.js';
+import { isDiscardableSession } from './session-select.js';
 import { computeCacheLoss } from './meta-rows.js';
 import { classifyRequest } from '../../../src/utils/requestType.js';
 
@@ -38,11 +39,26 @@ const ATTACH_RECENT_MS = 5 * 60 * 1000; // pre-existing dirs considered "live"
 const TICK_RETRY_MS = 250;      // in-process tick raced the first queue drain
 const TICK_RETRY_MAX = 8;
 
-/** Read newly appended complete lines from a file cursor {path, offset,
- *  pending}. Returns an array of raw line strings (possibly empty). A file
+const READ_CHUNK_BYTES = 8 * 1024 * 1024;
+// Node's max string length (~512MiB) — a longer line can never be decoded.
+const MAX_LINE_BYTES = 0x1fffffe8;
+
+/** Read newly appended complete lines from a file cursor {path, offset}
+ *  (partial-line carry lives on lazily-initialized _pendBufs/_pendBytes/
+ *  _skipLine cursor fields). Returns an array of raw line strings (possibly
+ *  empty). A file
  *  that shrank (should never happen — v2 files are append-only) returns null
- *  so the caller can rebuild the cursor. */
-function readNewLines(cursor) {
+ *  so the caller can rebuild the cursor.
+ *
+ *  Chunked + byte-level newline split (issue #129 twin): the first attach to
+ *  a session seeds from offset 0, so one whole-file read + decode would throw
+ *  ERR_STRING_TOO_LONG on an oversized journal and crash-loop the boot path
+ *  exactly like the cold-scan crash the streaming reader fixed. The partial
+ *  tail line is carried on the cursor as Buffer fragments (never decoded
+ *  until its newline lands); a single line past the string cap is skipped
+ *  with a report instead of thrown. Exported for tests (chunkBytes seam).
+ */
+export function readNewLines(cursor, chunkBytes = READ_CHUNK_BYTES, maxLineBytes = MAX_LINE_BYTES) {
   let size;
   try {
     size = statSync(cursor.path).size;
@@ -51,23 +67,74 @@ function readNewLines(cursor) {
   }
   if (size < cursor.offset) return null;
   if (size === cursor.offset) return [];
-  const toRead = size - cursor.offset;
-  const buf = Buffer.alloc(toRead);
+  if (cursor._pendBufs === undefined) {
+    cursor._pendBufs = [];
+    cursor._pendBytes = 0;
+    cursor._skipLine = false;
+  }
+  const out = [];
   let fd;
   try {
     fd = openSync(cursor.path, 'r');
-    readSync(fd, buf, 0, toRead, cursor.offset);
+    const chunk = Buffer.alloc(Math.min(chunkBytes, size - cursor.offset));
+    while (cursor.offset < size) {
+      const toRead = Math.min(chunk.length, size - cursor.offset);
+      const n = readSync(fd, chunk, 0, toRead, cursor.offset);
+      if (n === 0) break;
+      cursor.offset += n;
+      const view = chunk.subarray(0, n);
+      let from = 0;
+      while (from < n) {
+        const nl = view.indexOf(10, from);
+        if (nl === -1) {
+          if (!cursor._skipLine) {
+            const restLen = n - from;
+            if (cursor._pendBytes + restLen > maxLineBytes) {
+              cursor._skipLine = true;
+              cursor._pendBufs = [];
+              cursor._pendBytes = 0;
+              reportSwallowed('v2-live.read-line-too-long', new Error(`${cursor.path}: line exceeds ${maxLineBytes} bytes — skipped`));
+            } else {
+              // chunk is reused next readSync — the carried slice must own its bytes
+              cursor._pendBufs.push(Buffer.from(view.subarray(from)));
+              cursor._pendBytes += restLen;
+            }
+          }
+          break;
+        }
+        if (cursor._skipLine) {
+          cursor._skipLine = false; // the oversized line ends at this newline
+        } else {
+          const seg = view.subarray(from, nl);
+          let text = null;
+          try {
+            if (cursor._pendBufs.length > 0) {
+              cursor._pendBufs.push(seg);
+              text = Buffer.concat(cursor._pendBufs).toString('utf-8');
+            } else {
+              text = seg.toString('utf-8');
+            }
+          } catch (err) {
+            reportSwallowed('v2-live.read-line-too-long', err);
+          }
+          cursor._pendBufs = [];
+          cursor._pendBytes = 0;
+          if (text !== null) {
+            const t = text.trim();
+            if (t) out.push(t);
+          }
+        }
+        from = nl + 1;
+      }
+    }
   } catch (err) {
+    // Deliver what was already parsed; offset only advanced past read bytes,
+    // so the next poll resumes from the failure point.
     reportSwallowed('v2-live.read', err);
-    return [];
   } finally {
     if (fd !== undefined) { try { closeSync(fd); } catch { /* already closed */ } }
   }
-  cursor.offset = size;
-  const chunk = cursor.pending + buf.toString('utf-8');
-  const parts = chunk.split('\n');
-  cursor.pending = parts.pop() || '';
-  return parts.map((l) => l.trim()).filter(Boolean);
+  return out;
 }
 
 export class V2LiveFeed {
@@ -99,6 +166,7 @@ export class V2LiveFeed {
     this._wireV3 = !!opts.wireV3;
     this._sessions = new Map(); // dir → cursor bundle
     this._seenDirs = new Map(); // dir → last observed journal mtimeMs (attached or not)
+    this._discardGated = new Set(); // dirs refused by the discard gate — first real attach must NOT suppress history
     this._sessionsRoot = null;
     this._rootWatcher = null;
     this._safetyTimer = null;
@@ -126,6 +194,7 @@ export class V2LiveFeed {
     for (const cur of this._sessions.values()) this._closeCursor(cur);
     this._sessions.clear();
     this._seenDirs.clear();
+    this._discardGated.clear();
     this._sessionsRoot = null;
   }
 
@@ -246,6 +315,23 @@ export class V2LiveFeed {
   _attach(dir, { suppressExisting }) {
     if (this._sessions.has(dir)) return this._sessions.get(dir);
     if (!existsSync(join(dir, 'journal.jsonl'))) return null;
+    // Discardable sessions (quota-probe orphans — no main/teammate req, no
+    // meta.leader) are never followed: single choke point, every attach path
+    // (_initialScan / _maybeAttachNew / tick / _safetyTick / _rebuildCursor)
+    // funnels here and handles null. Self-healing when a dir later gains its
+    // first main: the leader's own dir re-attaches via tick's retry chain
+    // (sub-second); cross-process dirs via the 5s safety poll's mtime-bump
+    // scan (_seenDirs bookkeeping stays in the callers, so the bump fires).
+    if (isDiscardableSession(dir)) {
+      this._discardGated.add(dir);
+      return null;
+    }
+    // A dir previously refused by the discard gate is attaching for the FIRST
+    // time — its first renderable turn was never broadcast, so the safety
+    // poll's suppressExisting:true (meant for "old stale dir resumed") must
+    // not swallow it: cross-process producers (IM worker, second ccv) have no
+    // cold-load fallback for a connected client.
+    if (this._discardGated.delete(dir)) suppressExisting = false;
     const cur = {
       dir,
       synth: new SessionSynthesizer(dir, { deferMs: this._deferMs, now: this._now }),
@@ -254,9 +340,9 @@ export class V2LiveFeed {
       // rebase each other's accumulated baseline — v1's tail followed exactly
       // one file, so a single shared reconstructor was a new interleave surface.
       reconstructor: createIncrementalReconstructor(),
-      journal: { path: join(dir, 'journal.jsonl'), offset: 0, pending: '' },
-      responses: { path: join(dir, 'responses.jsonl'), offset: 0, pending: '' },
-      convFiles: new Map(), // path → {key, offset, pending}
+      journal: { path: join(dir, 'journal.jsonl'), offset: 0 },
+      responses: { path: join(dir, 'responses.jsonl'), offset: 0 },
+      convFiles: new Map(), // path → {key, offset} (+ lazy _pendBufs carry)
       watcher: null,
       debounce: null,
       reading: false,
@@ -353,7 +439,7 @@ export class V2LiveFeed {
         const p = join(convRoot, key, f);
         let fc = cur.convFiles.get(p);
         if (!fc) {
-          fc = { key, path: p, offset: 0, pending: '' };
+          fc = { key, path: p, offset: 0 };
           cur.convFiles.set(p, fc);
         }
         const lines = readNewLines(fc);
@@ -471,8 +557,17 @@ export class V2LiveFeed {
       timestamp: parsed.timestamp || '',
       url: parsed.url || '',
       method: parsed.method || 'POST',
-      kind: item.isMain ? 'main' : (parsed.teammate ? 'teammate' : 'sub'),
-      mainAgent: parsed.mainAgent === true,
+      // conv/evt/kind/mainAgent mirror the cold fold (meta-rows.js foldDir) —
+      // journal truth, NOT re-derivation. conv is load-bearing: the client
+      // assembler's buildEntry is `if (row.conv)`-gated, so a conv-less live
+      // row rebuilt every entry with EMPTY messages (chat vanished at stream
+      // end). mainAgent must be kind-derived like cold: parsed.mainAgent
+      // re-derives from the body and mis-tags countTokens (main system/tools
+      // aboard) as true, which would merge its turn into the chat live-only.
+      conv: item.conv,
+      evt: item.evt,
+      kind: item.kind || (item.isMain ? 'main' : (parsed.teammate ? 'teammate' : 'sub')),
+      mainAgent: item.isMain === true,
       teammate: parsed.teammate || undefined,
       model: parsed.body?.model,
       proxyUrl: parsed.proxyUrl || undefined,

package/server/lib/v2/meta-rows.js

@@ -18,6 +18,7 @@
 import { readFileSync, readdirSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { readJsonlTolerant } from './replay.js';
+import { iterateJsonlLines } from './jsonl-read.js';
 import { iterateV2Items, findTeammateSessionDirs } from './adapter.js';
 import { SingleFlight } from './singleflight.js';
 import { reportSwallowed } from '../error-report.js';
@@ -246,13 +247,11 @@ export async function readV2NativeCold(sessionDir, rows) {
       try { files = readdirSync(join(convRoot, key)).filter((f) => /^e\d+\.jsonl$/.test(f)).sort((a, b) => Number(a.match(/\d+/)[0]) - Number(b.match(/\d+/)[0])); } catch { continue; }
       const raws = [];
       for (const f of files) {
-        let text = '';
-        try { text = readFileSync(join(convRoot, key, f), 'utf-8'); } catch { continue; }
-        for (const line of text.split('\n')) {
-          const trimmed = line.trim();
-          if (trimmed) raws.push(trimmed);
-        }
-        await yieldLoop(); // one yield per conv file read
+        // streamed line-by-line (issue #129): a conv epoch past Node's string
+        // cap must degrade to skipped lines, not lose the whole file silently
+        try { for (const trimmed of iterateJsonlLines(join(convRoot, key, f))) raws.push(trimmed); }
+        catch (err) { reportSwallowed('v2-native.conv-read-failed', err); }
+        await yieldLoop(); // one yield per conv file read (error path included)
       }
       // last snapshot at-or-before the window start for this session
       let start = 0;
@@ -271,17 +270,15 @@ export async function readV2NativeCold(sessionDir, rows) {
       // boundaries: the browser paints and the byte meter ticks between them.
       pushChunked(convPayloads, windowRaws, (linesJson) => `{"sessionId":${JSON.stringify(sessionId)},"channel":${JSON.stringify(key)},"lines":[${linesJson}]}`);
     }
-    // responses: exactly the window member seqs
-    let respText = '';
-    try { respText = readFileSync(join(dir, 'responses.jsonl'), 'utf-8'); } catch { /* none yet */ }
-    await yieldLoop();
+    // responses: exactly the window member seqs — streamed (issue #129)
     const respRaws = [];
-    for (const line of respText.split('\n')) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      const m = /"seq":\s*(\d+)/.exec(trimmed);
-      if (m && memberSeqs && memberSeqs.has(Number(m[1]))) respRaws.push(trimmed);
-    }
+    try {
+      for (const trimmed of iterateJsonlLines(join(dir, 'responses.jsonl'))) {
+        const m = /"seq":\s*(\d+)/.exec(trimmed);
+        if (m && memberSeqs && memberSeqs.has(Number(m[1]))) respRaws.push(trimmed);
+      }
+    } catch (err) { reportSwallowed('v2-native.responses-read-failed', err); }
+    await yieldLoop();
     pushChunked(respPayloads, respRaws, (linesJson) => `{"sessionId":${JSON.stringify(sessionId)},"lines":[${linesJson}]}`);
   }
   return { convPayloads, respPayloads };
@@ -315,7 +312,7 @@ function pushChunked(out, raws, wrap) {
 async function attachBodyFields(sessionDir, rows) {
   const rowByKey = new Map(rows.map((r) => [itemKey(r.sessionId, r.seq), r]));
   const materialize = (sessionId, seq) => rowByKey.has(itemKey(sessionId, seq));
-  let pending = null;      // { row, entry } awaiting its nextReq for classify
+  let pending = null;      // { row, entry, isMain } awaiting its nextReq for classify
   let prevMainFull = null; // previous mainAgent full-body entry (cacheLoss)
   let n = 0;
   const finish = (slot, nextEntry) => {
@@ -329,8 +326,12 @@ async function attachBodyFields(sessionDir, rows) {
       reportSwallowed('v2-meta.row-classify', err);
       row.typeTag = null; // journal-derived kind still renders
     }
-    // authoritative synthesis-level markers (parity with the legacy list)
-    row.mainAgent = entry.mainAgent === true;
+    // Authoritative synthesis-level markers. mainAgent stays KIND-derived
+    // (item.isMain = journal kind==='main' && !leader) like foldDir and the
+    // live rows — entry.mainAgent re-derives from the blob-backfilled body
+    // and mis-tags a main-shaped countTokens probe as true, which would merge
+    // its turn into the chat after a cold reload (2026-07-16 review P1).
+    row.mainAgent = slot.isMain === true;
     if (entry.teammate) row.teammate = entry.teammate;
     if (entry.body && entry.body.model) row.model = entry.body.model;
     if (row.mainAgent) {
@@ -353,7 +354,7 @@ async function attachBodyFields(sessionDir, rows) {
       entry = { ...entry, body: { ...entry.body, messages: item.stateRef } };
     }
     if (pending) finish(pending, entry);
-    pending = { row, entry };
+    pending = { row, entry, isMain: item.isMain };
     if (++n % 20 === 0) await new Promise((resolve) => setImmediate(resolve));
   }
   if (pending) finish(pending, null);

package/server/lib/v2/replay.js

@@ -14,14 +14,14 @@ import { join } from 'node:path';
 import { createHash } from 'node:crypto';
 import { messageFingerprint, normalizeMsgForEquality } from '../session-boundary.js';
 import { isSupportedWireFormat } from './layout.js';
+import { iterateJsonlLines } from './jsonl-read.js';
 
-/** Parse a JSONL file tolerating a truncated tail line (spec §14). */
+/** Parse a JSONL file tolerating a truncated tail line (spec §14). Streams
+ *  line-by-line (issue #129): a file past Node's ~512MiB string cap must not
+ *  throw ERR_STRING_TOO_LONG out of the whole read path. */
 export function readJsonlTolerant(path) {
-  if (!existsSync(path)) return [];
   const out = [];
-  for (const line of readFileSync(path, 'utf-8').split('\n')) {
-    const t = line.trim();
-    if (!t) continue;
+  for (const t of iterateJsonlLines(path)) {
     try { out.push(JSON.parse(t)); } catch { /* truncated tail — drop */ }
   }
   return out;