cc-viewer 1.6.299 → 1.6.300

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-DWYtIFvu.js"></script>
+  <script type="module" crossorigin src="/assets/index-BXb1GO0R.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/vendor-antd-Bur5ZxWE.js">
   <link rel="modulepreload" crossorigin href="/assets/vendor-codemirror-Si44UqBp.js">
   <link rel="modulepreload" crossorigin href="/assets/vendor-mdxeditor-Cco3AQJS.js">

package/findcc.js

@@ -26,6 +26,18 @@ export function getClaudeConfigDir() {
     const raw = envDir.trim();
     return raw.startsWith('~/') ? join(homedir(), raw.slice(2)) : resolve(raw);
   }
+  // ████████ 测试隔离铁闸 L1b —— 绝对不可移除(2026-06-06 数据事故防再犯)████████
+  // CCV_LOG_DIR=tmp 只重定向 LOG_DIR,管不到本函数:updater.js 的 CACHE_DIR=
+  // join(getClaudeConfigDir(),'cc-viewer') 在测试里直指真实 ~/.claude/cc-viewer,
+  // branch-lib-updater.test.js 的 rmSync(CACHE_DIR,{recursive}) 曾因此把用户 40GB
+  // 历史日志整树删除(2026-06-06 第 1/4 次事故确证真凶)。settings.json、ensure-hooks、
+  // ~/.claude/* 展开全部派生于此 —— 测试态(node:test 注入 NODE_TEST_CONTEXT)未显式
+  // 设 CLAUDE_CONFIG_DIR 时,一律走进程私有临时目录,绝不解析到真实 ~/.claude。
+  // 单测:test/logdir-test-guard.test.js。
+  if (process.env.NODE_TEST_CONTEXT) {
+    return join(tmpdir(), 'cc-viewer-test', `guard-cfg-${process.pid}-${threadId}`);
+  }
+  // ████████████████████████████████████████████████████████████████████████████
   return join(homedir(), '.claude');
 }
 
@@ -40,6 +52,13 @@ function resolveLogDir() {
     const expanded = raw.startsWith('~/') ? join(homedir(), raw.slice(2)) : raw;
     return resolve(expanded);
   }
+  // 测试隔离铁闸:node:test 环境(NODE_TEST_CONTEXT 由测试 runner 自动注入,spread env
+  // 的子进程会继承)下若未显式设 CCV_LOG_DIR,绝不解析到真实用户目录——强制进程私有临时
+  // 目录。2026-06-06 事故:无 env 的测试探针把真实 ~/.claude/cc-viewer 当 LOG_DIR,
+  // 清理逻辑将用户数据整树删除。任何测试运行不允许触碰在用的文件体系和本地存储。
+  if (process.env.NODE_TEST_CONTEXT) {
+    return join(tmpdir(), 'cc-viewer-test', `guard-${process.pid}-${threadId}`);
+  }
   return join(getClaudeConfigDir(), 'cc-viewer');
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-viewer",
-  "version": "1.6.299",
+  "version": "1.6.300",
   "description": "Claude Code Logger visualization management tool",
   "license": "MIT",
   "main": "server.js",
@@ -22,9 +22,9 @@
     "pretest": "npm run lint:control-bytes",
     "pretest:coverage": "npm run lint:control-bytes",
     "pretest:coverage:html": "npm run lint:control-bytes",
-    "test": "CCV_LOG_DIR=tmp node --test --test-force-exit",
-    "test:coverage": "CCV_LOG_DIR=tmp node --test --test-force-exit --experimental-test-coverage --test-coverage-include='server/**/*.js' --test-coverage-include='src/utils/**/*.js' --test-coverage-include='*.js'",
-    "test:coverage:html": "CCV_LOG_DIR=tmp c8 --reporter=text-summary --reporter=html node --test",
+    "test": "CCV_LOG_DIR=tmp CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 node --test --test-force-exit --test-timeout=120000",
+    "test:coverage": "CCV_LOG_DIR=tmp CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 node --test --test-force-exit --test-timeout=120000 --experimental-test-coverage --test-coverage-include='server/**/*.js' --test-coverage-include='src/utils/**/*.js' --test-coverage-include='*.js'",
+    "test:coverage:html": "CCV_LOG_DIR=tmp CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 c8 --reporter=text-summary --reporter=html node --test --test-force-exit --test-timeout=120000",
     "prepublishOnly": "npm run build",
     "electron:dev": "electron electron/main.js",
     "electron:build": "npm run build && electron-builder",

