cc-viewer 1.6.306 → 1.6.308

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-1bh2o4MD.js"></script>
+  <script type="module" crossorigin src="/assets/index-BD-SSlan.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/package.json

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

package/server/interceptor.js

@@ -259,6 +259,15 @@ let _lastTailFp = '';           // 截至最近一次 startRequest 的末位 mes
 let _mainAgentDeltaCount = 0;   // mainAgent 请求计数器（用于触发定期 checkpoint）
 const CHECKPOINT_INTERVAL = 10; // 每 N 条 mainAgent 请求写一个 checkpoint
 
+// 完成序倒置守卫（KEEP IN SYNC: server/lib/delta-reconstructor.js + docs/WIRE_FORMAT.md §3.7）：
+// entry 形态在请求发起时冻结，但 completed entry 按响应完成顺序落盘（AsyncWriteQueue FIFO）。
+// burst 下慢请求的条目会落在快请求之后，文件序 ≠ 请求序，重建器按文件序拼接会翻倍。
+// `_seq` 记录请求发起序（语义序），`_seqEpoch` 标识写进程（重启 / 多进程混写时 seq 不可比，
+// 重建器据 epoch 切换基线而不是误判乱序）。teammate 子进程不参与（其条目不进 mainAgent 重建）。
+let _seqCounter = 0;
+// 时间戳 + 6 位随机尾：随机尾用于区分同毫秒启动的第二写进程（IM worker 场景）
+const _seqEpoch = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+
 /**
  * Delta storage: completed 写入成功后更新状态。
  *
@@ -654,6 +663,12 @@ export function setupInterceptor() {
       _deltaOriginalTailFp = messages.length > 0 ? fingerprintMsg(messages[messages.length - 1]) : '';
       _mainAgentDeltaCount++;
 
+      // 完成序倒置守卫：请求发起序号（必须与下方 Plan C eager 块同处一个同步段，中间不得插 await）
+      if (!_isTeammate) {
+        requestEntry._seq = ++_seqCounter;
+        requestEntry._seqEpoch = _seqEpoch;
+      }
+
       // 并发竞态修复（详见模块顶部注释 + history.md Unreleased 段 fix(interceptor) 条目）：
       // snapshot 上一请求处理时的 count/fp 给 Plan C 用，然后 eager 把模块级状态推到本次值
       // （不等 _commitDeltaState）。BUG 来源：teammate 终止快速串行让 mainAgent 30ms 内连续

package/server/lib/context-watcher.js

@@ -31,8 +31,8 @@ export function readModelContextSize() {
       if (sizeMatch) {
         const num = parseInt(sizeMatch[1], 10);
         contextSize = sizeMatch[2] === 'm' ? num * 1000000 : num * 1000;
-      } else if (/opus|mythons/i.test(lower)) {
-        // Opus / mythons models default to 1M context
+      } else if (/opus|mythons|fable[ -]5/i.test(lower)) {
+        // Opus / mythons / fable-5 family models default to 1M context
         contextSize = 1000000;
       }
       // Cache the base name → size mapping
@@ -61,8 +61,8 @@ export function getContextSizeForModel(apiModelName) {
   if (_startupModelBase && base === _startupModelBase) {
     return _startupContextSize;
   }
-  // Opus / mythons always have 1M context; other unknown models default to 200K
-  if (/opus|mythons/i.test(lower)) return 1000000;
+  // Opus / mythons / fable-5 family always have 1M context; other unknown models default to 200K
+  if (/opus|mythons|fable[ -]5/i.test(lower)) return 1000000;
   return 200000;
 }
 

package/server/lib/delta-reconstructor.js

@@ -2,10 +2,19 @@
 /**
  * Delta Reconstructor — 增量日志重建模块
  *
- * Wire format 协议详见 docs/WIRE_FORMAT.md（mainAgent entry 形态判定 / 字段词典）
+ * Wire format 协议详见 docs/WIRE_FORMAT.md（mainAgent entry 形态判定 / 字段词典 / §3.7 完成序倒置）
  *
  * 将 delta 格式的日志条目重建为完整的 messages 数组。
- * 仅处理 mainAgent 条目，teammate/旧格式条目直接跳过。
+ * 仅处理 mainAgent 条目；teammate（`entry.teammate` 字段，可能与 mainAgent:true 双标并存）
+ * 与旧格式条目直接跳过——teammate 子进程与 leader 共写同一日志文件，其消息绝不能进入
+ * mainAgent 的累积状态。
+ *
+ * 完成序倒置守卫（KEEP IN SYNC: server/interceptor.js `_seq` 写入点）：
+ * entry 形态在请求发起时冻结，但按响应完成顺序落盘，burst 下文件序可能 ≠ 请求序。
+ * 重建时跟踪 `_seq`/`_seqEpoch`：同 epoch 内 seq 小于已见最大值的条目判为乱序（stale），
+ * 不进累积态并标记 `_staleReorder`（客户端 merge 入口据此跳过）；epoch 变化（进程重启 /
+ * 换写进程）则重置基线。重建结果与 `_totalMessageCount` 不符时做完整性修复 / 标记
+ * `_reconstructBroken`，防脏条目把整段对话二次拼接（mainAgent 整段重复 bug 根因）。
  *
  * 提供三种 API：
  * - reconstructEntries(entries): 批量重建，用于 readLogFile() 和 readLocalLog()
@@ -32,10 +41,167 @@ export function isCheckpointEntry(entry) {
 }
 
 /**
- * 判断一个条目是否为需要重建的 delta 条目（mainAgent + _deltaFormat）。
+ * 判断一个条目是否为需要重建的 delta 条目（mainAgent + _deltaFormat，排除 teammate）。
+ * teammate 子进程的条目可能带 mainAgent:true 双标（system 含 "You are Claude Code"），
+ * 必须显式排除，否则其 delta/checkpoint 会污染 leader 的累积状态。
  */
 export function isDeltaEntry(entry) {
-  return entry._deltaFormat && entry.mainAgent;
+  return entry._deltaFormat && entry.mainAgent && !entry.teammate;
+}
+
+/**
+ * 判断条目是否参与 mainAgent 累积状态（非 delta 的旧格式全量条目分支共用）。
+ */
+function _isMainAgentFullEntry(entry) {
+  return entry.mainAgent && !entry.teammate && Array.isArray(entry.body?.messages);
+}
+
+// ============================================================================
+// 完成序倒置守卫（_seq/_seqEpoch）
+// ============================================================================
+
+/**
+ * seq 守卫状态机。st = { lastSeq: 0, lastEpoch: null }。
+ * 返回：
+ * - 'no-seq'：旧日志无 _seq，跳过检查（行为不变）
+ * - 'stale' ：同 epoch 且 seq 小于已见最大值 → 乱序条目
+ * - 'replay'：同 epoch 同 seq → 同条重发（日志轮转 race 等）
+ * - 'ok'    ：按序条目（含 epoch 切换），st 已推进
+ */
+function _seqGuardCheck(entry, st) {
+  const seq = entry._seq;
+  if (typeof seq !== 'number') return 'no-seq';
+  const epoch = entry._seqEpoch || null;
+  if (st.lastEpoch !== null && epoch === st.lastEpoch) {
+    if (seq < st.lastSeq) return 'stale';
+    if (seq === st.lastSeq) return 'replay';
+  }
+  // 按序 / epoch 切换（进程重启 seq 归零、IM worker 等第二写进程）：推进基线。
+  // 注意 epoch 是盲信的——任何未见过的 epoch 都视同"进程重启"重置基线，没有
+  // "哪个 epoch 拥有 mainAgent 流"的概念。双写进程 interleave 时基线会被来回
+  // rebase（短暂错误内容），由下一 checkpoint 自愈（≤CHECKPOINT_INTERVAL 条）。
+  st.lastEpoch = epoch;
+  st.lastSeq = seq;
+  return 'ok';
+}
+
+/**
+ * 标记乱序条目并尽量就地补偿：accumulated 已包含更新的真值时，用其前缀
+ * （= 截至该条目声称长度的最新内容）回填 body.messages，避免裸 delta 切片
+ * 残留在请求详情面板 / mergeLogFiles 落盘产物中。
+ * 返回 true 表示已补偿（messages 为一致全量），false 表示需后续 checkpoint 补偿。
+ */
+function _markStaleEntry(entry, accumulated) {
+  entry._staleReorder = true;
+  const total = entry._totalMessageCount;
+  if (Array.isArray(entry.body?.messages) && total && accumulated.length >= total) {
+    entry.body.messages = accumulated.slice(0, total);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * delta 拼接后的完整性校验（重建长度 vs `_totalMessageCount`）。
+ * - accumulated 超长（典型：旧日志无 _seq 时的倒置——checkpoint 先落、stale delta 后落）：
+ *   slice 回 _totalMessageCount，并把 `st.poisoned` 置位。会话单调增长时该前缀 = 最新
+ *   checkpoint 真值；但**缩短型 checkpoint（/compact、/clear）跨倒置时前缀是旧会话内容**
+ *   （局部不可判定），因此基底必须视为不可信：调用方对后续 delta 一律标 _reconstructBroken
+ *   冻结，直到下一 checkpoint 重置——否则毒化基底上长度全部自洽，永不自愈。
+ *   本条目同时标 _staleReorder 让 merge 跳过。
+ * - accumulated 不足（typ.: 倒置中先落盘的快 delta）：仅在基线已建立时标 _reconstructBroken
+ *   ——server 重启 / 客户端 reconstructor 重建后的冷启动 delta 流没有基线，维持现状透传，
+ *   否则会把正常增量全部误标导致视图冻结。
+ * @param {{baselineSeen: boolean, poisoned: boolean}} st - 重建器完整性状态（原地更新）
+ * 返回（可能被 slice 修复过的）accumulated。
+ */
+function _integrityCheck(entry, accumulated, st) {
+  const total = entry._totalMessageCount;
+  if (!total) return accumulated;
+  if (accumulated.length > total) {
+    accumulated = accumulated.slice(0, total);
+    entry.body.messages = accumulated;
+    entry._staleReorder = true;
+    st.poisoned = true;
+  } else if (accumulated.length < total && st.baselineSeen) {
+    entry._reconstructBroken = true;
+  }
+  return accumulated;
+}
+
+/**
+ * 单条条目的重建状态机核心 — 三个 API（批量/段级/增量）共用。
+ * KEEP IN SYNC: server/interceptor.js `_seq` 写入点。
+ *
+ * 调用方约定：inProgress 条目必须在调用前自行处理（批量/段级跳过、增量重建副本不进
+ * 累积态）——placeholder 与 completed 共享同一 _seq，先于守卫排除防 completed 被
+ * "同 seq 重发"规则误吞。
+ *
+ * 经过本函数后 entry.body.messages 的三种终态：
+ * 1. 全量重建 —— 正常 delta 拼接 / checkpoint 原样 / replay 幂等回写；
+ * 2. 真值前缀 —— stale 就地补偿、超长 slice 修复（_staleReorder 置位，merge 跳过）；
+ * 3. 裸 delta 切片待补偿 —— stale 就地补偿失败 / poisoned 冻结（_staleReorder 或
+ *    _reconstructBroken 置位）：由第二遍 checkpoint 补偿回填，无第二遍的路径靠
+ *    isMergeBlockedEntry 阻断 merge、mergeLogFiles 丢弃兜底。
+ *
+ * @param {object} entry - 单条日志条目（原地修改）
+ * @param {{accumulated: Array, intState: {baselineSeen: boolean, poisoned: boolean},
+ *          seqState: {lastSeq: number, lastEpoch: string|null}}} ctx
+ *   重建上下文；ctx.accumulated 由本函数重新赋值（调用方读 ctx 而非局部变量）。
+ * @returns {boolean} true = 该条目断裂、需后续 checkpoint 第二遍补偿
+ *   （批量/段级路径据此收集索引；增量路径无第二遍、忽略返回值）
+ */
+function _stepReconstruct(entry, ctx) {
+  if (!isDeltaEntry(entry)) {
+    // 非 delta 条目（旧格式 / teammate）：如果是 mainAgent 旧格式，重置累积状态
+    if (_isMainAgentFullEntry(entry)) {
+      ctx.accumulated = [...entry.body.messages];
+      ctx.intState.baselineSeen = true;
+      ctx.intState.poisoned = false;
+    }
+    return false;
+  }
+
+  const msgs = entry.body?.messages;
+  if (!Array.isArray(msgs)) return false;
+
+  // 完成序倒置守卫
+  const verdict = _seqGuardCheck(entry, ctx.seqState);
+  if (verdict === 'replay') {
+    // 同条重发（日志轮转 race 等）：幂等回写全量（不重复累积）
+    entry.body.messages = ctx.accumulated;
+    if (entry._totalMessageCount && ctx.accumulated.length !== entry._totalMessageCount) {
+      entry._staleReorder = true;
+      return true;
+    }
+    return false;
+  }
+  if (verdict === 'stale') {
+    // 就地补偿失败 → 交给后续 checkpoint 反向修复
+    return !_markStaleEntry(entry, ctx.accumulated);
+  }
+
+  if (isCheckpointEntry(entry)) {
+    // checkpoint：用当前 messages 重置累积状态（毒化态随之解除）
+    ctx.accumulated = [...msgs];
+    ctx.intState.baselineSeen = true;
+    ctx.intState.poisoned = false;
+  } else if (ctx.intState.poisoned) {
+    // 基底不可信（缩短型 checkpoint 跨倒置被 slice 修复过）：冻结到下一 checkpoint，
+    // 交给补偿用后续 checkpoint 回填真值
+    entry._reconstructBroken = true;
+    return true;
+  } else {
+    // delta：拼接到累积数组，挂载重建后的完整 messages
+    ctx.accumulated = [...ctx.accumulated, ...msgs];
+    entry.body.messages = ctx.accumulated;
+    ctx.accumulated = _integrityCheck(entry, ctx.accumulated, ctx.intState);
+    if (entry._staleReorder || entry._reconstructBroken ||
+        (entry._totalMessageCount && ctx.accumulated.length !== entry._totalMessageCount)) {
+      return true; // 含 slice 修复条目：后续 checkpoint 存在时回填为真值前缀
+    }
+  }
+  return false;
 }
 
 /**
@@ -48,39 +214,19 @@ export function isDeltaEntry(entry) {
  */
 export function reconstructEntries(entries) {
   // 第一遍：正向重建
-  let accumulated = []; // mainAgent 累积 messages
-  const broken = [];    // 记录重建失败的条目索引（用于第二遍补偿）
+  const ctx = {
+    accumulated: [],
+    intState: { baselineSeen: false, poisoned: false },
+    seqState: { lastSeq: 0, lastEpoch: null },
+  };
+  const broken = []; // 记录重建失败的条目索引（用于第二遍补偿）
 
   for (let i = 0; i < entries.length; i++) {
     const entry = entries[i];
     // 跳过 inProgress 条目：孤立的 inProgress（请求超时未完成）在 dedup 后残留，
     // 其 delta 与后续 completed 条目重复，双重累积会导致 accumulated 偏移
-    // （与 createIncrementalReconstructor line 209 保持一致）
     if (entry.inProgress) continue;
-    if (!isDeltaEntry(entry)) {
-      // 非 delta 条目（旧格式 / teammate）：如果是 mainAgent 旧格式，重置累积状态
-      if (entry.mainAgent && Array.isArray(entry.body?.messages)) {
-        accumulated = [...entry.body.messages];
-      }
-      continue;
-    }
-
-    // delta 条目处理
-    const msgs = entry.body?.messages;
-    if (!Array.isArray(msgs)) continue;
-
-    if (isCheckpointEntry(entry)) {
-      // checkpoint：用当前 messages 重置累积状态
-      accumulated = [...msgs];
-    } else {
-      // delta：拼接到累积数组
-      accumulated = [...accumulated, ...msgs];
-      // 挂载重建后的完整 messages（checkpoint/旧格式条目保持不变）
-      entry.body.messages = accumulated;
-      if (entry._totalMessageCount && accumulated.length !== entry._totalMessageCount) {
-        broken.push(i);
-      }
-    }
+    if (_stepReconstruct(entry, ctx)) broken.push(i);
   }
 
   // 第二遍：补偿修复 — 用后续最近的 checkpoint 回填断裂的条目
@@ -91,32 +237,48 @@ export function reconstructEntries(entries) {
   return entries;
 }
 
+/**
+ * 用候选全量条目（checkpoint/旧格式，排除 teammate）补偿一条断裂条目。
+ * 内容已是真值前缀，清除标记让批量 merge / mergeLogFiles 正常消费。
+ * @returns {boolean} true = 已补偿
+ */
+function _tryRepairFromCandidate(brokenEntry, expectedCount, candidate) {
+  if (!candidate.mainAgent || candidate.teammate || !Array.isArray(candidate.body?.messages)) return false;
+  const candidateMsgs = candidate.body.messages;
+  const candidateTotal = candidate._totalMessageCount || candidateMsgs.length;
+  const isFullEntry = !candidate._deltaFormat || isCheckpointEntry(candidate);
+  if (isFullEntry && candidateTotal >= expectedCount) {
+    brokenEntry.body.messages = candidateMsgs.slice(0, expectedCount);
+    delete brokenEntry._staleReorder;
+    delete brokenEntry._reconstructBroken;
+    return true;
+  }
+  return false;
+}
+
 /**
  * 补偿修复：对断裂的 delta 条目，从后续最近的 checkpoint 中提取完整 messages 回填。
  * checkpoint 包含截至该点的完整历史，可以据此反推之前条目的 messages。
+ * @param {object|null} [nextCheckpoint] - 数组内向后查找失败时的额外候选
+ *   （段级调用方传入段外的下一 checkpoint，最后一段可为 null）
  */
-function _compensateBrokenEntries(entries, brokenIndices) {
+function _compensateBrokenEntries(entries, brokenIndices, nextCheckpoint = null) {
   for (const brokenIdx of brokenIndices) {
     const brokenEntry = entries[brokenIdx];
     const expectedCount = brokenEntry._totalMessageCount;
     if (!expectedCount) continue;
 
-    // 向后查找最近的 checkpoint 或旧格式全量条目
+    // 向后查找最近的 checkpoint 或旧格式全量条目（排除 teammate）
+    let repaired = false;
     for (let j = brokenIdx + 1; j < entries.length; j++) {
-      const candidate = entries[j];
-      if (!candidate.mainAgent || !Array.isArray(candidate.body?.messages)) continue;
-
-      const candidateMsgs = candidate.body.messages;
-      const candidateTotal = candidate._totalMessageCount || candidateMsgs.length;
-
-      // 候选条目必须是 checkpoint/旧格式且包含足够的 messages
-      const isFullEntry = !candidate._deltaFormat || isCheckpointEntry(candidate);
-      if (isFullEntry && candidateTotal >= expectedCount) {
-        // 从完整 messages 中截取前 expectedCount 条作为补偿
-        brokenEntry.body.messages = candidateMsgs.slice(0, expectedCount);
+      if (_tryRepairFromCandidate(brokenEntry, expectedCount, entries[j])) {
+        repaired = true;
         break;
       }
     }
+    if (!repaired && nextCheckpoint) {
+      _tryRepairFromCandidate(brokenEntry, expectedCount, nextCheckpoint);
+    }
   }
 }
 
@@ -127,66 +289,29 @@ function _compensateBrokenEntries(entries, brokenIndices) {
  *
  * @param {Array} segment - 段内条目数组（段首应为 checkpoint/旧格式条目）
  * @param {object|null} nextCheckpoint - 下一个 checkpoint 条目（用于反向修复），最后一段可为 null
+ * @param {{lastSeq: number, lastEpoch: string|null}} [sharedSeqState] - 跨段共享的 seq 守卫状态。
+ *   流式分段调用方（log-stream）必须按文件维度传入同一对象：乱序的 stale checkpoint 自己就是
+ *   段边界，若每段独立建 seqState 它会以 fresh 基线被判 'ok' 漏检。不传时退化为段内独立状态
+ *   （仅适合单段调用）。
  * @returns {Array} 重建后的段条目数组（原地修改）
  */
-export function reconstructSegment(segment, nextCheckpoint) {
-  let accumulated = [];
+export function reconstructSegment(segment, nextCheckpoint, sharedSeqState) {
+  const ctx = {
+    accumulated: [],
+    intState: { baselineSeen: false, poisoned: false },
+    seqState: sharedSeqState || { lastSeq: 0, lastEpoch: null },
+  };
   const broken = [];
 
   for (let i = 0; i < segment.length; i++) {
     const entry = segment[i];
     if (entry.inProgress) continue;
-    if (!isDeltaEntry(entry)) {
-      if (entry.mainAgent && Array.isArray(entry.body?.messages)) {
-        accumulated = [...entry.body.messages];
-      }
-      continue;
-    }
-
-    const msgs = entry.body?.messages;
-    if (!Array.isArray(msgs)) continue;
-
-    if (isCheckpointEntry(entry)) {
-      accumulated = [...msgs];
-    } else {
-      accumulated = [...accumulated, ...msgs];
-      entry.body.messages = accumulated;
-      if (entry._totalMessageCount && accumulated.length !== entry._totalMessageCount) {
-        broken.push(i);
-      }
-    }
+    if (_stepReconstruct(entry, ctx)) broken.push(i);
   }
 
   // 补偿修复：先在段内向后查找，再用 nextCheckpoint
   if (broken.length > 0) {
-    for (const brokenIdx of broken) {
-      const brokenEntry = segment[brokenIdx];
-      const expectedCount = brokenEntry._totalMessageCount;
-      if (!expectedCount) continue;
-
-      let repaired = false;
-      // 段内向后查找
-      for (let j = brokenIdx + 1; j < segment.length; j++) {
-        const candidate = segment[j];
-        if (!candidate.mainAgent || !Array.isArray(candidate.body?.messages)) continue;
-        const candidateMsgs = candidate.body.messages;
-        const candidateTotal = candidate._totalMessageCount || candidateMsgs.length;
-        const isFullEntry = !candidate._deltaFormat || isCheckpointEntry(candidate);
-        if (isFullEntry && candidateTotal >= expectedCount) {
-          brokenEntry.body.messages = candidateMsgs.slice(0, expectedCount);
-          repaired = true;
-          break;
-        }
-      }
-      // 段内未找到，用 nextCheckpoint 修复
-      if (!repaired && nextCheckpoint) {
-        const cpMsgs = nextCheckpoint.body?.messages;
-        const cpTotal = nextCheckpoint._totalMessageCount || cpMsgs?.length || 0;
-        if (Array.isArray(cpMsgs) && cpTotal >= expectedCount) {
-          brokenEntry.body.messages = cpMsgs.slice(0, expectedCount);
-        }
-      }
-    }
+    _compensateBrokenEntries(segment, broken, nextCheckpoint);
   }
 
   return segment;
@@ -196,55 +321,49 @@ export function reconstructSegment(segment, nextCheckpoint) {
  * 创建有状态的增量重建器 — 用于 watcher 逐条重建。
  * 每次调用 reconstruct(entry) 处理一条新条目。
  *
- * @returns {{ reconstruct: (entry: object) => object }}
+ * @returns {{ reconstruct: (entry: object) => object, reset: () => void }}
  */
 export function createIncrementalReconstructor() {
-  let accumulated = []; // mainAgent 累积 messages
+  // accumulated：mainAgent 累积 messages；
+  // baselineSeen：自创建/reset 后是否见过 checkpoint/旧格式全量条目；
+  // poisoned：accumulated 被 slice 修复过（基底不可信），冻结到下一 checkpoint
+  const ctx = {
+    accumulated: [],
+    intState: { baselineSeen: false, poisoned: false },
+    seqState: { lastSeq: 0, lastEpoch: null },
+  };
 
   return {
     /**
      * 重建单条条目。
      * - 非 delta 条目：如果是 mainAgent 旧格式，更新累积状态，原样返回
+     * - 乱序条目（_seq 守卫）：不进累积态，标 _staleReorder 后返回
      * - checkpoint：重置累积状态，原样返回
-     * - delta：拼接重建，修改 body.messages 后返回
+     * - delta：拼接重建 + 完整性校验，修改 body.messages 后返回
      *
      * @param {object} entry - 单条日志条目
      * @returns {object} 重建后的条目（同一引用）
      */
     reconstruct(entry) {
-      // inProgress 条目：用 accumulated 副本重建 messages，但不更新 accumulated 本身。
+      // inProgress 条目：用 accumulated 副本重建 messages，但不更新 accumulated 本身，
+      // 也不参与 seq 守卫（placeholder 与 completed 共享同一 _seq，先于守卫跳过，
+      // 防 completed 被"同 seq 重发"规则误吞）。
       // 这样客户端收到完整 messages（避免 delta 闪烁），
       // 而后续 completed 条目仍能基于正确的 accumulated 重建。
       if (entry.inProgress) {
         if (isDeltaEntry(entry) && !isCheckpointEntry(entry)) {
           const msgs = entry.body?.messages;
           if (Array.isArray(msgs)) {
-            entry.body.messages = [...accumulated, ...msgs];
+            entry.body.messages = [...ctx.accumulated, ...msgs];
           }
         }
         return entry;
       }
 
-      if (!isDeltaEntry(entry)) {
-        // 非 delta 条目：如果是 mainAgent 旧格式，更新累积状态
-        if (entry.mainAgent && Array.isArray(entry.body?.messages)) {
-          accumulated = [...entry.body.messages];
-        }
-        return entry;
-      }
-
-      const msgs = entry.body?.messages;
-      if (!Array.isArray(msgs)) return entry;
-
-      if (isCheckpointEntry(entry)) {
-        // checkpoint：重置累积状态
-        accumulated = [...msgs];
-      } else {
-        // delta：拼接
-        accumulated = [...accumulated, ...msgs];
-        entry.body.messages = accumulated;
-      }
-
+      // 忽略 needs-compensation 返回值：增量路径是实时流、无法回看后续 checkpoint
+      // 做第二遍补偿。stale 仅靠 _markStaleEntry 就地回填；未补偿条目带
+      // _staleReorder/_reconstructBroken 标记，由客户端 isMergeBlockedEntry 阻断 merge。
+      _stepReconstruct(entry, ctx);
       return entry;
     },
 
@@ -252,8 +371,11 @@ export function createIncrementalReconstructor() {
      * 重置累积状态（用于 full_reload 等场景）。
      */
     reset() {
-      accumulated = [];
+      ctx.accumulated = [];
+      ctx.intState.baselineSeen = false;
+      ctx.intState.poisoned = false;
+      ctx.seqState.lastSeq = 0;
+      ctx.seqState.lastEpoch = null;
     }
   };
 }
-

package/server/lib/im-log-watcher.js

@@ -0,0 +1,94 @@
+// im-log-watcher.js — 监听 IM worker 日志目录，写入即推 SSE，让「对话记录」弹窗零滞后刷新。
+//
+// 背景：IM worker 是独立进程、独立端口（见 im-process-manager.buildChildEnv，CCV_START_PORT=7050+）。
+// 它的 Claude 子进程 turn 结束时把 turn_end POST 到 worker 自己的端口，主 web 服务收不到。
+// 但 IM worker 的日志写在共享文件系统 ~/.claude/cc-viewer/IM_<id>/*.jsonl，主服务能直接 watch。
+// 于是：主服务 fs.watch 这些目录，助手回复落盘即广播 `im_log_update` SSE，前端据此自动重拉。
+//
+// 设计：
+//  - ensure(platformId) 幂等、惰性：「对话记录」弹窗首次请求 /api/im/:platform/logs 时才开始 watch，
+//    避免为从未打开的平台占 watcher（平台数 ≤ 4，成本可忽略）。dir 不存在时先 mkdir 再 watch。
+//  - 每个目录的 change 事件按 debounceMs 合并（fs.watch 一次写会抖多次），只在 .jsonl（排除 *_temp.jsonl）
+//    变化时触发——与 findRecentLog 的「最新真实日志」语义对齐，过滤流式临时文件噪声。
+//  - watchImpl / mkdirImpl 可注入，便于确定性单测（无需真实 FS 时序）。
+
+import { watch as fsWatch, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+// fs.watch 一次文件写会抖多次（macOS/Linux 尤甚），通常 50~300ms 内合并；选 250ms 平衡实时性与稳定性。
+const DEFAULT_DEBOUNCE_MS = 250;
+// platformId 纵深防御：上游 platformOf() 已用白名单挡住非法平台，这里再独立校验一次，
+// 杜绝被污染的 id 经 `IM_${id}` 拼进路径造成穿越（与路由正则 /^[a-z0-9_-]+$/ 同集）。
+const PLATFORM_ID_RE = /^[a-z0-9_-]+$/;
+
+export function createImLogWatcher({ getLogDir, onChange, debounceMs = DEFAULT_DEBOUNCE_MS, watchImpl, mkdirImpl, existsImpl } = {}) {
+  const _watch = watchImpl || fsWatch;
+  const _mkdir = mkdirImpl || ((d) => { try { mkdirSync(d, { recursive: true }); } catch { /* ignore */ } });
+  const _exists = existsImpl || existsSync;
+  const _onChange = typeof onChange === 'function' ? onChange : () => {};
+  const _getLogDir = typeof getLogDir === 'function' ? getLogDir : () => '';
+
+  const watchers = new Map(); // platformId -> { w: FSWatcher, dir: string } —— 连同所属目录登记，便于 LOG_DIR 切换检测
+  const timers = new Map();   // platformId -> timeout
+  let _disposed = false;
+
+  function _schedule(platformId) {
+    const existing = timers.get(platformId);
+    if (existing) clearTimeout(existing);
+    timers.set(platformId, setTimeout(() => {
+      timers.delete(platformId);
+      if (_disposed) return;
+      try { _onChange(platformId); } catch { /* never propagate to fs.watch */ }
+    }, debounceMs));
+  }
+
+  // 只认真实日志的 .jsonl 写入；filename 为 null（部分平台）时保守放行（让前端重拉，pure refresh 无副作用）。
+  function _relevant(filename) {
+    if (!filename) return true;
+    const name = String(filename);
+    if (!name.endsWith('.jsonl')) return false;
+    if (name.endsWith('_temp.jsonl')) return false;
+    return true;
+  }
+
+  function ensure(platformId) {
+    if (_disposed || !platformId) return;
+    if (!PLATFORM_ID_RE.test(platformId)) return; // 纵深防御：非白名单字符不放行（防 `IM_${id}` 路径穿越）
+    const logDir = _getLogDir();
+    if (!logDir) return;
+    const dir = join(logDir, `IM_${platformId}`);
+    const reg = watchers.get(platformId);
+    if (reg) {
+      // 幂等仅当「目录路径未变且仍存在」时成立；否则关旧重建：
+      //  - reg.dir !== dir：LOG_DIR 运行时切换（切项目），旧 watcher 还盯着旧目录，新目录无人监听；
+      //  - !exists(dir)：目录被删（某些平台 fs.watch 删目录不报 error，留下永不恢复的幽灵监听）。
+      if (reg.dir === dir && _exists(dir)) return;
+      try { reg.w.close(); } catch { /* ignore */ }
+      watchers.delete(platformId);
+    }
+    _mkdir(dir);
+    let w;
+    try {
+      w = _watch(dir, (_eventType, filename) => {
+        if (_relevant(filename)) _schedule(platformId);
+      });
+    } catch { return; }
+    // watcher 出错（目录被删等）→ 关闭并撤销登记，下次 ensure 可重建。
+    if (w && typeof w.on === 'function') {
+      w.on('error', () => { try { w.close(); } catch { /* ignore */ } watchers.delete(platformId); });
+    }
+    watchers.set(platformId, { w, dir });
+  }
+
+  function dispose() {
+    _disposed = true;
+    for (const t of timers.values()) clearTimeout(t);
+    timers.clear();
+    for (const reg of watchers.values()) { try { reg.w.close(); } catch { /* ignore */ } }
+    watchers.clear();
+  }
+
+  return { ensure, dispose, _watchers: watchers };
+}
+
+export default createImLogWatcher;

package/server/lib/log-management.js

@@ -159,10 +159,29 @@ export async function mergeLogFiles(logDir, files) {
     await streamReconstructedEntriesAsync(filePath, async (segment) => {
       let chunk = '';
       for (const entry of segment) {
+        // 乱序/断裂条目若未被补偿回填（messages 仍是裸 delta 切片），丢弃不写：
+        // 剥除 _deltaFormat 后它会伪装成旧格式全量条目，未来读取时把累积状态
+        // 重置成几条切片，比丢掉这条（内容已被更新条目取代）破坏大得多
+        if ((entry._staleReorder || entry._reconstructBroken) &&
+            entry._totalMessageCount && Array.isArray(entry.body?.messages) &&
+            entry.body.messages.length !== entry._totalMessageCount) {
+          continue;
+        }
         delete entry._deltaFormat;
         delete entry._totalMessageCount;
         delete entry._conversationId;
         delete entry._isCheckpoint;
+        // 信号对的另一半同剥：_isCheckpoint 已剥后，孤立的 _inPlaceReplaceDetected
+        // 永远无法触发双信号短路（applyInPlaceLastMsgReplace 要求两者同真），留着
+        // 只会误导未来读取；_eagerSnapshot 为已废弃字段（写入点已删），仅历史日志残留
+        delete entry._inPlaceReplaceDetected;
+        delete entry._eagerSnapshot;
+        // 完成序倒置守卫的内部字段不落盘：合并产物是已重建的全量条目，
+        // seq 序号与 stale/broken 标记只在重建期有意义，泄漏会让后续读取误判
+        delete entry._seq;
+        delete entry._seqEpoch;
+        delete entry._staleReorder;
+        delete entry._reconstructBroken;
         chunk += JSON.stringify(entry) + '\n---\n';
       }
       await appendFile(tmpPath, chunk);