cc-viewer 1.6.348 → 1.7.1

package/server/lib/log-stream.js

@@ -13,7 +13,7 @@
 import { existsSync, statSync, openSync, readSync, closeSync } from 'node:fs';
 import { open as fsOpen, stat as fsStat } from 'node:fs/promises';
 import { isCheckpointEntry, isDeltaEntry, reconstructSegment } from './delta-reconstructor.js';
-import { resolveJsonlPath } from './jsonl-archive.js';
+import { isV2SessionDir, iterateV2RawEntries, iterateV2RawEntriesAsync, readV2WindowedEntries, streamV2WindowedEntries } from './v2/adapter.js';
 
 const READ_CHUNK_SIZE = 1024 * 1024; // 1MB
 const SEPARATOR = '\n---\n';
@@ -23,7 +23,12 @@ const SEPARATOR = '\n---\n';
  * 内存 = 1MB buffer + pending。
  */
 function* iterateRawEntries(filePath) {
-  filePath = resolveJsonlPath(filePath);
+  // wire-v2 S5: a session DIRECTORY resolves to the v2→v1 adapter stream — the
+  // synthesized entries feed every downstream consumer unchanged (spec §11).
+  if (isV2SessionDir(filePath)) {
+    yield* iterateV2RawEntries(filePath);
+    return;
+  }
   const fileSize = statSync(filePath).size;
   if (fileSize === 0) return;
 
@@ -64,8 +69,17 @@ function* iterateRawEntries(filePath) {
  * @param {string} filePath
  * @param {{ startOffset?: number }} [opts] - startOffset>0 时从该偏移量开始读取并跳过首条（可能被截断）
  */
-async function* iterateRawEntriesAsync(filePath, { startOffset = 0 } = {}) {
-  filePath = resolveJsonlPath(filePath);
+// Exported since wire-v2 S4: the verify tool needs a SINGLE streaming pass —
+// streamRawEntriesAsync's dedup map (~half the file resident) plus its second
+// send pass are pure waste for a scan-only consumer (review P2).
+export async function* iterateRawEntriesAsync(filePath, { startOffset = 0 } = {}) {
+  // wire-v2 S5: adapter branch. startOffset is a BYTE offset into a physical
+  // file — meaningless for a synthesized stream, so v2 always reads in full
+  // (readTailEntries routes v2 through its full-read path for the same reason).
+  if (isV2SessionDir(filePath)) {
+    yield* iterateV2RawEntriesAsync(filePath);
+    return;
+  }
   let fh;
   try {
     const st = await fsStat(filePath);
@@ -109,7 +123,6 @@ async function* iterateRawEntriesAsync(filePath, { startOffset = 0 } = {}) {
  * 用于 SSE load_start 的 total 字段（进度显示）。
  */
 export async function countLogEntries(filePath) {
-  filePath = resolveJsonlPath(filePath);
   if (!existsSync(filePath)) return 0;
   let count = 0;
   for await (const _ of iterateRawEntriesAsync(filePath)) { count++; }
@@ -149,11 +162,10 @@ function isSegmentBoundary(entry) {
 }
 
 // ============================================================================
-// 同步 API — 用于 mergeLogFiles（合并需要重建为全量格式写入磁盘）
+// 同步 API — 重建为全量格式的同步变体（当前无生产消费者，保留给测试与未来批处理；退役评估归 wire-v2 S6c）
 // ============================================================================
 
 export function streamReconstructedEntries(filePath, onSegment, opts = {}) {
-  filePath = resolveJsonlPath(filePath);
   if (!existsSync(filePath)) return 0;
   const stat = statSync(filePath);
   if (stat.size === 0) return 0;
@@ -208,7 +220,6 @@ export function streamReconstructedEntries(filePath, onSegment, opts = {}) {
 }
 
 export async function streamReconstructedEntriesAsync(filePath, onSegment, opts = {}) {
-  filePath = resolveJsonlPath(filePath);
   if (!existsSync(filePath)) return 0;
   try {
     const st = await fsStat(filePath);
@@ -289,16 +300,44 @@ export async function streamReconstructedEntriesAsync(filePath, onSegment, opts
  * @returns {Promise<{sentCount: number, totalCount: number}>}
  */
 export async function streamRawEntriesAsync(filePath, onRawEntry, opts = {}) {
-  filePath = resolveJsonlPath(filePath);
   const empty = { sentCount: 0, totalCount: 0 };
   if (!existsSync(filePath)) { if (opts.onReady) opts.onReady({ totalCount: 0 }); return empty; }
-  const stat = statSync(filePath);
-  if (stat.size === 0) { if (opts.onReady) opts.onReady({ totalCount: 0 }); return empty; }
+  // v2 session dirs skip the size probe: a directory's st.size is 0 on some
+  // filesystems (Windows) and never reflects the synthesized stream anyway.
+  if (!isV2SessionDir(filePath)) {
+    const stat = statSync(filePath);
+    if (stat.size === 0) { if (opts.onReady) opts.onReady({ totalCount: 0 }); return empty; }
+  }
 
   const sinceFilter = opts.since || null;
   const onScan = opts.onScan || null;
   const onReady = opts.onReady || null;
 
+  // v2 windowed path: the adapter guarantees a reconstructable baseline at the
+  // window start (synthesized checkpoint), which the byte-tail heuristics below
+  // cannot — expand-to-checkpoint over adapter output could walk arbitrarily
+  // far back on a session with sparse organic snapshots.
+  // S10a: streaming two-pass — `since` is pushed into window membership so the
+  // /events incremental reconnect path materializes only the entries it will
+  // send (the historical full materialization here was the primary OOM path).
+  // onScan is retired on this branch: the newest-mainAgent raws come back as
+  // `mainAgentRing` in the result instead (adapter P0-2).
+  if (isV2SessionDir(filePath)) {
+    // cached defaults FALSE here: streamRawEntriesAsync serves the /events
+    // cold-load / live-attach and the workspaces live-source reload — these
+    // suppress the ≤ttl cache READ (they must not start from a stale window).
+    // Level-1 scan coalescing still collapses concurrent reconnects; the join
+    // staleness is bounded by one in-flight scan (not the ttl) — see
+    // singleflight.js cached=false note.
+    const res = await streamV2WindowedEntries(
+      filePath,
+      { limit: opts.limit, since: sinceFilter, onReady, cached: opts.cached === true },
+      onRawEntry,
+    );
+    await new Promise(resolve => setImmediate(resolve));
+    return { sentCount: res.sentCount, totalCount: res.totalCount, mainAgentRing: res.mainAgentRing };
+  }
+
   // 第一遍：异步 generator 逐条读取 → dedup Map 存原始字符串（不 parse）
   // 内存 = 去重后的原始字符串总量 ≈ 文件大小的一半（inProgress 被 completed 覆盖）
   const dedup = new Map();
@@ -417,10 +456,17 @@ function _sliceToCheckpoint(entries, limit) {
  * @param {{ limit?: number }} opts
  * @returns {Promise<{ entries: string[], hasMore: boolean, oldestTimestamp: string, estimatedTotal: number }>}
  */
-export async function readTailEntries(filePath, { limit = 300 } = {}) {
-  filePath = resolveJsonlPath(filePath);
+export async function readTailEntries(filePath, { limit = 300, cached = true } = {}) {
   const emptyResult = { entries: [], hasMore: false, oldestTimestamp: '', estimatedTotal: 0 };
   if (!existsSync(filePath)) return emptyResult;
+  // v2 session dirs have no byte-offset tail window — the adapter windows by
+  // entry count and synthesizes a baseline checkpoint at the window start.
+  // cached defaults TRUE: the /api/local-log tail + IM popup are historical
+  // read-only reads (S10b) and may consume a ≤ttl-stale window.
+  if (isV2SessionDir(filePath)) {
+    const win = await readV2WindowedEntries(filePath, { limit, cached });
+    return { entries: win.entries, hasMore: win.hasMore, oldestTimestamp: win.oldestTimestamp, estimatedTotal: win.totalCount };
+  }
   const st = statSync(filePath);
   if (st.size === 0) return emptyResult;
 
@@ -473,98 +519,3 @@ async function _readTailFull(filePath, limit, fileSize) {
   const oldestTimestamp = extractTimestamp(sliced[0]) || '';
   return { entries: sliced, hasMore, oldestTimestamp, estimatedTotal: totalCount };
 }
-
-/**
- * 读取分页历史条目（用于 /api/entries/page REST 端点）。
- *
- * 复用 iterateRawEntries + extractDedupKey 去重，
- * 过滤 timestamp < before 的条目，从末尾取最后 limit 条，
- * 向前扩展到 checkpoint 边界。
- *
- * @param {string} filePath
- * @param {{ before: string, limit: number }} opts
- * @returns {{ entries: string[], hasMore: boolean, oldestTimestamp: string, count: number }}
- */
-export async function readPagedEntries(filePath, { before, limit }) {
-  filePath = resolveJsonlPath(filePath);
-  if (!existsSync(filePath)) return { entries: [], hasMore: false, oldestTimestamp: '', count: 0 };
-  const stat = statSync(filePath);
-  if (stat.size === 0) return { entries: [], hasMore: false, oldestTimestamp: '', count: 0 };
-
-  const dedup = await _collectDedup(iterateRawEntriesAsync(filePath));
-
-  // 过滤 timestamp < before
-  const filtered = [];
-  for (const [key, raw] of dedup) {
-    if (key.startsWith('__nokey_')) continue;
-    const ts = extractTimestamp(raw);
-    if (ts && ts < before) {
-      filtered.push(raw);
-    }
-  }
-
-  if (filtered.length === 0) {
-    return { entries: [], hasMore: false, oldestTimestamp: '', count: 0 };
-  }
-
-  const { sliced, hasMore } = _sliceToCheckpoint(filtered, limit);
-  const oldestTimestamp = extractTimestamp(sliced[0]) || '';
-  return { entries: sliced, hasMore, oldestTimestamp, count: sliced.length };
-}
-
-/**
- * Scan a whole segment and collect the parsed entries matching `predicate`,
- * for the post-rotation teammate backfill (/api/prev-segment-teammates).
- *
- * - `rawPrefilter(rawString)`: cheap substring gate evaluated BEFORE
- *   JSON.parse, so multi-MB MainAgent checkpoint frames are skipped without
- *   parsing.
- * - Last-write-wins dedup by timestamp|url (a request's inProgress and final
- *   writes share one key; the later frame replaces the earlier).
- * - `maxBytes` budget applied NEWEST-first over the raw sizes: when the
- *   matches exceed the budget, the oldest are dropped and `truncated` is set.
- *
- * Returns { entries, truncated } with entries in chronological (file) order.
- */
-export async function collectFilteredRawEntriesAsync(filePath, predicate, {
-  maxBytes = 64 * 1024 * 1024,
-  rawPrefilter = null,
-  yieldEvery = 50,
-} = {}) {
-  const matched = new Map(); // dedupKey -> { size, entry }, insertion order = file order
-  let nokey = 0;
-  let totalBytes = 0;
-  let truncated = false;
-  let parsedCount = 0;
-  for await (const raw of iterateRawEntriesAsync(filePath)) {
-    if (rawPrefilter && !rawPrefilter(raw)) continue;
-    // Real team logs defeat the prefilter for most BYTES (leader checkpoints
-    // embed the SendMessage tool text), so parses can total >1s on a 300MB
-    // segment — yield periodically to keep the live proxy's event loop
-    // responsive during the scan.
-    if (yieldEvery > 0 && ++parsedCount % yieldEvery === 0) {
-      await new Promise((resolve) => setImmediate(resolve));
-    }
-    let entry;
-    try { entry = JSON.parse(raw); } catch { continue; }
-    if (!entry || !predicate(entry)) continue;
-    const key = extractDedupKey(raw) || `__nokey_${nokey++}`;
-    const prev = matched.get(key);
-    if (prev) totalBytes -= prev.size;
-    matched.set(key, { size: raw.length, entry });
-    totalBytes += raw.length;
-    // Enforce the budget DURING the scan (newest wins): evicting the oldest
-    // keys keeps transient memory bounded even on teammate-heavy segments —
-    // not just the response size.
-    while (totalBytes > maxBytes && matched.size > 1) {
-      const oldestKey = matched.keys().next().value;
-      totalBytes -= matched.get(oldestKey).size;
-      matched.delete(oldestKey);
-      truncated = true;
-    }
-  }
-  return {
-    entries: [...matched.values()].map((it) => it.entry),
-    truncated,
-  };
-}

package/server/lib/log-watcher.js

@@ -1,35 +1,23 @@
-import { readFileSync, existsSync, watch, watchFile, unwatchFile, statSync } from 'node:fs';
-import { open as fsOpen, stat as fsStat } from 'node:fs/promises';
-import { dirname, basename } from 'node:path';
+import { readFileSync, existsSync } from 'node:fs';
 import { isMainAgentEntry, extractCachedContent } from './kv-cache-analyzer.js';
 import { buildContextWindowEvent, getContextSizeForModel } from './context-watcher.js';
-import { reconstructEntries, createIncrementalReconstructor } from './delta-reconstructor.js';
-import { countLogEntries, streamReconstructedEntriesAsync } from './log-stream.js';
+import { reconstructEntries } from './delta-reconstructor.js';
 import { enrichEntry } from './enrich-plan-input.js';
 import { enrichEntry as enrichWorkflowEntry } from './enrich-workflow.js';
-import { resolveJsonlPath } from './jsonl-archive.js';
-
-// 跟踪所有被 watch 的日志文件。value: fileState 对象（外部只用 .has()/.keys()）
-const watchedFiles = new Map();
-
-// 目录级 fs.watch 实例注册表（事件驱动，替代 per-file 轮询）
-const _dirWatchers = new Map();
-
-// Windows 单次 appendFileSync 触发 2+ 事件，防抖合并
-const FSWATCH_DEBOUNCE_MS = 80;
-
-// 安全网慢轮询：fs.watch 可能漏事件（buffer overflow 等），冷 fallback 兜底
-const SAFETY_POLL_MS = 5000;
-
-const FORCE_POLL = process.env.CCV_FORCE_POLL === '1';
-
+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/
+// live-feed.js. This module keeps what both eras share: the SSE client
+// plumbing (sendToClients & friends), the per-entry broadcast pipeline
+// (processWatchedEntry, used by the live feed), and readLogFile — the legacy
+// v1 reader (no production caller; kept for tests and ad-hoc legacy reads).
 /**
  * Read and parse a JSONL log file.
  * @param {string} logFile - absolute path to the log file
  * @returns {Array} parsed and deduplicated entries
  */
 export function readLogFile(logFile) {
-  logFile = resolveJsonlPath(logFile);
   if (!existsSync(logFile)) {
     return [];
   }
@@ -73,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;
@@ -81,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;
     }
@@ -105,264 +106,51 @@ export function sendEventToClients(clients, eventName, data) {
   }
 }
 
-export function sendChunkToClients(clients, dataJson) {
-  const payload = `event: load_chunk\ndata: ${dataJson}\n\n`;
+/** 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);
   }
 }
 
-// --- 轮转切换（抽取公共逻辑） ---
-
-async function _switchToRotatedFile(logFile, currentLogFile, clients, opts) {
-  // Deliberately KEEP the old file watched: external-process teammates resolve
-  // the leader log once at boot and continue appending to the previous segment
-  // after rotation. Unwatching it would make their post-rotation entries
-  // invisible live; client dedup absorbs any replayed frames. watchedFiles is
-  // a multi-file Map, so watching both segments is supported.
-  const total = await countLogEntries(currentLogFile);
-  sendEventToClients(clients, 'load_start', { total, incremental: false });
-  await streamReconstructedEntriesAsync(currentLogFile, (segment) => {
-    sendChunkToClients(clients, JSON.stringify(segment));
-  });
-  sendEventToClients(clients, 'load_end', {});
-  watchLogFile({ ...opts, logFile: currentLogFile });
-}
-
-// --- 增量读 + 解析 + 广播（独立于触发机制） ---
-
-async function _readDelta(state) {
-  if (state._reading) return; // 防止并发调用（debounce + safetyTimer 可能重叠）
-  state._reading = true;
-  const { logFile, opts, reconstructor } = state;
-  const { clients, getClaudePid, runParallelHook, notifyStatsWorker, getLogFile } = opts;
-  try {
-    const st = await fsStat(logFile);
-    const currentSize = st.size;
-
-    if (currentSize < state.lastByteOffset) {
-      state.lastByteOffset = 0;
-      state.pendingTail = '';
-      reconstructor.reset();
-
-      const currentLogFile = getLogFile();
-      if (currentLogFile !== logFile && !watchedFiles.has(currentLogFile)) {
-        await _switchToRotatedFile(logFile, currentLogFile, clients, opts);
-        return;
-      }
-    }
-
-    if (currentSize <= state.lastByteOffset) return;
-
-    const bytesToRead = currentSize - state.lastByteOffset;
-    const buf = Buffer.alloc(bytesToRead);
-    const fh = await fsOpen(logFile, 'r');
-    try {
-      await fh.read(buf, 0, bytesToRead, state.lastByteOffset);
-    } finally {
-      await fh.close();
-    }
-    state.lastByteOffset = currentSize;
-
-    const raw = state.pendingTail + buf.toString('utf-8');
-    const parts = raw.split('\n---\n');
-    state.pendingTail = parts.pop() || '';
-
-    if (parts.length === 0 && state.pendingTail.trim()) {
-      try {
-        JSON.parse(state.pendingTail);
-        parts.push(state.pendingTail);
-        state.pendingTail = '';
-      } catch {}
-    }
-
-    const validParts = parts.filter(p => p.trim());
-    if (validParts.length > 0) {
-      validParts.forEach(entry => {
-        try {
-          const parsed = JSON.parse(entry);
-          if (!parsed.pid) parsed.pid = getClaudePid();
-          reconstructor.reconstruct(parsed);
-          try { enrichEntry(parsed); } catch {}
-          try { enrichWorkflowEntry(parsed); } catch {}
-          sendToClients(clients, parsed);
-          runParallelHook('onNewEntry', parsed).catch(() => {});
-          if (isMainAgentEntry(parsed) && !parsed.inProgress) {
-            const cached = extractCachedContent(parsed);
-            if (cached) sendEventToClients(clients, 'kv_cache_content', cached);
-            const usage = parsed.response?.body?.usage;
-            if (usage) {
-              const contextSize = getContextSizeForModel(parsed.body?.model);
-              const cwData = buildContextWindowEvent(usage, contextSize);
-              if (cwData) sendEventToClients(clients, 'context_window', cwData);
-            }
-          }
-        } catch {}
-      });
-      notifyStatsWorker(logFile);
-    }
-
-    const currentLogFile = getLogFile();
-    if (currentLogFile !== logFile && !watchedFiles.has(currentLogFile)) {
-      await _switchToRotatedFile(logFile, currentLogFile, clients, opts);
-    }
-  } catch {
-    // File not yet created or transient read error
-  } finally {
-    state._reading = false;
-  }
-}
-
-// --- 目录级 fs.watch 管理 ---
-
-function _getOrCreateDirWatcher(dir) {
-  if (_dirWatchers.has(dir)) return _dirWatchers.get(dir);
-
-  try {
-    const files = new Map();
-    const watcher = watch(dir, (eventType, filename) => {
-      if (!filename) {
-        for (const [, fileState] of files) {
-          _scheduleDebouncedRead(fileState);
-        }
-        return;
-      }
-      const fileState = files.get(filename);
-      if (fileState) _scheduleDebouncedRead(fileState);
-    });
-
-    watcher.on('error', () => {
-      for (const [, fileState] of files) {
-        _fallbackToPolling(fileState);
-      }
-      try { watcher.close(); } catch {}
-      _dirWatchers.delete(dir);
-    });
-
-    const entry = { watcher, files };
-    _dirWatchers.set(dir, entry);
-    return entry;
-  } catch {
-    return null;
-  }
-}
-
-function _scheduleDebouncedRead(fileState) {
-  if (fileState.debounceTimer) return;
-  fileState.debounceTimer = setTimeout(() => {
-    fileState.debounceTimer = null;
-    _readDelta(fileState);
-  }, FSWATCH_DEBOUNCE_MS);
-}
-
-// 测试注入缝(仿 updater fetchImpl 惯例):替换轮询分支的 watchFile 实现。
-// 真实 watchFile 的 stat 基线与 500ms 间隔在 CI 慢机上不可确定性驱动(基线竞态曾致
-// 25s 全程静默 flake),单测注入假实现手动触发回调即可零时序覆盖。生产恒为 node:fs 原版。
-let _watchFileImpl = watchFile;
-export function __setWatchFileImplForTests(fn) { _watchFileImpl = fn || watchFile; }
-
-function _fallbackToPolling(fileState) {
-  if (fileState.polling) return;
-  fileState.polling = true;
-  _watchFileImpl(fileState.logFile, { interval: 500 }, () => {
-    _readDelta(fileState);
-  });
-}
-
-function _unwatchSingleFile(logFile) {
-  const fileState = watchedFiles.get(logFile);
-  watchedFiles.delete(logFile);
-
-  if (!fileState) return;
-
-  if (fileState.debounceTimer) clearTimeout(fileState.debounceTimer);
-  if (fileState.safetyTimer) clearInterval(fileState.safetyTimer);
-
-  if (fileState.polling) {
-    try { unwatchFile(logFile); } catch {}
-    return;
-  }
-
-  const dir = dirname(logFile);
-  const filename = basename(logFile);
-  const dirEntry = _dirWatchers.get(dir);
-  if (dirEntry) {
-    dirEntry.files.delete(filename);
-    if (dirEntry.files.size === 0) {
-      try { dirEntry.watcher.close(); } catch {}
-      _dirWatchers.delete(dir);
-    }
+export function sendChunkToClients(clients, dataJson) {
+  const payload = `event: load_chunk\ndata: ${dataJson}\n\n`;
+  for (let i = clients.length - 1; i >= 0; i--) {
+    _safeSseWrite(clients, clients[i], payload);
   }
 }
 
-// --- 公开 API ---
-
-export function watchLogFile(opts) {
-  const { logFile } = opts;
-  if (watchedFiles.has(logFile)) return;
-
-  let lastByteOffset = 0;
-  const _reconstructor = createIncrementalReconstructor();
-  try {
-    if (existsSync(logFile)) {
-      lastByteOffset = statSync(logFile).size;
+/**
+ * Per-entry broadcast pipeline — the single processing path every live entry
+ * takes on its way to the SSE clients, regardless of source (v1 file tail or
+ * the v2 live feed): pid stamping, server-side delta reconstruction, plan/
+ * workflow enrichment, client broadcast, plugin hook, kv-cache and
+ * context-window side events.
+ * @param {object} parsed - one parsed log entry (mutated in place)
+ * @param {{reconstructor: object, clients: Array, getClaudePid: Function,
+ *          runParallelHook: Function}} ctx
+ */
+export function processWatchedEntry(parsed, ctx) {
+  const { reconstructor, clients, getClaudePid, runParallelHook } = ctx;
+  if (!parsed.pid) parsed.pid = getClaudePid();
+  reconstructor.reconstruct(parsed);
+  try { enrichEntry(parsed); } catch {}
+  try { enrichWorkflowEntry(parsed); } catch {}
+  // 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);
+    if (cached) sendEventToClients(clients, 'kv_cache_content', cached);
+    const usage = parsed.response?.body?.usage;
+    if (usage) {
+      const contextSize = getContextSizeForModel(parsed.body?.model);
+      const cwData = buildContextWindowEvent(usage, contextSize);
+      if (cwData) sendEventToClients(clients, 'context_window', cwData);
     }
-  } catch {}
-
-  const fileState = {
-    logFile,
-    opts,
-    reconstructor: _reconstructor,
-    lastByteOffset,
-    pendingTail: '',
-    debounceTimer: null,
-    safetyTimer: null,
-    polling: false,
-  };
-
-  watchedFiles.set(logFile, fileState);
-
-  if (FORCE_POLL) {
-    _fallbackToPolling(fileState);
-    return;
-  }
-
-  const dir = dirname(logFile);
-  const filename = basename(logFile);
-  const dirEntry = _getOrCreateDirWatcher(dir);
-
-  if (!dirEntry) {
-    _fallbackToPolling(fileState);
-    return;
-  }
-
-  dirEntry.files.set(filename, fileState);
-
-  fileState.safetyTimer = setInterval(() => {
-    _readDelta(fileState);
-  }, SAFETY_POLL_MS);
-}
-
-export function unwatchLogFile(logFile) {
-  _unwatchSingleFile(logFile);
-}
-
-export function unwatchAll() {
-  for (const logFile of watchedFiles.keys()) {
-    _unwatchSingleFile(logFile);
   }
-  for (const [, entry] of _dirWatchers) {
-    try { entry.watcher.close(); } catch {}
-  }
-  _dirWatchers.clear();
-  watchedFiles.clear();
-}
-
-export function startWatching(opts) {
-  const { clients, ...watchOpts } = opts;
-  watchLogFile({ ...watchOpts, clients });
-}
-
-export function getWatchedFiles() {
-  return watchedFiles;
 }