cc-viewer 1.6.232 → 1.6.234

package/lib/enrich-plan-input.js

@@ -0,0 +1,109 @@
+/**
+ * Enrich Plan Input
+ *
+ * 在 cc-viewer 出 SSE/REST 之前，把 ExitPlanMode tool_use 的空 input 用 session 转写
+ * 里 normalizeToolInput 写进去的 plan / planFilePath 补全。
+ *
+ * 不修改 ExitPlanMode 之外的工具；不覆盖已有 input 字段。
+ */
+
+import { lookupToolUseInput } from './session-transcript-reader.js';
+
+const EMPTY_INPUT_SUBSTR = '"name":"ExitPlanMode","input":{}';
+
+/**
+ * 廉价子串预过滤：原始 JSON 字符串里有没有「ExitPlanMode + 空 input」的字节序列。
+ * 实测当前 CC 的 interceptor 用 default JSON.stringify(body)，零空格，恒定字节序。
+ *
+ * @param {string} raw
+ * @returns {boolean}
+ */
+export function rawHasEmptyExitPlanMode(raw) {
+  if (typeof raw !== 'string' || !raw) return false;
+  return raw.indexOf(EMPTY_INPUT_SUBSTR) !== -1;
+}
+
+function findEmptyExitPlanModeBlocks(content, out) {
+  if (!Array.isArray(content)) return;
+  for (const blk of content) {
+    if (!blk || blk.type !== 'tool_use' || blk.name !== 'ExitPlanMode') continue;
+    const inp = blk.input;
+    if (!inp || typeof inp !== 'object' || Array.isArray(inp)) continue;
+    if (Object.keys(inp).length !== 0) continue;
+    if (typeof blk.id !== 'string' || !blk.id) continue;
+    out.push(blk);
+  }
+}
+
+/**
+ * 遍历 entry 中所有 ExitPlanMode tool_use（response.body.content 当前轮 +
+ * body.messages[*].content[] 历史轮），把空 input 用 session 转写补全。
+ *
+ * 设计说明：
+ * - 早返回：缺 sessionId header（旧版 CC 无该 header）→ 不查表，不计 missed。
+ * - 早返回：sub-agent / 非 mainAgent 条目不 enrich——子代理 transcript 在另一目录
+ *   (`<sid>/subagents/agent-<hash>.jsonl`)，按主 transcript 的 tool_use.id 查表
+ *   理论上不会命中，但显式守卫避免万一同 id 撞库。
+ * - Header 名规范：interceptor 走 fetch Headers.entries() 全小写（WHATWG 规范），
+ *   只查小写键即可。
+ * - In-place mutation by design：用 Object.assign(blk.input, patch) 而非
+ *   `blk.input = {...}`。增量重建器 (lib/delta-reconstructor.js) 会让同一 tool_use
+ *   block 在多个 entry 间共享对象引用；in-place mutate 让后续 entry 的「Object.keys
+ *   (inp).length === 0」预检自动跳过——正是我们想要的 (相同 plan，不重新查盘)。
+ *   注意：此优化仅在 SSE / live 路径（共享对象）生效；REST 路径 raw → JSON.parse
+ *   每条独立对象，每条仍走一次 lookup（命中走 LRU，O(1)）。
+ *
+ * @param {object} entry - 已 JSON.parse 的日志条目
+ * @returns {{ enriched: number, missed: number }}
+ */
+export function enrichEntry(entry) {
+  if (!entry || typeof entry !== 'object') return { enriched: 0, missed: 0 };
+  if (entry.mainAgent === false) return { enriched: 0, missed: 0 };  // sub-agent 不补
+  const sid = entry.headers?.['x-claude-code-session-id'] || null;
+  if (!sid) return { enriched: 0, missed: 0 };
+  const projectHint = typeof entry.project === 'string' ? entry.project : undefined;
+
+  const candidates = [];
+  const respContent = entry.response?.body?.content;
+  findEmptyExitPlanModeBlocks(respContent, candidates);
+  const msgs = entry.body?.messages;
+  if (Array.isArray(msgs)) {
+    for (const m of msgs) {
+      if (m && Array.isArray(m.content)) findEmptyExitPlanModeBlocks(m.content, candidates);
+    }
+  }
+  if (candidates.length === 0) return { enriched: 0, missed: 0 };
+
+  let enriched = 0, missed = 0;
+  for (const blk of candidates) {
+    const found = lookupToolUseInput(sid, blk.id, projectHint);
+    if (found && (found.plan || found.planFilePath)) {
+      const patch = {};
+      if (typeof found.plan === 'string') patch.plan = found.plan;
+      if (typeof found.planFilePath === 'string') patch.planFilePath = found.planFilePath;
+      Object.assign(blk.input, patch);
+      enriched++;
+    } else {
+      missed++;
+    }
+  }
+  return { enriched, missed };
+}
+
+/**
+ * 服务端三处接入点共用：raw 字符串预过滤 → 命中才 parse + enrich + stringify。
+ *
+ * 设计原则：保持 lib/log-stream.js 的「原始字符串透传」哲学，只对真正需要补全的
+ * 条目做 parse / stringify，其它一律按 raw 透传。
+ *
+ * @param {string} raw - 一条日志条目的原始 JSON 字符串
+ * @returns {string} - enriched JSON 字符串，或原始 raw
+ */
+export function enrichRawIfNeeded(raw) {
+  if (!rawHasEmptyExitPlanMode(raw)) return raw;
+  let entry;
+  try { entry = JSON.parse(raw); } catch { return raw; }
+  const { enriched } = enrichEntry(entry);
+  if (enriched === 0) return raw;
+  try { return JSON.stringify(entry); } catch { return raw; }
+}