package/server/interceptor.js

@@ -16,7 +16,7 @@ import { homedir } from 'node:os';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { dirname, join, basename } from 'node:path';
 import { LOG_DIR } from '../findcc.js';
-import { assembleStreamMessage, createStreamAssembler, cleanupTempFiles, findRecentLog, isAnthropicApiPath, isMainAgentRequest, rotateLogFile, fingerprintMsg } from './lib/interceptor-core.js';
+import { assembleStreamMessage, createStreamAssembler, cleanupTempFiles, findRecentLog, isAnthropicApiPath, isMainAgentRequest, rotateLogFile, fingerprintMsg, replaceTopLevelModel } from './lib/interceptor-core.js';
 
 
 
@@ -780,15 +780,31 @@ export function setupInterceptor() {
             }
           }
         }
-        // 3. Model 替换
+        // 3. Model 替换 —— 避免对整条 wire body（-c 重启后全量 checkpoint 可达数十 MB）
+        //    二次 JSON.parse + 全量 re-stringify：用 L557 已解析的 body 读旧值，对原始
+        //    字符串做有界定向替换（唯一非歧义匹配才生效）；定位失败回退旧 parse 路径，
+        //    最坏退化为现状。注意不能复用 requestEntry.body 重建 wire —— delta 路径
+        //    （上方 needsCheckpoint=false 分支）已把它的 messages 改成增量切片。
         if (_activeProfile.activeModel && _fetchOpts?.body) {
-          try {
-            const _b = JSON.parse(_fetchOpts.body);
-            if (_b.model) {
-              _b.model = _activeProfile.activeModel;
-              _fetchOpts = { ..._fetchOpts, body: JSON.stringify(_b) };
+          const _oldModel = (body && typeof body === 'object') ? body.model : undefined;
+          if (_oldModel === _activeProfile.activeModel) {
+            // 已是目标 model，跳过（旧路径会原样 re-stringify，对上游等价）
+          } else {
+            const _replaced = (typeof _fetchOpts.body === 'string' && typeof _oldModel === 'string')
+              ? replaceTopLevelModel(_fetchOpts.body, _oldModel, _activeProfile.activeModel)
+              : null;
+            if (_replaced !== null) {
+              _fetchOpts = { ..._fetchOpts, body: _replaced };
+            } else {
+              try {
+                const _b = JSON.parse(_fetchOpts.body);
+                if (_b.model) {
+                  _b.model = _activeProfile.activeModel;
+                  _fetchOpts = { ..._fetchOpts, body: JSON.stringify(_b) };
+                }
+              } catch { }
             }
-          } catch { }
+          }
         }
         // 记录 proxy 信息到日志条目
         requestEntry.proxyProfile = _activeProfile.name;

package/server/lib/async-write-queue.js

@@ -4,13 +4,15 @@
 import { appendFile } from 'node:fs/promises';
 import { appendFileSync } from 'node:fs';
 
-const HIGH_WATER_MARK = 50 * 1024 * 1024; // 50MB — 超过此值降级为同步写入
+const HIGH_WATER_MARK = 50 * 1024 * 1024; // 50MB — backlog 超过此值降级为同步写入
+const WRITE_CHUNK_BYTES = 8 * 1024 * 1024; // 8MB — 单次 async append 上限，巨条分块让出 FS handle
 
 export class AsyncWriteQueue {
   /**
    * @param {string|(() => string)} pathOrGetter - 文件路径或返回路径的函数（支持动态路径）
    * @param {object} [opts]
    * @param {boolean} [opts.syncMode] - 强制同步模式
+   * @param {number} [opts.highWaterMark] - backlog 同步降级阈值（默认 50MB；测试用）
    */
   constructor(pathOrGetter, opts = {}) {
     this._pathOrGetter = pathOrGetter;
@@ -21,6 +23,9 @@ export class AsyncWriteQueue {
     this._closed = false;
     this._flushResolvers = []; // resolve() callbacks waiting for flush()
     this._syncMode = opts.syncMode || !!process.env.CCV_SYNC_WRITES;
+    // typeof 防御：字符串 "1000" 能通过 > 0 协转检查，但后续字节比较会退化为字典序
+    this._highWaterMark = (typeof opts.highWaterMark === 'number' && opts.highWaterMark > 0)
+      ? opts.highWaterMark : HIGH_WATER_MARK;
   }
 
   _getPath() {
@@ -38,13 +43,21 @@ export class AsyncWriteQueue {
       return;
     }
 
-    if (this._syncMode || this._pendingBytes >= HIGH_WATER_MARK) {
+    // 同步降级是 backlog 的内存压力保护，不是按条规则：
+    // - 单条超大 buffer（-c 重启后的全量 checkpoint，可达数十 MB）必须走异步 ——
+    //   对它 appendFileSync 正是 Windows event loop 卡死点；其内存代价 ≈ 字符串本就在内存。
+    // - drain 在途时绝不抢同步（正确性硬约束）：_drain 现按 8MB 分块写，appendFileSync
+    //   插队会落在分块中间、把条目撕裂进另一条 JSON 内部。又因"队列非空 ⇒ 必已 scheduleDrain
+    //   ⇒ _draining=true"，这条 backlog 同步分支实际只是防御性兜底，正常运行不会触发。
+    const byteLen = Buffer.byteLength(data);
+    const wouldExceed = this._pendingBytes + byteLen >= this._highWaterMark;
+    const oversizedSingle = byteLen >= this._highWaterMark;
+    if (this._syncMode || (wouldExceed && !oversizedSingle && !this._draining)) {
       try { appendFileSync(path, data); } catch {}
       if (onDone) try { onDone(); } catch {}
       return;
     }
 
-    const byteLen = Buffer.byteLength(data);
     this._queue.push({ path, data, onDone });
     this._pendingBytes += byteLen;
     this._scheduleDrain();
@@ -108,7 +121,20 @@ export class AsyncWriteQueue {
         }
 
         try {
-          await appendFile(path, combined);
+          // 巨条分块：单次 async append 超过 8MB 时按字节切片顺序写，
+          // 避免一次巨型写独占 FS handle（Windows NTFS 上拖垮其它 I/O）。
+          // 必须按 Buffer 字节切（而非字符串 slice），否则多字节 UTF-8 字符
+          // 跨界会被 per-call 编码撕裂成乱码。顺序 await 保证落盘顺序。
+          // Buffer.from 对超大 combined 有一次性内存翻倍（30MB 串 → +30MB Buffer），
+          // 循环结束即释放，等价于字符串自身的量级，可接受。
+          const buf = Buffer.from(combined, 'utf-8');
+          if (buf.length <= WRITE_CHUNK_BYTES) {
+            await appendFile(path, buf);
+          } else {
+            for (let pos = 0; pos < buf.length; pos += WRITE_CHUNK_BYTES) {
+              await appendFile(path, buf.subarray(pos, pos + WRITE_CHUNK_BYTES));
+            }
+          }
         } catch {}
         for (const cb of callbacks) {
           try { cb(); } catch {}

package/server/lib/config-backup.js

@@ -0,0 +1,54 @@
+// 启动期配置备份 — 2026-06-06 LOG_DIR 整树删除事故防再犯。
+// preferences.json(auth/IM token/偏好)、profile.json(代理热切换)、workspaces.json(工作区注册表)
+// 是无法从日志/会话重建的"静态设置";本模块在 server 启动时把它们备份到 LOG_DIR **之外**
+// 的兄弟目录(默认 ~/.claude/cc-viewer-config-backups/<时间戳>/),滚动保留最近 KEEP 份。
+// 全程 best-effort:任何失败只返回 {ok:false},绝不抛错阻塞启动。
+import { existsSync, mkdirSync, copyFileSync, readdirSync, rmSync, chmodSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { LOG_DIR } from '../../findcc.js';
+
+const CONFIG_FILES = ['preferences.json', 'profile.json', 'workspaces.json'];
+const KEEP = 10;
+// 备份子目录名:严格时间戳形态。prune 只删匹配此形态的目录,绝不波及其它内容。
+const STAMP_RE = /^\d{8}_\d{6}$/;
+
+export function getBackupRoot(logDir = LOG_DIR) {
+  return join(dirname(logDir), 'cc-viewer-config-backups');
+}
+
+/**
+ * 备份 logDir 下的配置文件到 getBackupRoot()/<YYYYMMDD_HHMMSS>/,并滚动清理。
+ * @param {string} [logDir] 默认 findcc 的 LOG_DIR(live binding)
+ * @param {Date}   [now]    注入时钟,便于测试
+ * @returns {{ok:boolean, dir?:string, copied?:string[], pruned?:number, error?:string}}
+ */
+export function backupConfigs(logDir = LOG_DIR, now = new Date()) {
+  try {
+    const candidates = CONFIG_FILES.filter((f) => existsSync(join(logDir, f)));
+    if (!candidates.length) return { ok: true, copied: [], pruned: 0 };
+    const stamp = now.toISOString().replace(/[-:]/g, '').replace('T', '_').slice(0, 15);
+    const root = getBackupRoot(logDir);
+    const dir = join(root, stamp);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const copied = [];
+    for (const f of candidates) {
+      try {
+        copyFileSync(join(logDir, f), join(dir, f));
+        // preferences 携带密钥,备份份保持 0600(copyFileSync 跟随 umask,需显式收紧)
+        chmodSync(join(dir, f), 0o600);
+        copied.push(f);
+      } catch { /* 单文件失败不影响其它 */ }
+    }
+    let pruned = 0;
+    try {
+      const entries = readdirSync(root).filter((d) => STAMP_RE.test(d)).sort();
+      while (entries.length > KEEP) {
+        rmSync(join(root, entries.shift()), { recursive: true, force: true });
+        pruned++;
+      }
+    } catch { /* prune 失败不影响本次备份 */ }
+    return { ok: true, dir, copied, pruned };
+  } catch (err) {
+    return { ok: false, error: err?.message || String(err) };
+  }
+}

package/server/lib/im-process-manager.js

@@ -60,6 +60,20 @@ export function buildChildEnv(id, base = process.env) {
  * @returns {{ pid:number|undefined, dir:string, outLog:string }}
  */
 export function spawnImProcess(id, opts = {}) {
+  // ████████ 测试隔离铁闸 L4 —— 绝对不可移除(2026-06-06 数据事故防再犯)████████
+  // 单元测试【绝不允许】拉起真实 detached IM worker:
+  //  1) detached worker 脱离测试生命周期常驻(PPID=1),测试结束后仍在运行;
+  //  2) buildChildEnv 按设计剥离 CCV_*,worker 子链最终把真实 ~/.claude/cc-viewer 当 LOG_DIR;
+  //  3) 测试与用户真实 worker 在锁/端口(7050-7099)/配置上互相干扰——
+  //     2026-06-06 该链条曾三次把用户 40GB 历史日志整树删除。
+  // 注入 spawnImpl 的纯单测(假 spawn)不受影响;确需真实 spawn 的集成测试必须显式
+  // CCV_TEST_ALLOW_IM_SPAWN=1 并自行负责完全隔离(私有 CCV_LOG_DIR + 私有端口窗)。
+  if (process.env.NODE_TEST_CONTEXT && !opts.spawnImpl && process.env.CCV_TEST_ALLOW_IM_SPAWN !== '1') {
+    const dir = imDir(id);
+    console.warn(`[im-process-manager] 测试环境拒绝真实 spawn IM worker '${id}'(L4 铁闸;如确需请设 CCV_TEST_ALLOW_IM_SPAWN=1)`);
+    return { pid: undefined, dir, outLog: join(dir, 'process.out.log'), blockedByTestGuard: true };
+  }
+  // ████████████████████████████████████████████████████████████████████████
   const spawnImpl = opts.spawnImpl || nodeSpawn;
   const dir = imDir(id);
   mkdirSync(dir, { recursive: true });

package/server/lib/interceptor-core.js

@@ -400,3 +400,43 @@ export function rotateLogFile(currentFile, newFile, maxSize) {
   } catch { }
   return { rotated: false };
 }
+
+/**
+ * 在原始 JSON 字符串上定向替换顶层 "model" 字段的值，避免对巨型 wire body
+ * （`-c` 重启后的全量 checkpoint 请求可达数十 MB）做二次 JSON.parse + 全量 re-stringify。
+ *
+ * 安全性依据：
+ * - JSON 字符串值内的引号必然转义为 \"，裸 `"model":"<old>"` 字节序列只能出现在真实结构处；
+ * - 候选必须满足成员边界（前一个非空白字符是 `{` 或 `,`）；
+ * - 顶层 model 恒存在恒命中 → 嵌套对象若有同值 model 键则候选 ≥2 → 返回 null 由调用方
+ *   回退 parse/stringify 旧路径（最坏退化为现状，绝不误改）。
+ *
+ * @param {string} jsonStr - 原始 wire body（紧凑或带单空格的 JSON 字符串）
+ * @param {string} oldModel - 当前顶层 model 值（来自已解析的 body.model）
+ * @param {string} newModel - 目标 model 值
+ * @returns {string|null} 替换后的字符串；无法唯一定位时返回 null（调用方回退）
+ */
+export function replaceTopLevelModel(jsonStr, oldModel, newModel) {
+  if (typeof jsonStr !== 'string' || typeof oldModel !== 'string' || !oldModel ||
+      typeof newModel !== 'string' || !newModel) return null;
+  const oldVal = JSON.stringify(oldModel);
+  // 覆盖紧凑（JSON.stringify 默认）与冒号后单空格两种序列化形态；其它形态 → 0 候选 → 回退
+  const needles = [`"model":${oldVal}`, `"model": ${oldVal}`];
+  const candidates = [];
+  for (const needle of needles) {
+    let idx = jsonStr.indexOf(needle);
+    while (idx !== -1) {
+      // 成员边界校验：前一个非空白字符必须是 { 或 ,
+      let p = idx - 1;
+      while (p >= 0 && (jsonStr[p] === ' ' || jsonStr[p] === '\t' || jsonStr[p] === '\n' || jsonStr[p] === '\r')) p--;
+      if (p >= 0 && (jsonStr[p] === '{' || jsonStr[p] === ',')) {
+        candidates.push({ idx, needle });
+      }
+      idx = jsonStr.indexOf(needle, idx + 1);
+    }
+  }
+  if (candidates.length !== 1) return null;
+  const { idx, needle } = candidates[0];
+  const replaced = needle.slice(0, needle.length - oldVal.length) + JSON.stringify(newModel);
+  return jsonStr.slice(0, idx) + replaced + jsonStr.slice(idx + needle.length);
+}

package/server/lib/sdk-manager.js

@@ -19,6 +19,10 @@ try {
   console.warn('[SDK] Agent SDK not available:', err.message);
 }
 
+// Test seam — inject a fake query() (仿 im-bridge-core.js 的 __setFetchForTests 惯例).
+// 仅供单测注入 fake async-generator，不改任何业务逻辑。
+export function __setQueryForTests(fn) { _query = fn; }
+
 // Interactive tool names — filtered from entries, handled via canUseTool → WS
 const INTERACTIVE_TOOLS = new Set(['AskUserQuestion', 'ExitPlanMode']);
 

package/server/lib/updater.js

@@ -140,7 +140,7 @@ export function isAnyCcvBusy({ currentPid, busy, portRange, lsofImpl } = {}) {
 //                       却被当显式传值，从而绕过自动检测，让 brew 用户被错误地走 npm 路径升级。
 //
 // 返回 status:
-//   disabled | skipped | latest | major_available | deferred_busy
+//   disabled | skipped | skipped_test_context | latest | major_available | deferred_busy
 //   | brew_managed | upgrading_in_background | error
 export async function checkAndUpdate(options = {}) {
   const fetchImpl = options.fetchImpl || fetch;
@@ -164,6 +164,23 @@ export async function checkAndUpdate(options = {}) {
     return { status: 'skipped', currentVersion, remoteVersion: null };
   }
 
+  // ████████ 测试隔离铁闸 L5 —— 绝对不可移除(2026-06-06 数据事故防再犯)████████
+  // 单元测试【绝不允许】发送真实网络请求:起真实 server 的测试,启动链的 30s 定时器
+  // (server.js startViewer)会走到这里,真打 registry.npmjs.org,同大版本空闲时甚至
+  // 触发 detached `npm install` 真实自更新——测试能改写用户的 cc-viewer 安装。
+  // 条件说明:
+  //  - NODE_TEST_CONTEXT:node:test runner 自动注入,覆盖测试进程及 spread env 子进程;
+  //  - NODE_ENV==='test' 兜底:覆盖测试用 spawnSync 起的孙进程(NODE_TEST_CONTEXT 跨代
+  //    传递不保证,如 branch-server.test.js 的 runScenario);
+  //  - 注入 fetchImpl 的 updater 单测(假网络)不受影响,走正常逻辑;
+  //  - 闸位必须在 disabled/skipped 早退【之后】、真实 fetch【之前】:放函数入口会劫持
+  //    存量无-fetchImpl 用例对 disabled/skipped 的断言。
+  // 守卫单测:test/updater-test-guard.test.js。
+  if ((process.env.NODE_TEST_CONTEXT || process.env.NODE_ENV === 'test') && !options.fetchImpl) {
+    return { status: 'skipped_test_context', currentVersion, remoteVersion: null };
+  }
+  // ████████████████████████████████████████████████████████████████████████████
+
   try {
     const res = await fetchImpl('https://registry.npmjs.org/cc-viewer');
     if (!res.ok) throw new Error(`HTTP ${res.status}`);

package/server/routes/events.js

@@ -194,6 +194,15 @@ async function events(req, res, parsedUrl, isLocal, deps) {
   let latestKvCache = null;
   let latestContextWindow = null;
   let pushedContextWindow = false;
+  // 只记忆最后 K 条 mainAgent 候选原始字符串，Pass 1 结束后 newest-first 结构化校验
+  // （isMainAgentEntry），最多 parse K 次。旧逻辑在 onScan 里对每条 mainAgent raw 全量
+  // JSON.parse —— `-c` 大会话日志里多个数十 MB 的 checkpoint 会让每次 SSE 连接阻塞
+  // event loop 数秒（Windows 卡死主因之一）。
+  // ring=3 的容错意义：团队会话末尾常有连续 teammate 伪 mainAgent 条目，单记忆位会被
+  // 挤掉真实 mainAgent；子串预过滤的理论误伤（键/值恰为 "teammate" 的真实条目）也由
+  // 环内更早候选兜底。
+  const MAINAGENT_SCAN_RING = 3;
+  const mainAgentRawRing = [];
 
   await streamRawEntriesAsync(LOG_FILE, async (raw) => {
     // 直接发送原始 JSON 字符串，不做 parse/reconstruct/stringify
@@ -221,21 +230,13 @@ async function events(req, res, parsedUrl, isLocal, deps) {
     since: useIncremental ? sinceParam : undefined,
     limit: useLimit ? effectiveLimit : undefined,
     onScan: (raw) => {
-      // 轻量追踪最新 MainAgent 的 KV-Cache 和 context_window（仅 regex 检测）
-      if (raw.includes('"mainAgent":true') || raw.includes('"mainAgent": true')) {
-        try {
-          const entry = JSON.parse(raw);
-          if (isMainAgentEntry(entry)) {
-            const cached = extractCachedContent(entry);
-            if (cached) latestKvCache = cached;
-            const usage = entry.response?.body?.usage;
-            if (usage) {
-              const contextSize = getContextSizeForModel(entry.body?.model);
-              const cw = buildContextWindowEvent(usage, contextSize);
-              if (cw) latestContextWindow = cw;
-            }
-          }
-        } catch { }
+      // 只做子串检测 + 入环，不 parse（巨型 checkpoint 逐条 parse 会阻塞 event loop）。
+      // teammate 条目恒带 "teammate" 字段，子串预过滤减少环污染；结构化判定留给
+      // Pass 1 结束后的 newest-first 校验（isMainAgentEntry），预过滤误伤由环容错。
+      if ((raw.includes('"mainAgent":true') || raw.includes('"mainAgent": true')) &&
+          !raw.includes('"teammate"')) {
+        mainAgentRawRing.push(raw);
+        if (mainAgentRawRing.length > MAINAGENT_SCAN_RING) mainAgentRawRing.shift();
       }
     },
     onReady: ({ totalCount, hasMore, oldestTs }) => {
@@ -253,6 +254,27 @@ async function events(req, res, parsedUrl, isLocal, deps) {
 
   res.write(`event: load_end\ndata: {}\n\n`);
 
+  // Pass 1 入环的候选 newest-first 校验 + parse（≤K 次）。kv_cache 与 context_window
+  // 各自取"最新一条能提供该值的真实 mainAgent"—— 与旧版逐条覆盖语义等价（环深度内）。
+  for (let ri = mainAgentRawRing.length - 1; ri >= 0 && (!latestKvCache || !latestContextWindow); ri--) {
+    try {
+      const entry = JSON.parse(mainAgentRawRing[ri]);
+      if (!isMainAgentEntry(entry)) continue;
+      if (!latestKvCache) {
+        const cached = extractCachedContent(entry);
+        if (cached) latestKvCache = cached;
+      }
+      if (!latestContextWindow) {
+        const usage = entry.response?.body?.usage;
+        if (usage) {
+          const contextSize = getContextSizeForModel(entry.body?.model);
+          const cw = buildContextWindowEvent(usage, contextSize);
+          if (cw) latestContextWindow = cw;
+        }
+      }
+    } catch { }
+  }
+
   // 发送最新 MainAgent 的 KV-Cache 和 context_window
   if (latestKvCache) {
     res.write(`event: kv_cache_content\ndata: ${JSON.stringify(latestKvCache)}\n\n`);

package/server/routes/preferences.js

@@ -28,6 +28,9 @@ function preferencesGet(req, res, parsedUrl, isLocal, deps) {
   delete prefs.authByProject;
   stripImConfigs(prefs); // dingtalk / feishu / … — admin-only, never to a LAN client
   prefs.logDir = LOG_DIR; // 始终返回当前运行时的日志目录
+  // 日志设置出厂默认"继承"：键缺失（从未设置过）才注入；显式关闭持久化的是 null（键存在），不覆盖。
+  // 虚拟默认 —— 仅注入回包不落盘（GET 不写文件），直接读 preferences.json 的代码看不到该默认。
+  if (!('resumeAutoChoice' in prefs)) prefs.resumeAutoChoice = 'continue';
   // home-friendly 展示形态：设了 CLAUDE_CONFIG_DIR 的用户看到真实路径，默认用户看到 "~/.claude"
   // join() 而非字符串拼接，避免 Windows 分隔符不匹配导致比较失败
   const _cDir = getClaudeConfigDir();
@@ -111,6 +114,8 @@ function preferencesPost(req, res, parsedUrl, isLocal, deps) {
       delete prefs.authByProject;
       stripImConfigs(prefs);
       prefs.logDir = LOG_DIR;
+      // 与 GET 一致：回显里补齐 resumeAutoChoice 虚拟默认（已在上方落盘，文件不含该默认值）
+      if (!('resumeAutoChoice' in prefs)) prefs.resumeAutoChoice = 'continue';
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify(prefs));
     } catch {

package/server/server.js

@@ -77,6 +77,7 @@ import { loadPlugins, runWaterfallHook, runParallelHook } from './lib/plugin-loa
 import { CONTEXT_WINDOW_FILE, readModelContextSize } from './lib/context-watcher.js';
 import { watchLogFile, startWatching, unwatchAll, sendEventToClients, sendToClients } from './lib/log-watcher.js';
 import { cleanupExtractCache } from './lib/jsonl-archive.js';
+import { backupConfigs } from './lib/config-backup.js';
 import { createBackpressureGate } from './lib/ws-backpressure.js';
 
 
@@ -804,6 +805,10 @@ export async function startViewer() {
   // 清理过期解压缓存（fire-and-forget；任何错误吞掉）
   setImmediate(() => { try { cleanupExtractCache(); } catch { /* ignore */ } });
 
+  // 启动期配置备份:preferences/profile/workspaces → LOG_DIR 外的 cc-viewer-config-backups/
+  // (滚动留 10 份)。2026-06-06 事故:配置随 LOG_DIR 整树丢失后无处可恢复。fire-and-forget。
+  setImmediate(() => { try { backupConfigs(); } catch { /* ignore */ } });
+
   // 启动时清理磁盘上 ASK_HOOK_TIMEOUT_MS 之前的 ask 条目（兜底防泄漏）。
   // 内存 Map 不 hydrate：旧 res 已死、新 ask-bridge 重连同 toolUseId 会自动复用槽位
   // （server.js 已有"旧 res 已断 → 复用"分支），无需在这里主动重建内存态。
@@ -1883,6 +1888,10 @@ export function broadcastTurnEnd(sessionId = null, ts = Date.now()) {
 // 流式状态 SSE 推送定时器：检测 streamingState 变化并广播给所有客户端。
 // rising-edge → turn_end flush 由 _observeStreamingTick 统一处理。
 let _streamingStatusTimer = null;
+// 启动后 30s 的更新检查 timer 句柄。必须可清理:
+//  - .unref() 防止它把事件循环 keep-alive 30s(测试进程靠 --test-force-exit 兜底是时序侥幸);
+//  - _doStop 里 clearTimeout 防止 stop/start 循环(Electron tab / 测试)泄漏多个 pending 检查。
+let _updateCheckTimer = null;
 function startStreamingStatusTimer() {
   if (_streamingStatusTimer) return;
   _streamingStatusTimer = setInterval(() => {
@@ -1957,6 +1966,10 @@ async function _doStop() {
     clearInterval(_streamingStatusTimer);
     _streamingStatusTimer = null;
   }
+  if (_updateCheckTimer) {
+    clearTimeout(_updateCheckTimer);
+    _updateCheckTimer = null;
+  }
   resetStreamingState();
   // 清 interceptor 的 live-port，避免 stop/start 循环（Electron tab 切换 / 测试）间隙内
   // 早期请求向已关闭的端口 POST 丢包。新 startViewer 的 listen 回调会再次 setLivePort
@@ -2036,7 +2049,9 @@ if (!isWorkspaceMode) {
       // 为什么是 30s 而非 3s：空闲/忙判断的核心是 `clients.length`(SSE 已连) + PTY + SDK。
       // 3s 时大多数 client 还没连上 → busy 恒 false → 升级照打断用户。30s 给"活跃会话"留出进入窗口。
       // 同大版本直接后台 detached npm install（不阻塞事件循环）；跨大版本 / 忙时 → 仅广播 banner，用户下次启动再升。
-      setTimeout(async () => {
+      // 句柄必须保存:_doStop 要 clearTimeout(stop/start 循环防泄漏);.unref() 防 keep-alive。
+      // 测试侧三重防护:此处 unref + updater.js 的 L5 铁闸 + npm test 脚本 DISABLE_NONESSENTIAL_TRAFFIC。
+      _updateCheckTimer = setTimeout(async () => {
         let ptyRunning = false;
         try {
           const { getPtyState } = await import('./pty-manager.js');
@@ -2061,6 +2076,7 @@ if (!isWorkspaceMode) {
           }
         } catch { /* update check 失败静默 */ }
       }, 30_000);
+      _updateCheckTimer.unref();
     }).catch(err => {
       console.error('Failed to start CC Viewer:', err);
     });