cc-viewer 1.7.0 → 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-Ac8vnV3v.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.0",
+  "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",
@@ -66,6 +66,7 @@
     "findcc.js",
     "interceptor.js",
     "server/",
+    "src/utils/",
     "plugins/",
     "concepts/",
     "ultraAgents/"

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/log-watcher.js

@@ -4,6 +4,7 @@ import { buildContextWindowEvent, getContextSizeForModel } from './context-watch
 import { reconstructEntries } from './delta-reconstructor.js';
 import { enrichEntry } from './enrich-plan-input.js';
 import { enrichEntry as enrichWorkflowEntry } from './enrich-workflow.js';
+import { sseWrite } from './wire-compress.js';
 
 // 1.7.0: the v1 log-file tail (fs.watch + byte cursors + rotation follow)
 // retired with the v1 write path — the live channel is server/lib/v2/
@@ -60,7 +61,11 @@ function _safeSseWrite(clients, client, payload) {
   }
   let ok;
   try {
-    ok = client.write(payload);
+    // sseWrite routes through the client's negotiated Content-Encoding
+    // (wire-compress.js) — a bare client.write here would corrupt compressed
+    // streams. The drain listener below stays on the res: the encoder is
+    // piped into it, so socket drain still propagates.
+    ok = sseWrite(client, payload);
   } catch {
     _removeClient(clients, client);
     return false;
@@ -68,9 +73,18 @@ function _safeSseWrite(clients, client, payload) {
   if (!ok) {
     if (!client._sseBackpressureSince) {
       client._sseBackpressureSince = Date.now();
-      client.once('drain', () => { client._sseBackpressureSince = 0; });
+      // On compressed clients the false write() came from the ENCODER (its
+      // input buffer), whose own 'drain' fires when compression catches up —
+      // the res may never emit 'drain' at all (compressed output is 20-80x
+      // smaller than what the socket can absorb). Arming the reset on the
+      // wrong stream would let the timeout below kill healthy clients.
+      const pressured = client._wireEnc || client;
+      pressured.once('drain', () => { client._sseBackpressureSince = 0; });
     } else if (Date.now() - client._sseBackpressureSince > SSE_BACKPRESSURE_TIMEOUT_MS) {
       _removeClient(clients, client);
+      // Destroy the encoder first: end() alone leaves the 16MB brotli window
+      // alive until TCP teardown of the already-stuck socket.
+      try { if (client._wireEnc) client._wireEnc.destroy(); } catch {}
       try { client.end(); } catch {}
       return false;
     }
@@ -92,6 +106,15 @@ export function sendEventToClients(clients, eventName, data) {
   }
 }
 
+/** Like sendEventToClients but `json` is an ALREADY-serialized JSON string —
+ *  wire v3 forwards raw stored lines verbatim without a parse/stringify trip. */
+export function sendEventRawToClients(clients, eventName, json) {
+  const payload = `event: ${eventName}\ndata: ${json}\n\n`;
+  for (let i = clients.length - 1; i >= 0; i--) {
+    _safeSseWrite(clients, clients[i], payload);
+  }
+}
+
 export function sendChunkToClients(clients, dataJson) {
   const payload = `event: load_chunk\ndata: ${dataJson}\n\n`;
   for (let i = clients.length - 1; i >= 0; i--) {
@@ -115,7 +138,10 @@ export function processWatchedEntry(parsed, ctx) {
   reconstructor.reconstruct(parsed);
   try { enrichEntry(parsed); } catch {}
   try { enrichWorkflowEntry(parsed); } catch {}
-  sendToClients(clients, parsed);
+  // Wire v3 (V3.S5): the flagged v2 live feed suppresses the full-entry
+  // broadcast — clients rebuild entries from native lines + rows. The kv/
+  // context side events below still fire (they are slim and file-agnostic).
+  if (!ctx.suppressEntryBroadcast) sendToClients(clients, parsed);
   runParallelHook('onNewEntry', parsed).catch(() => {});
   if (isMainAgentEntry(parsed) && !parsed.inProgress) {
     const cached = extractCachedContent(parsed);

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;
 }
@@ -402,12 +405,30 @@ export class SessionSynthesizer {
     // ---- body (blob backfill is per-request by journal ref — never carried) --
     const tools = this._loadBlob(req.blobs && req.blobs.tools);
     const system = this._loadBlob(req.blobs && req.blobs.sys);
+    // req.params carries every residual body field (params-era journals);
+    // dedicated fields override it so precedence is deterministic. user_id is
+    // ALWAYS meta.userIdRaw — the client does equality-based session-boundary
+    // detection on it, and a `-c` adopted folder mixes real user_ids that
+    // would otherwise split the timeline mid-session.
+    const params = req.params && typeof req.params === 'object' ? req.params : null;
     const body = {
+      ...params,
       ...(req.model && { model: req.model }),
       ...(system !== undefined && { system }),
       ...(tools !== undefined && { tools }),
-      ...(meta.userIdRaw && { metadata: { user_id: meta.userIdRaw } }),
     };
+    if (meta.userIdRaw) {
+      const extra = body.metadata && typeof body.metadata === 'object' ? body.metadata : null;
+      body.metadata = { ...extra, user_id: meta.userIdRaw };
+    } else if (body.metadata && typeof body.metadata === 'object' && body.metadata.user_id !== undefined) {
+      // noid session (no parseable user_id at write time): a raw params
+      // user_id may vary per request, and surfacing it would re-open the
+      // spurious client boundary-split this block exists to prevent. Drop
+      // ONLY user_id; other metadata keys keep full fidelity.
+      const { user_id, ...restMeta } = body.metadata;
+      if (Object.keys(restMeta).length > 0) body.metadata = restMeta;
+      else delete body.metadata;
+    }
 
     const isTeammateEntry = isTeammate;
     const isMainKind = isMain;
@@ -473,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);
@@ -523,6 +552,7 @@ export class SessionSynthesizer {
     }
     entry.response = {
       ...(typeof done.http === 'number' && { status: done.http }),
+      ...(resp && resp.statusText && { statusText: resp.statusText }),
       ...(resp && resp.headers && { headers: resp.headers }),
       body: resp ? resp.body : null,
     };
@@ -544,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;
@@ -609,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;
       }
@@ -646,7 +690,7 @@ export function findTeammateSessionDirs(sessionDir, leaderUuid) {
  * Item-level iteration of one v2 session with teammate re-join — the shared
  * core of the raw-string generators and the window reader below.
  */
-function* iterateV2Items(sessionDir, opts = {}) {
+export function* iterateV2Items(sessionDir, opts = {}) {
   const streams = [iterateSessionItems(sessionDir, opts)];
   const ownMeta = (() => {
     try { return JSON.parse(readFileSync(join(sessionDir, 'meta.json'), 'utf-8')); } catch { return null; }
@@ -735,7 +779,7 @@ export function _v2WindowStatsForTest(reset = false) {
  * The result is IMMUTABLE and shared across coalesced callers — window
  * selection must not mutate `recs`/`ring`.
  */
-async function scanV2Descriptors(sessionDir) {
+export async function scanV2Descriptors(sessionDir) {
   _windowStats.scanRuns++;
   const dedup = new Map(); // key → descriptor (insertion order = output order)
   const ring = []; // newest ≤3 isMain descriptors, pre-dedup iteration order
@@ -796,7 +840,7 @@ function selectV2Window(scan, opts = {}) {
 
 /** Level-1 shared Pass A + per-caller selection. `cached` gates the TTL
  *  micro-cache read (F5b: /events live-attach must never consume it). */
-async function computeV2Window(sessionDir, opts = {}) {
+export async function computeV2Window(sessionDir, opts = {}) {
   const scan = await _scanFlight.run(`scan:${sessionDir}`, () => scanV2Descriptors(sessionDir), { cached: !!opts.cached });
   return selectV2Window(scan, opts);
 }
@@ -813,7 +857,7 @@ async function computeV2Window(sessionDir, opts = {}) {
  * equivalent (algorithm review F6). `collect` mode fills a slot array in
  * Pass A output order instead: byte-identical to the historical single pass.
  */
-async function materializeV2Window(sessionDir, win, { collect = false, onEntry = null } = {}) {
+async function materializeV2Window(sessionDir, win, { collect = false, onEntry = null, promoteKeys = null } = {}) {
   const memberIdx = new Map();
   win.members.forEach((d, i) => memberIdx.set(itemKey(d.sessionId, d.seq), i));
   const ringKeys = new Set(win.ring.map((d) => itemKey(d.sessionId, d.seq)));
@@ -837,7 +881,12 @@ async function materializeV2Window(sessionDir, win, { collect = false, onEntry =
       // replayed state (item.stateRef aliases the live conversation state at
       // this seq — used transiently, never retained). Same construction as the
       // historical end-of-window rebuild, byte-for-byte.
-      if (k === win.baselineKey) {
+      // `promoteKeys` (V3.S1): per-member force-checkpoint for single-entry
+      // reads — a mid-session main delta carries only its appended slice, but
+      // the detail view needs the full replayed state for BOTH the target and
+      // its prevMain (Body Diff / cacheLoss compare whole messages arrays).
+      // The window baseline promotes only win.baselineKey (the window start).
+      if (k === win.baselineKey || (promoteKeys && promoteKeys.has(k))) {
         const state = item.stateRef || [];
         const rebuilt = { ...item.entry, body: { ...item.entry.body, messages: state } };
         rebuilt._isCheckpoint = true;
@@ -889,6 +938,47 @@ async function materializeV2Window(sessionDir, win, { collect = false, onEntry =
  * @param {{limit?: number, before?: string|null, cached?: boolean}} [opts]
  * @returns {Promise<{entries: string[], hasMore: boolean, oldestTimestamp: string, totalCount: number, mainAgentRing: string[]}>}
  */
+/**
+ * V3.S1: on-demand single-entry read — the detail view's data source once the
+ * request list is metadata rows. Locates the target (sessionId, seq) in the
+ * shared descriptor scan, pairs it with its preceding isMain descriptor
+ * (Body Diff / Context tab need the previous mainAgent, raw-seq adjacency),
+ * and materializes exactly those members with per-member checkpoint promotion
+ * (main deltas come back with the full replayed state, matching what the
+ * client holds after reconstruction on the legacy channel).
+ *
+ * @param {string} sessionDir - leader session dir (teammate rows resolve
+ *   through the leader's k-way fold so tags/order match the list)
+ * @param {{seq: number, sessionId?: string|null, cached?: boolean}} opts -
+ *   sessionId (UUID) disambiguates teammate rows; null = any session's seq
+ * @returns {Promise<{entry: string, prevMain: string|null}|null>} raw JSON
+ *   strings (never re-parsed here), or null when the seq is unknown / gated
+ *   out by synthesis (crash-orphan) — callers answer 404.
+ */
+export async function readV2SingleEntry(sessionDir, opts = {}) {
+  const seq = opts.seq;
+  const sessionId = opts.sessionId || null;
+  const key = `entry:${sessionDir}|${sessionId || ''}|${seq}`;
+  return _windowFlight.run(key, async () => {
+    const scan = await _scanFlight.run(`scan:${sessionDir}`, () => scanV2Descriptors(sessionDir), { cached: true });
+    const recs = scan.recs;
+    const idx = recs.findIndex((d) => d.seq === seq && (!sessionId || d.sessionId === sessionId));
+    if (idx === -1) return null;
+    const target = recs[idx];
+    let prevMain = null;
+    for (let i = idx - 1; i >= 0; i--) {
+      if (recs[i].isMain) { prevMain = recs[i]; break; }
+    }
+    const members = prevMain ? [prevMain, target] : [target];
+    const win = { members, ring: [], baselineKey: null };
+    const promoteKeys = new Set(members.filter((d) => d.isMainDelta).map((d) => itemKey(d.sessionId, d.seq)));
+    const { slots } = await materializeV2Window(sessionDir, win, { collect: true, promoteKeys });
+    const entry = slots[members.length - 1];
+    if (entry === undefined) return null; // synthesis gate dropped it between passes
+    return { entry, prevMain: prevMain ? (slots[0] ?? null) : null };
+  }, { cached: opts.cached !== false });
+}
+
 export async function readV2WindowedEntries(sessionDir, opts = {}) {
   const cached = !!opts.cached;
   const key = `win:${sessionDir}|${opts.limit || 0}|${opts.before || ''}`;
@@ -1016,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)
@@ -1052,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);
+  }
+}