package/lib/log-stream.js

@@ -241,7 +241,7 @@ export async function streamRawEntriesAsync(filePath, onRawEntry, opts = {}) {
       if (ts && ts < sinceFilter) continue;
     }
 
-    onRawEntry(raw);
+    await onRawEntry(raw);
     sentCount++;
     if (sentCount % YIELD_INTERVAL === 0) {
       await new Promise(resolve => setImmediate(resolve));

package/lib/log-watcher.js

@@ -3,6 +3,7 @@ import { isMainAgentEntry, extractCachedContent } from './kv-cache-analyzer.js';
 import { buildContextWindowEvent, getContextSizeForModel } from './context-watcher.js';
 import { reconstructEntries, createIncrementalReconstructor } from './delta-reconstructor.js';
 import { countLogEntries, streamReconstructedEntries } from './log-stream.js';
+import { enrichEntry } from './enrich-plan-input.js';
 
 // 跟踪所有被 watch 的日志文件
 const watchedFiles = new Map();
@@ -40,19 +41,58 @@ export function readLogFile(logFile) {
   }
 }
 
+// SSE 单客户端 backpressure 容忍上限：连续未排空 > 此时长则视为 dead 客户端剔除。
+// 与 server.js 同名常量值保持一致（避免循环依赖，此处单独 mirror）。
+const SSE_BACKPRESSURE_TIMEOUT_MS = 5000;
+
+function _removeClient(clients, client) {
+  const idx = clients.indexOf(client);
+  if (idx !== -1) clients.splice(idx, 1);
+}
+
+/**
+ * 向单个 SSE client 安全写入 payload。
+ * - 写错或 client.destroyed/!writable：立即从 clients 数组移除
+ * - write 返回 false（写缓冲满）：标记时间戳，超过 SSE_BACKPRESSURE_TIMEOUT_MS 仍未排空则剔除并 end()
+ * - drain 后重置 _sseBackpressureSince=0，下次 backpressure 重新计时
+ */
+function _safeSseWrite(clients, client, payload) {
+  // 仅在显式标记 destroyed/writable=false 时剔除；undefined（如老 mock）按"活"处理。
+  if (client.destroyed === true || client.writable === false) {
+    _removeClient(clients, client);
+    return false;
+  }
+  let ok;
+  try {
+    ok = client.write(payload);
+  } catch {
+    _removeClient(clients, client);
+    return false;
+  }
+  if (!ok) {
+    if (!client._sseBackpressureSince) {
+      client._sseBackpressureSince = Date.now();
+      client.once('drain', () => { client._sseBackpressureSince = 0; });
+    } else if (Date.now() - client._sseBackpressureSince > SSE_BACKPRESSURE_TIMEOUT_MS) {
+      _removeClient(clients, client);
+      try { client.end(); } catch {}
+      return false;
+    }
+  }
+  return true;
+}
+
 /**
  * Send an SSE entry to all connected clients.
  * @param {Array} clients - SSE client array
  * @param {object} entry - parsed log entry
  */
 export function sendToClients(clients, entry) {
-  clients.forEach(client => {
-    try {
-      client.write(`data: ${JSON.stringify(entry)}\n\n`);
-    } catch (err) {
-      // Client disconnected
-    }
-  });
+  const payload = `data: ${JSON.stringify(entry)}\n\n`;
+  // 倒序遍历允许循环内安全 splice
+  for (let i = clients.length - 1; i >= 0; i--) {
+    _safeSseWrite(clients, clients[i], payload);
+  }
 }
 
 /**
@@ -62,11 +102,22 @@ export function sendToClients(clients, entry) {
  * @param {object} data - event payload
  */
 export function sendEventToClients(clients, eventName, data) {
-  clients.forEach(client => {
-    try {
-      client.write(`event: ${eventName}\ndata: ${JSON.stringify(data)}\n\n`);
-    } catch (err) {}
-  });
+  const payload = `event: ${eventName}\ndata: ${JSON.stringify(data)}\n\n`;
+  for (let i = clients.length - 1; i >= 0; i--) {
+    _safeSseWrite(clients, clients[i], payload);
+  }
+}
+
+/**
+ * 旋转处理器专用：发送已序列化的 load_chunk segment 数据。
+ * @param {Array} clients - SSE client array
+ * @param {string} dataJson - segment 已被调用方 JSON.stringify
+ */
+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);
+  }
 }
 
 /**
@@ -111,20 +162,13 @@ export function watchLogFile(opts) {
           unwatchFile(logFile);
           watchedFiles.delete(logFile);
 
-          // 流式分段广播，避免全量加载 OOM
+          // 流式分段广播，避免全量加载 OOM；走 _safeSseWrite 包装做 backpressure / dead-client 清理
           const rotTotal = countLogEntries(currentLogFile);
-          clients.forEach(client => {
-            try { client.write(`event: load_start\ndata: ${JSON.stringify({ total: rotTotal, incremental: false })}\n\n`); } catch { }
-          });
+          sendEventToClients(clients, 'load_start', { total: rotTotal, incremental: false });
           streamReconstructedEntries(currentLogFile, (segment) => {
-            const data = JSON.stringify(segment);
-            clients.forEach(client => {
-              try { client.write(`event: load_chunk\ndata: ${data}\n\n`); } catch { }
-            });
-          });
-          clients.forEach(client => {
-            try { client.write(`event: load_end\ndata: {}\n\n`); } catch { }
+            sendChunkToClients(clients, JSON.stringify(segment));
           });
+          sendEventToClients(clients, 'load_end', {});
           watchLogFile({ ...opts, logFile: currentLogFile });
           return;
         }
@@ -172,6 +216,11 @@ export function watchLogFile(opts) {
             }
             // Delta storage: reconstruct before push — 确保前端收到完整 messages
             _reconstructor.reconstruct(parsed);
+            // ExitPlanMode V2 input 服务端补全（详见 enrich-plan-input.js#enrichEntry JSDoc）。
+            // 同步实现：候选扫描天然廉价（无 ExitPlanMode 块直接 0ms 返回）；命中
+            // 路径由 transcript 64MB 上限 + miss 30s TTL + path mtime 校验三层兜
+            // 住，最坏 ~150ms。如未来 hit 比例显著上升再考虑 setImmediate 拆分。
+            try { enrichEntry(parsed); } catch { /* 静默回退 */ }
             sendToClients(clients, parsed);
             runParallelHook('onNewEntry', parsed).catch(() => {});
             if (isMainAgentEntry(parsed) && !parsed.inProgress) {

package/lib/session-transcript-reader.js

@@ -0,0 +1,242 @@
+/**
+ * Session Transcript Reader
+ *
+ * 从本地 Claude Code session 转写文件（<projectsDir>/<encoded-cwd>/<sessionId>.jsonl）
+ * 按 tool_use.id 抽取 ExitPlanMode 的 input.plan / planFilePath。
+ *
+ * 用途：CC 2.x ExitPlanModeV2Tool 在 API 网线送 input:{}，plan 内容仅在 CC 客户端
+ * normalizeToolInput 时写入 session 转写。cc-viewer 出 SSE/REST 前用本模块补全。
+ *
+ * 设计决策：
+ * - 边界放置在 server egress 而非 fs.watch + 独立 SSE 事件——前端零改动 +
+ *   tool_use.id 已在 wire 上同步可用；缺点是历史回放每次重扫，由 LRU + 文件大小
+ *   上限 + miss TTL 兜住。
+ * - projectsDir 走 findcc.getClaudeConfigDir()，与 CLAUDE_CONFIG_DIR 重定向对齐。
+ * - 内存：流式 1MB 分块读 + 行级 indexOf 双子串预过滤 + 半写入行 try/catch 跳过。
+ * - 缓存：transcript 路径 LRU(64) + tool_use input LRU(5000)；命中后用 mtime 校验
+ *   detect transcript 被覆写。
+ * - miss 短 TTL：30s 让 race（CC 还没 flush）后自动重试。
+ */
+
+import { existsSync, statSync, openSync, readSync, closeSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { getClaudeConfigDir } from '../findcc.js';
+
+function projectsDir() {
+  return process.env.CCV_PROJECTS_DIR || join(getClaudeConfigDir(), 'projects');
+}
+
+const READ_CHUNK_SIZE = 1024 * 1024;
+const MAX_TRANSCRIPT_BYTES = 64 * 1024 * 1024;  // 异常 GB 级文件防御
+const MISS_TTL_MS = 30 * 1000;                  // miss 路径短 TTL，让 race 后自动重试
+
+const PATH_CACHE_MAX = 64;
+const INPUT_CACHE_MAX = 5000;
+
+const transcriptPathCache = new Map();   // key → { path, mtimeMs } | { path: null, expireAt }
+const toolUseInputCache = new Map();     // `${path}:${tuId}` → { plan?, planFilePath? }（仅命中入缓存）
+
+function lruSet(map, key, value, max) {
+  if (map.has(key)) map.delete(key);
+  map.set(key, value);
+  if (map.size > max) {
+    const oldest = map.keys().next().value;
+    map.delete(oldest);
+  }
+}
+
+function lruGet(map, key) {
+  if (!map.has(key)) return undefined;
+  const v = map.get(key);
+  map.delete(key);
+  map.set(key, v);
+  return v;
+}
+
+function pickByMtime(arr) {
+  return arr.reduce((a, b) => a.mtimeMs >= b.mtimeMs ? a : b);
+}
+
+/**
+ * sessionId → 转写文件绝对路径。多匹配时按 entry.project 反向匹配编码目录尾段，
+ * 仍多匹配取 mtimeMs 最大者。命中后 LRU(64) 缓存（带 mtime）；miss 短 TTL 缓存。
+ *
+ * @param {string} sessionId
+ * @param {string} [projectHint] - interceptor 写入的 entry.project（basename of cwd, sanitized）
+ * @returns {string | null}
+ */
+export function findTranscriptPath(sessionId, projectHint) {
+  if (!sessionId) return null;
+  const cacheKey = projectHint ? `${sessionId}|${projectHint}` : sessionId;
+  const cached = lruGet(transcriptPathCache, cacheKey);
+  if (cached) {
+    if (cached.path === null) {
+      // miss 缓存：TTL 内继续返回 null，过期则重新探测
+      if (cached.expireAt && cached.expireAt > Date.now()) return null;
+    } else {
+      // hit 缓存：用 mtime 校验文件未被覆写
+      try {
+        const st = statSync(cached.path);
+        if (st.isFile() && st.mtimeMs === cached.mtimeMs) return cached.path;
+      } catch {}
+      // mtime 变了或文件没了 → fall through 重扫
+    }
+  }
+
+  const root = projectsDir();
+  let dirs;
+  try { dirs = readdirSync(root); }
+  catch {
+    lruSet(transcriptPathCache, cacheKey, { path: null, expireAt: Date.now() + MISS_TTL_MS }, PATH_CACHE_MAX);
+    return null;
+  }
+
+  const matches = [];
+  for (const d of dirs) {
+    const p = join(root, d, `${sessionId}.jsonl`);
+    let st;
+    try { st = statSync(p); } catch { continue; }
+    if (!st.isFile()) continue;
+    matches.push({ dir: d, path: p, mtimeMs: st.mtimeMs });
+  }
+
+  if (matches.length === 0) {
+    lruSet(transcriptPathCache, cacheKey, { path: null, expireAt: Date.now() + MISS_TTL_MS }, PATH_CACHE_MAX);
+    return null;
+  }
+
+  let chosen;
+  if (matches.length === 1) {
+    chosen = matches[0];
+  } else if (projectHint) {
+    const hint = String(projectHint);
+    const hintMatch = matches.filter(m => m.dir.endsWith('-' + hint) || m.dir === hint);
+    chosen = pickByMtime(hintMatch.length ? hintMatch : matches);
+  } else {
+    chosen = pickByMtime(matches);
+  }
+
+  lruSet(transcriptPathCache, cacheKey, { path: chosen.path, mtimeMs: chosen.mtimeMs }, PATH_CACHE_MAX);
+  return chosen.path;
+}
+
+/**
+ * 单行扫描：行级双子串预过滤后 JSON.parse 抽取目标 ExitPlanMode 块的 input。
+ *
+ * @param {string} line
+ * @param {string} toolUseId
+ * @returns {{ ok: 'hit', value: { plan?: string, planFilePath?: string } }
+ *         | { ok: 'unknown-shape' }
+ *         | { ok: 'miss' }}
+ */
+function scanLineForToolUse(line, toolUseId) {
+  if (!line) return { ok: 'miss' };
+  if (line.indexOf('"name":"ExitPlanMode"') === -1) return { ok: 'miss' };
+  if (line.indexOf(toolUseId) === -1) return { ok: 'miss' };
+
+  let entry;
+  try { entry = JSON.parse(line); } catch { return { ok: 'miss' }; }
+  const content = entry?.message?.content;
+  if (!Array.isArray(content)) return { ok: 'miss' };
+
+  let unknownShape = false;
+  for (const blk of content) {
+    if (blk?.type !== 'tool_use' || blk?.name !== 'ExitPlanMode') continue;
+    if (blk?.id !== toolUseId) continue;
+    const inp = blk.input || {};
+    const value = {};
+    if (typeof inp.plan === 'string') value.plan = inp.plan;
+    if (typeof inp.planFilePath === 'string') value.planFilePath = inp.planFilePath;
+    if (value.plan || value.planFilePath) return { ok: 'hit', value };
+    if (Object.keys(inp).length > 0) unknownShape = true;
+  }
+  return unknownShape ? { ok: 'unknown-shape' } : { ok: 'miss' };
+}
+
+/**
+ * 流式扫 transcript 文件，按 tool_use.id 找 ExitPlanMode 块的 input。
+ * 命中即 break；半写入行 try/catch 跳过。最大文件大小由 MAX_TRANSCRIPT_BYTES 兜底。
+ *
+ * @param {string} filePath
+ * @param {string} toolUseId
+ * @returns {{ result: { plan?: string, planFilePath?: string } | null, unknownShape: boolean }}
+ */
+function scanTranscriptFile(filePath, toolUseId) {
+  let unknownShape = false;
+  try {
+    const fileSize = statSync(filePath).size;
+    if (fileSize === 0) return { result: null, unknownShape: false };
+    if (fileSize > MAX_TRANSCRIPT_BYTES) {
+      try {
+        process.stderr.write(`[enrichPlan] transcript too large (${fileSize} bytes > ${MAX_TRANSCRIPT_BYTES}); skipped\n`);
+      } catch {}
+      return { result: null, unknownShape: false };
+    }
+    const fd = openSync(filePath, 'r');
+    const buf = Buffer.alloc(Math.min(READ_CHUNK_SIZE, fileSize));
+    let offset = 0;
+    let pending = '';
+    try {
+      while (offset < fileSize) {
+        const toRead = Math.min(buf.length, fileSize - offset);
+        const bytesRead = readSync(fd, buf, 0, toRead, offset);
+        if (bytesRead === 0) break;
+        offset += bytesRead;
+        const text = pending + buf.toString('utf-8', 0, bytesRead);
+        const lines = text.split('\n');
+        pending = lines.pop() ?? '';
+        for (const line of lines) {
+          const r = scanLineForToolUse(line, toolUseId);
+          if (r.ok === 'hit') return { result: r.value, unknownShape };
+          if (r.ok === 'unknown-shape') unknownShape = true;
+        }
+      }
+      if (pending) {
+        const r = scanLineForToolUse(pending, toolUseId);
+        if (r.ok === 'hit') return { result: r.value, unknownShape };
+        if (r.ok === 'unknown-shape') unknownShape = true;
+      }
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return { result: null, unknownShape };
+  }
+  return { result: null, unknownShape };
+}
+
+/**
+ * 按 sessionId + tool_use.id 查 ExitPlanMode 的 input.plan / planFilePath。
+ * 仅缓存命中；miss 路径靠 findTranscriptPath 的短 TTL miss 缓存兜底。
+ *
+ * @param {string} sessionId
+ * @param {string} toolUseId
+ * @param {string} [projectHint]
+ * @returns {{ plan?: string, planFilePath?: string } | null}
+ */
+export function lookupToolUseInput(sessionId, toolUseId, projectHint) {
+  if (!sessionId || !toolUseId) return null;
+  const filePath = findTranscriptPath(sessionId, projectHint);
+  if (!filePath || !existsSync(filePath)) return null;
+
+  const cacheKey = `${filePath}:${toolUseId}`;
+  const cached = lruGet(toolUseInputCache, cacheKey);
+  if (cached) return cached;
+
+  const { result, unknownShape } = scanTranscriptFile(filePath, toolUseId);
+
+  if (!result && unknownShape) {
+    try {
+      process.stderr.write(`[enrichPlan] schema drift: ExitPlanMode tool_use ${toolUseId} has input but no plan/planFilePath (sid=${sessionId})\n`);
+    } catch {}
+  }
+
+  if (result) lruSet(toolUseInputCache, cacheKey, result, INPUT_CACHE_MAX);
+  return result;
+}
+
+/** 测试用：清掉两个 LRU。 */
+export function clearCache() {
+  transcriptPathCache.clear();
+  toolUseInputCache.clear();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-viewer",
-  "version": "1.6.232",
+  "version": "1.6.234",
   "description": "Claude Code Logger visualization management tool",
   "license": "MIT",
   "main": "server.js",

package/server.js

@@ -48,6 +48,7 @@ import { watchLogFile, startWatching, getWatchedFiles, sendEventToClients, sendT
 import { isMainAgentEntry, extractCachedContent } from './lib/kv-cache-analyzer.js';
 import { listLocalLogs, deleteLogFiles, mergeLogFiles } from './lib/log-management.js';
 import { countLogEntries, streamRawEntriesAsync, readPagedEntries } from './lib/log-stream.js';
+import { enrichRawIfNeeded } from './lib/enrich-plan-input.js';
 import { buildTeamStatusResponse } from './lib/team-runtime.js';
 
 
@@ -185,6 +186,13 @@ export function initPostLaunch() {
 // Global POST body size limit (10MB) to prevent OOM from malicious/buggy clients
 const MAX_POST_BODY = 10 * 1024 * 1024;
 
+// /events 默认重放窗口：bare 请求（无 since、无 limit、无 cc）时使用，
+// 防止长会话把数十 MB 历史一次性灌进浏览器导致 renderer OOM。
+// 用户显式 ?limit=0 可恢复全量加载（power-user 逃生口）。
+const DEFAULT_EVENTS_LIMIT = 1000;
+// SSE 单客户端 backpressure 容忍上限：连续未排空 > 此时长则视为 dead 客户端剔除。
+const SSE_BACKPRESSURE_TIMEOUT_MS = 5000;
+
 
 
 const __filename = fileURLToPath(import.meta.url);
@@ -963,24 +971,57 @@ async function handleRequest(req, res) {
     const projectMatch = !projectParam || projectParam === (_projectName || '');
     const useIncremental = !!(sinceParam && ccParam > 0 && projectMatch && !isNaN(new Date(sinceParam).getTime()));
 
-    // 分页参数：移动端首次加载传 limit=200，与 since 互斥
-    const limitParam = parseInt(parsedUrl.searchParams.get('limit'), 10) || 0;
-    const useLimit = !useIncremental && limitParam > 0;
+    // 分页参数：
+    // - mobile 首次加载传 ?limit=200
+    // - bare desktop 请求（无任何 query 参数）默认套 DEFAULT_EVENTS_LIMIT
+    // - 显式 ?limit=0 表示"我要全量"（保留旧行为入口）
+    const limitParamRaw = parsedUrl.searchParams.get('limit');
+    const limitParamGiven = limitParamRaw !== null;
+    const limitParamNum = parseInt(limitParamRaw, 10);
+    let effectiveLimit = 0;
+    if (!useIncremental) {
+      if (limitParamGiven) {
+        effectiveLimit = Number.isFinite(limitParamNum) && limitParamNum > 0 ? limitParamNum : 0;
+      } else {
+        effectiveLimit = DEFAULT_EVENTS_LIMIT;
+      }
+    }
+    const useLimit = effectiveLimit > 0;
 
     // KV-Cache / context_window 追踪（扫描全量条目，不受 since 过滤影响）
     let latestKvCache = null;
     let latestContextWindow = null;
     let pushedContextWindow = false;
 
-    await streamRawEntriesAsync(LOG_FILE, (raw) => {
+    await streamRawEntriesAsync(LOG_FILE, async (raw) => {
       // 直接发送原始 JSON 字符串，不做 parse/reconstruct/stringify
+      // ExitPlanMode V2 空 input 的条目按需补全 plan / planFilePath，其它原样透传
+      if (res.destroyed || !res.writable) return;
+      const out = enrichRawIfNeeded(raw);
       // SSE data 字段不允许裸换行，去除 pretty-printed JSON 的换行
-      res.write('event: load_chunk\ndata: [');
-      res.write(raw.includes('\n') ? raw.replace(/\n/g, '') : raw);
-      res.write(']\n\n');
+      // 写入路径整体 try-catch 兜底：连接在 res.write 之间被对端 RST/destroy 时不至于
+      // 把 EPIPE 抛穿 async callback；res.on('close'|'error') 已会做 clients 数组清理。
+      let drained = true;
+      try {
+        res.write('event: load_chunk\ndata: [');
+        drained = res.write(out.includes('\n') ? out.replace(/\n/g, '') : out);
+        res.write(']\n\n');
+      } catch {
+        return;
+      }
+      // 写缓冲满则等 drain（或 close/error/超时任一 fulfill），防止浏览器侧 renderer OOM
+      if (!drained) {
+        await new Promise((resolve) => {
+          const t = setTimeout(resolve, SSE_BACKPRESSURE_TIMEOUT_MS);
+          const done = () => { clearTimeout(t); resolve(); };
+          res.once('drain', done);
+          res.once('close', done);
+          res.once('error', done);
+        });
+      }
     }, {
       since: useIncremental ? sinceParam : undefined,
-      limit: useLimit ? limitParam : undefined,
+      limit: useLimit ? effectiveLimit : undefined,
       onScan: (raw) => {
         // 轻量追踪最新 MainAgent 的 KV-Cache 和 context_window（仅 regex 检测）
         if (raw.includes('"mainAgent":true') || raw.includes('"mainAgent": true')) {
@@ -1045,11 +1086,16 @@ async function handleRequest(req, res) {
     // 这样 watcher 的 sendToClients 不会在 load 阶段向该客户端推送 live entry。
     clients.push(res);
 
-    req.on('close', () => {
+    // req.on('close') 在某些异常断连时不一定立即触发；res 端 close/error 兜底保证
+    // 不会在 clients 数组里留下幽灵 res，防止 sendToClients 后续写入触发慢泄漏。
+    const removeFromClients = () => {
       clearInterval(pingTimer);
       const idx = clients.indexOf(res);
       if (idx !== -1) clients.splice(idx, 1);
-    });
+    };
+    req.on('close', removeFromClients);
+    res.on('close', removeFromClients);
+    res.on('error', removeFromClients);
     return;
   }
 
@@ -1061,7 +1107,7 @@ async function handleRequest(req, res) {
     let first = true;
     await streamRawEntriesAsync(LOG_FILE, (raw) => {
       if (!first) res.write(',');
-      res.write(raw);
+      res.write(enrichRawIfNeeded(raw));
       first = false;
     });
     res.write(']');
@@ -1081,8 +1127,9 @@ async function handleRequest(req, res) {
     try {
       const result = readPagedEntries(LOG_FILE, { before, limit: limitVal });
       // entries 是原始 JSON 字符串数组，parse 后返回给客户端
+      // ExitPlanMode V2 空 input 的条目用 enrichRawIfNeeded 在 raw 阶段补全
       const entries = result.entries.map(raw => {
-        try { return JSON.parse(raw); } catch { return null; }
+        try { return JSON.parse(enrichRawIfNeeded(raw)); } catch { return null; }
       }).filter(Boolean);
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({