cx-viewer 1.0.2 → 1.0.4

package/src/components/chat/controllers/permissionController.js

@@ -0,0 +1,84 @@
+// 权限审批队列控制器（从 ChatView 抽出，仿 askFlowController 的 host-adapter 模式）。
+//
+// 处理 ToolApprovalPanel 的 allow / allowSession / deny 三个决策：hook 路径走 ws 发
+// perm-hook-answer，PTY 路径走选项点击；每个决策后出队下一个 pending。纯逻辑、可单测。
+// state（pendingPermission / permissionQueue）仍留 ChatView.state，经 host 读写。
+//
+// host 接口：
+//   getState()          → 读 pendingPermission / permissionQueue
+//   setState(updater)   → 转发宿主 this.setState（支持 functional updater）
+//   ws()                → 宿主 this._inputWs（{ readyState, send }）
+//   promptOptionClick(n)→ 宿主 this.handlePromptOptionClick（PTY 路径用；该方法属 PTY 簇留宿主）
+
+export class PermissionController {
+  constructor(host) {
+    this.host = host;
+  }
+
+  shiftQueue = () => {
+    this.host.setState(state => {
+      const next = state.permissionQueue[0] || null;
+      return { pendingPermission: next, permissionQueue: state.permissionQueue.slice(1) };
+    });
+  };
+
+  allow = (id) => {
+    const perm = this.host.getState().pendingPermission;
+    if (perm?.source === 'pty' && perm.ptyPrompt) {
+      const optNum = this._findPtyOptionNumber(perm.ptyPrompt, 'allow');
+      this.host.promptOptionClick(optNum);
+      this.shiftQueue();
+      return;
+    }
+    const ws = this.host.ws();
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ type: 'perm-hook-answer', id, decision: 'allow' }));
+    }
+    this.shiftQueue();
+  };
+
+  allowSession = (id) => {
+    const perm = this.host.getState().pendingPermission;
+    if (perm?.source === 'pty' && perm.ptyPrompt) {
+      const optNum = this._findPtyOptionNumber(perm.ptyPrompt, 'allowSession');
+      this.host.promptOptionClick(optNum);
+      this.shiftQueue();
+      return;
+    }
+    const ws = this.host.ws();
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ type: 'perm-hook-answer', id, decision: 'allow', allowSession: true }));
+    }
+    this.shiftQueue();
+  };
+
+  deny = (id) => {
+    const perm = this.host.getState().pendingPermission;
+    if (perm?.source === 'pty' && perm.ptyPrompt) {
+      const optNum = this._findPtyOptionNumber(perm.ptyPrompt, 'deny');
+      this.host.promptOptionClick(optNum);
+      this.shiftQueue();
+      return;
+    }
+    const ws = this.host.ws();
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ type: 'perm-hook-answer', id, decision: 'deny' }));
+    }
+    this.shiftQueue();
+  };
+
+  _findPtyOptionNumber(prompt, decision) {
+    const options = prompt?.options || [];
+    if (decision === 'allow') {
+      const opt = options.find(o => /^yes$/i.test(o.text.trim()))
+        || options.find(o => /^yes/i.test(o.text) && !/allow|session|project/i.test(o.text));
+      return opt?.number || 1;
+    }
+    if (decision === 'allowSession') {
+      const opt = options.find(o => /allow.*(?:project|session|during)/i.test(o.text));
+      return opt?.number || 2;
+    }
+    const opt = options.find(o => /^no$/i.test(o.text.trim()) || /^no[^a-z]/i.test(o.text));
+    return opt?.number || options.length;
+  }
+}

package/src/components/chat/controllers/ptyPromptController.js

@@ -0,0 +1,166 @@
+/**
+ * PTY prompt-detection controller for ChatView.
+ *
+ * Host-adapter pattern (see askFlowController.js for the reference contract):
+ * a plain dependency-injected class. React state (ptyPrompt, ptyPromptHistory,
+ * pendingPermission, pendingPtyPlan) stays in ChatView.state and is only
+ * touched through the host; the byte-stream machinery that used to live as
+ * ChatView instance fields moves onto this controller as one unit:
+ *   - the 4KB rolling _buffer of ANSI-stripped PTY output,
+ *   - _ansiCarry (a trailing half-CSI/OSC sequence carried into the next
+ *     chunk so stripping always runs on complete sequences; deliberately NOT
+ *     reset by clearPrompt — it is byte-stream-level state),
+ *   - the 200ms detection debounce timer,
+ *   - _current (the synchronous mirror of state.ptyPrompt, avoiding stale
+ *     closure reads — exposed to AskFlowController via ChatView's host),
+ *
+ * No antd/i18n/JSX imports — statically loadable under node:test.
+ *
+ * host interface (injected by ChatView at construction):
+ *  - getState()               -> live this.state
+ *  - setState(update, cb?)    -> this.setState (functional updaters passed through)
+ *  - isAskSubmitting()        -> this._askFlow._askSubmitting (don't dismiss during ask submit)
+ *  - scrollToBottom()         -> this.scrollToBottom()
+ *  - now()                    -> Date.now() (injectable for dedupe-window tests)
+ */
+import { stripAnsi, splitTrailingAnsiCarry, detectPromptInBuffer, isFalsePositiveQuestion } from '../../../utils/promptDetect.js';
+import { isPlanApprovalPrompt, isDangerousOperationPrompt, parseToolInfoFromBuffer } from '../../../utils/promptClassifier.js';
+
+export const PTY_BUFFER_MAX = 4096;
+export const DETECT_DEBOUNCE_MS = 200;
+export const PTY_HISTORY_CAP = 200;
+
+export class PtyPromptController {
+  constructor(host) {
+    this.host = host;
+    this._buffer = '';
+    this._ansiCarry = '';
+    this._debounceTimer = null;
+    this._current = null; // synchronous mirror of state.ptyPrompt
+  }
+
+  getCurrent() { return this._current; }
+  setCurrent(v) { this._current = v; }
+  getBuffer() { return this._buffer; }
+
+  clearDebounce() {
+    if (this._debounceTimer) { clearTimeout(this._debounceTimer); this._debounceTimer = null; }
+  }
+
+  /** Append a PTY output chunk and (debounced) re-run prompt detection. */
+  appendData(raw) {
+    // ANSI sequences can be cut mid-way by PTY chunking: a trailing unfinished
+    // CSI/OSC is carried and re-joined with the next chunk before stripping.
+    const [safe, carry] = splitTrailingAnsiCarry(this._ansiCarry + raw);
+    this._ansiCarry = carry;
+    this._buffer += stripAnsi(safe);
+    if (this._buffer.length > PTY_BUFFER_MAX) {
+      this._buffer = this._buffer.slice(-PTY_BUFFER_MAX);
+    }
+    this.clearDebounce();
+    this._debounceTimer = setTimeout(() => this._detectPrompt(), DETECT_DEBOUNCE_MS);
+  }
+
+  /** Reset after a prompt answer was submitted: drop the buffer and any armed detection. */
+  resetBufferAfterSubmit() {
+    this._buffer = '';
+    this.clearDebounce();
+  }
+
+  /** Full prompt clear (terminal exit etc.). The ANSI carry survives on purpose. */
+  clearPrompt() {
+    this._buffer = '';
+    this._current = null;
+    this.clearDebounce();
+    if (this.host.getState().ptyPrompt) {
+      this.host.setState({ ptyPrompt: null });
+    }
+  }
+
+  dispose() {
+    this.clearDebounce();
+  }
+
+  _detectPrompt() {
+    const state = this.host.getState();
+    const buf = this._buffer.trimEnd();
+
+    // Linear line-scan parser (see utils/promptDetect.js).
+    const detected = detectPromptInBuffer(buf);
+    const question = detected ? detected.question : null;
+    const options = detected ? detected.options : null;
+
+    if (question && options) {
+      // Skip false positives (file paths, status bars, timing output). This is
+      // a hard return, deliberately distinct from the dismiss branch below.
+      if (isFalsePositiveQuestion(question)) return;
+
+      const prev = state.ptyPrompt;
+      const prompt = { question, options };
+
+      // SubAgent permission prompt: route to ToolApprovalPanel instead of the
+      // danger-approval bubble when hooks don't fire (subAgent tool calls
+      // bypass PreToolUse hooks).
+      if (isDangerousOperationPrompt(prompt) && !state.pendingPermission) {
+        const toolInfo = parseToolInfoFromBuffer(this._buffer, question, options);
+        const id = `pty_${this.host.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        this._current = prompt;
+        this.host.setState(s => {
+          const history = s.ptyPromptHistory.slice();
+          // Mark as 'pty-routed' (not 'active') so renderDangerApproval is not triggered.
+          history.push({ ...prompt, status: 'pty-routed', selectedNumber: null, timestamp: new Date(this.host.now()).toISOString() });
+          if (history.length > PTY_HISTORY_CAP) history.splice(0, history.length - PTY_HISTORY_CAP);
+          return {
+            pendingPermission: { id, toolName: toolInfo.toolName, input: toolInfo.input, source: 'pty', ptyPrompt: prompt },
+            ptyPromptHistory: history,
+          };
+        });
+        this.host.scrollToBottom();
+        return;
+      }
+
+      // Same question: only the options changed (cursor moved) — update in
+      // place, no new history entry.
+      if (prev && prev.question === question) {
+        this._current = prompt;
+        this.host.setState({ ptyPrompt: prompt });
+      } else {
+        // New prompt: mark the previous active entry dismissed first.
+        this._current = prompt;
+        this.host.setState(s => {
+          const history = s.ptyPromptHistory.slice();
+          if (s.ptyPrompt) {
+            const last = history[history.length - 1];
+            if (last && last.status === 'active') {
+              history[history.length - 1] = { ...last, status: 'dismissed' };
+            }
+          }
+          const ts = new Date(this.host.now()).toISOString();
+          history.push({ ...prompt, status: 'active', selectedNumber: null, timestamp: ts });
+          if (history.length > PTY_HISTORY_CAP) history.splice(0, history.length - PTY_HISTORY_CAP);
+          return { ptyPrompt: prompt, ptyPromptHistory: history };
+        });
+        this.host.scrollToBottom();
+      }
+      return;
+    }
+    // No match — dismiss the active prompt, EXCEPT plan-approval and dangerous
+    // prompts (they stay active until explicitly answered) and while an
+    // request_user_input submission is in flight.
+    if (state.ptyPrompt) {
+      if (isPlanApprovalPrompt(state.ptyPrompt)) return;
+      if (isDangerousOperationPrompt(state.ptyPrompt)) return;
+      if (this.host.isAskSubmitting()) return;
+      this._current = null;
+      this.host.setState(s => {
+        const history = s.ptyPromptHistory.slice();
+        const last = history[history.length - 1];
+        if (last && last.status === 'active') {
+          history[history.length - 1] = { ...last, status: 'dismissed' };
+        }
+        // Prompt vanished with no match: also defensively clear pendingPtyPlan.
+        return { ptyPrompt: null, ptyPromptHistory: history, pendingPtyPlan: null };
+      });
+    }
+  }
+}

package/src/components/chat/controllers/scrollHighlightController.js

@@ -0,0 +1,50 @@
+// 跳转高亮的「滚动即褪色」控制器（从 ChatView 抽出，仿 stickyBottomController 的事件+timer+dispose 模式）。
+//
+// 跳转到某条消息后高亮它；用户一滚动就开始褪色并停止监听。逻辑与宿主组件解耦，可单测。
+// host 接口：
+//   getScrollContainer() → 当前滚动容器 DOM（包宿主的 _getScrollContainer，含 virtuoso/desktop 分支）
+//   setState(updater)    → 转发宿主 this.setState
+
+export class ScrollHighlightController {
+  constructor(host) {
+    this.host = host;
+    this._delayTimer = null;
+    this._clearTimer = null;
+    this._boundEl = null;
+    this._onScroll = null;
+  }
+
+  bind() {
+    this.dispose();
+    // 延迟绑定：等 smooth scroll 动画完成后再监听，避免动画帧触发提前 fading。
+    this._delayTimer = setTimeout(() => {
+      const container = this.host.getScrollContainer();
+      if (!container) return;
+      this._boundEl = container;
+      this._onScroll = () => {
+        this.host.setState({ highlightFading: true });
+        this._clearTimer = setTimeout(() => {
+          this.host.setState({ highlightTs: null, highlightFading: false, highlightVisibleIdx: -1 });
+        }, 2000);
+        this.dispose();
+      };
+      container.addEventListener('scroll', this._onScroll, { passive: true });
+    }, 500);
+  }
+
+  dispose() {
+    if (this._delayTimer) {
+      clearTimeout(this._delayTimer);
+      this._delayTimer = null;
+    }
+    if (this._clearTimer) {
+      clearTimeout(this._clearTimer);
+      this._clearTimer = null;
+    }
+    if (this._onScroll && this._boundEl) {
+      this._boundEl.removeEventListener('scroll', this._onScroll);
+      this._boundEl = null;
+      this._onScroll = null;
+    }
+  }
+}

package/src/components/chat/controllers/splitDragController.js

@@ -0,0 +1,135 @@
+/**
+ * Drag-resize controller for ChatView's terminal split and nav sidebar.
+ *
+ * Host-adapter pattern (see askFlowController.js for the reference contract):
+ * a plain dependency-injected class — React state stays in ChatView.state and
+ * is only touched through the host. No antd/i18n/JSX imports so the module is
+ * statically loadable under node:test (the geometry it delegates to lives in
+ * utils/splitDragCalc.js, which carries the unit tests).
+ *
+ * host interface (injected by ChatView at construction):
+ *  - getState()            -> live this.state (activeSnapLine/terminalWidth/sidebarWidth)
+ *  - setState(update)      -> this.setState
+ *  - getSplitRect()        -> innerSplitRef.current?.getBoundingClientRect() ?? null
+ *  - persistWidth(key, px) -> localStorage.setItem(key, String(px)) (guarded)
+ *
+ * The controller owns the drag lifecycle: the document mousemove/mouseup
+ * listeners and document.body cursor/userSelect, restored on mouseup AND on
+ * dispose() so an unmount mid-drag never leaves the page stuck in col-resize.
+ * Render reads dragTarget() to place the snap-line overlay.
+ */
+import {
+  computeTerminalSnapLines,
+  computeSidebarSnapLines,
+  clampTerminalWidth,
+  clampSidebarWidth,
+  findActiveSnapLine,
+} from '../../../utils/splitDragCalc.js';
+
+export const TERMINAL_WIDTH_STORAGE_KEY = 'cx-viewer-terminal-width';
+export const SIDEBAR_WIDTH_STORAGE_KEY = 'cx-viewer-sidebar-width';
+
+export class SplitDragController {
+  constructor(host) {
+    this.host = host;
+    this._resizing = false;
+    this._dragTarget = null; // 'terminal' | 'sidebar' | null
+    this._onMouseMove = null;
+    this._onMouseUp = null;
+  }
+
+  dragTarget() {
+    return this._dragTarget;
+  }
+
+  onTerminalHandleDown(e) {
+    e.preventDefault();
+    const rect = this.host.getSplitRect();
+    const snapLines = rect ? computeTerminalSnapLines(rect.width) : [];
+    this._beginDrag('terminal', snapLines, {
+      move: (ev, r) => {
+        const tw = clampTerminalWidth(r.right, ev.clientX, r.width);
+        // Terminal snap distance is measured against the cursor position
+        // within the container (the line marks where the divider sits).
+        const activeSnapLine = findActiveSnapLine(ev.clientX - r.left, snapLines);
+        this.host.setState({ terminalWidth: tw, activeSnapLine });
+      },
+      up: (state) => {
+        if (state.activeSnapLine) {
+          const newWidth = state.activeSnapLine.terminalPx;
+          this.host.persistWidth(TERMINAL_WIDTH_STORAGE_KEY, newWidth);
+          this.host.setState({ terminalWidth: newWidth, isDragging: false, activeSnapLine: null, snapLines: [], needsInitialSnap: false });
+        } else {
+          this.host.persistWidth(TERMINAL_WIDTH_STORAGE_KEY, state.terminalWidth);
+          this.host.setState({ isDragging: false, activeSnapLine: null, snapLines: [], needsInitialSnap: false });
+        }
+      },
+    });
+  }
+
+  onSidebarHandleDown(e) {
+    e.preventDefault();
+    const rect = this.host.getSplitRect();
+    const snapLines = rect ? computeSidebarSnapLines(rect.width) : [];
+    this._beginDrag('sidebar', snapLines, {
+      move: (ev, r) => {
+        const sw = clampSidebarWidth(ev.clientX, r.left, r.width);
+        // Sidebar snap distance is measured against the clamped width itself.
+        const activeSnapLine = findActiveSnapLine(sw, snapLines);
+        this.host.setState({ sidebarWidth: sw, activeSnapLine });
+      },
+      up: (state) => {
+        if (state.activeSnapLine) {
+          const newWidth = state.activeSnapLine.linePosition;
+          this.host.persistWidth(SIDEBAR_WIDTH_STORAGE_KEY, newWidth);
+          this.host.setState({ sidebarWidth: newWidth, isDragging: false, activeSnapLine: null, snapLines: [] });
+        } else {
+          this.host.persistWidth(SIDEBAR_WIDTH_STORAGE_KEY, state.sidebarWidth);
+          this.host.setState({ isDragging: false, activeSnapLine: null, snapLines: [] });
+        }
+      },
+    });
+  }
+
+  _beginDrag(target, snapLines, { move, up }) {
+    this._resizing = true;
+    this._dragTarget = target;
+    this.host.setState({ isDragging: true, snapLines });
+
+    this._onMouseMove = (ev) => {
+      if (!this._resizing) return;
+      const rect = this.host.getSplitRect();
+      if (!rect) return;
+      move(ev, rect);
+    };
+    this._onMouseUp = () => {
+      this._resizing = false;
+      this._dragTarget = null;
+      up(this.host.getState());
+      this._teardownListeners();
+    };
+    document.addEventListener('mousemove', this._onMouseMove);
+    document.addEventListener('mouseup', this._onMouseUp);
+    document.body.style.cursor = 'col-resize';
+    document.body.style.userSelect = 'none';
+  }
+
+  _teardownListeners() {
+    if (this._onMouseMove) document.removeEventListener('mousemove', this._onMouseMove);
+    if (this._onMouseUp) document.removeEventListener('mouseup', this._onMouseUp);
+    this._onMouseMove = null;
+    this._onMouseUp = null;
+    document.body.style.cursor = '';
+    document.body.style.userSelect = '';
+  }
+
+  dispose() {
+    // Unmount mid-drag: drop listeners and restore the page cursor without
+    // touching state (the component is going away).
+    if (this._resizing || this._onMouseMove) {
+      this._resizing = false;
+      this._dragTarget = null;
+      this._teardownListeners();
+    }
+  }
+}

package/src/components/chat/controllers/toolFileChangeController.js

@@ -0,0 +1,216 @@
+// 工具文件变更监听控制器（从 ChatView 抽出，纯逻辑、可单测）。
+//
+// 扫描 mainAgentSessions + requests 里的 tool_result，反查 tool_use 索引拿 toolName/input，
+// 判断是否有文件改动 → 防抖触发 FileExplorer / Git 面板 / 当前文件内容刷新。
+// 用 FIFO LRU 去重已处理的 tool_use_id。state 留 ChatView，经 host 读写。
+//
+// host 接口：
+//   getState()             → currentFile / fileExplorerOpen / gitChangesOpen
+//   setState(updater)      → 转发宿主 this.setState（refresh 计数用 functional updater）
+//   getProps()             → mainAgentSessions / requests
+//   getProjectDir()        → 宿主 this._projectDirCache（可能为 null）
+//   setPendingFileRefresh()→ 面板关闭期记 pending（宿主 _pendingFileRefresh = true，由开面板时消费）
+//   setPendingGitRefresh() → 同上（_pendingGitRefresh）
+
+import { isMutatingCommand } from '../../../utils/commandValidator.js';
+
+// 文件修改类工具：触发文件浏览器与 Git 面板刷新
+const FILE_MUTATING_TOOLS = new Set(['apply_patch']);
+
+// _processedToolIds 去重 Set 上限与砍头后的保留量；FIFO LRU 实现
+//
+// 数学依据：
+//   - MAX = 20000：典型用法 ~25 tool_use/h，连续 800h（≈ 数日不间断对话）才触发
+//   - KEEP = 15000：砍头一次移除 5000 条最旧 id，避免逼近上限时频繁小批量砍头抖动
+//   - 内存开销：20000 × ~30 字符 toolu_xxx ≈ 600KB（Set + Queue），可接受
+//
+// 设计意图（vs 旧的暴力 clear）：
+//   清空整个 Set 后，仍残留在 sessions/requests 中的旧 tool_use block 会被重新认作
+//   "新事件"再触发一次刷新（用户感知"忽刷忽不刷"）。FIFO 砍头保证最新的事件 id
+//   仍在 Set 内不被误识，只丢弃确实过老的（用户已不关心的）id。
+const PROCESSED_TOOL_IDS_MAX = 20000;
+const PROCESSED_TOOL_IDS_KEEP = 15000;
+
+// tool_use_id 防御性长度上限；防御异常长 id 占用内存（正常 toolu_xxx 长度 ~30 字符）
+const TOOL_USE_ID_MAX_LEN = 256;
+
+// 收集 tool_use 块到 toolUseMap（id → {name, input}）的纯函数。
+export function collectToolUseBlocks(blocks, toolUseMap) {
+  if (!Array.isArray(blocks)) return;
+  for (const block of blocks) {
+    if (block.type === 'tool_use' && block.id && block.name) {
+      let input = block.input;
+      if (typeof input === 'string') {
+        // 流式过程中 input 字段可能是 "[object Object]{...}" 残片：上游 toString 污染
+        // 把已有的 [object Object] 前缀剥掉再 parse；解析失败兜底空对象，不影响 toolName 路径
+        try { input = JSON.parse(input.replace(/^\[object Object\]/, '')); } catch { input = {}; }
+      }
+      toolUseMap.set(block.id, { name: block.name, input });
+    }
+  }
+}
+
+export class ToolFileChangeController {
+  constructor(host) {
+    this.host = host;
+    this._processedToolIds = new Set();
+    // 与 _processedToolIds 同步的插入顺序队列（FIFO 砍头用）。
+    this._processedToolIdQueue = [];
+    this._fileRefreshTimer = null;
+    this._gitRefreshTimer = null;
+    this._contentRefreshTimer = null;
+  }
+
+  _processToolResult(block, toolUseMap, flags) {
+    if (block.type !== 'tool_result' || !block.tool_use_id) return;
+    // 防御性长度上限，防止异常 id 污染内存（正常 toolu_xxx ~30 字符）
+    if (typeof block.tool_use_id !== 'string' || block.tool_use_id.length > TOOL_USE_ID_MAX_LEN) return;
+    if (this._processedToolIds.has(block.tool_use_id)) return;
+    // 即使失败 / 无 meta 也要标记为已处理，避免后续 cdU 重复扫
+    this._processedToolIds.add(block.tool_use_id);
+    this._processedToolIdQueue.push(block.tool_use_id);
+
+    if (block.is_error) return;
+    const meta = toolUseMap.get(block.tool_use_id);
+    if (!meta) return;
+    const { name: toolName, input } = meta;
+
+    if (FILE_MUTATING_TOOLS.has(toolName)) {
+      flags.needFileRefresh = true;
+      flags.needGitRefresh = true;
+    } else if (toolName === 'shell_command' && input && input.command && isMutatingCommand(input.command)) {
+      flags.needFileRefresh = true;
+      flags.needGitRefresh = true;
+    }
+
+    // Auto-refresh FileContentView when the currently open file is modified.
+    // 仅文件修改类工具才读 currentFile —— 保持原短路：只读工具（占多数）不触碰 host.getState。
+    if (FILE_MUTATING_TOOLS.has(toolName)) {
+      const currentFile = this.host.getState().currentFile;
+      if (currentFile) {
+        const fp = input && input.file_path;
+        // typeof guard：Pass 1 JSON.parse 兜底为 {} 时 fp 为 undefined；流式异常 input
+        // 也可能让 fp 为 number/object，rel.startsWith 会抛 TypeError 中断整个 _processToolResult
+        if (typeof fp === 'string' && fp) {
+          let rel = fp;
+          const projectDir = this.host.getProjectDir();
+          if (rel.startsWith('/') && projectDir && rel.startsWith(projectDir + '/')) {
+            rel = rel.slice(projectDir.length + 1);
+          }
+          if (rel === currentFile || (rel.startsWith('/') && rel.endsWith('/' + currentFile))) {
+            flags.needContentRefresh = true;
+          }
+        }
+      }
+    }
+  }
+
+  check() {
+    // 扫描所有数据源（mainAgentSessions + props.requests 中的 subAgent/teammate），
+    // 基于 tool_result 触发刷新（确保工具已执行完且未失败），反查 tool_use 索引拿 toolName/input。
+    //
+    // 为什么改成 tool_result 触发：
+    // - tool_use 写入 jsonl 时工具尚未执行（特别是 shell_command 长命令、需 permission 审批的工具）
+    // - tool_result 写入 = 工具已执行完；is_error=true 时跳过避免无谓刷新
+    //
+    // 为什么扫 props.requests：subAgent / teammate（Task 工具调用、Agent Team）
+    // 的修改不会出现在 mainAgentSessions，必须从 requests 直接扫
+
+    // INVARIANT: _processedToolIds 与 _processedToolIdQueue 长度必须始终相等。
+    // 仅 development 校验（vite prod build 会 dead-code-eliminate 整个分支；test 环境也跳过避免噪声）
+    if (process.env.NODE_ENV === 'development' &&
+        this._processedToolIds.size !== this._processedToolIdQueue.length) {
+      console.warn('[ChatView] processed-tool-ids invariant broken',
+                   { setSize: this._processedToolIds.size, queueLen: this._processedToolIdQueue.length });
+    }
+
+    const { mainAgentSessions, requests: reqProp } = this.host.getProps();
+    const sessions = mainAgentSessions || [];
+    const requests = reqProp || [];
+    if (sessions.length === 0 && requests.length === 0) return;
+
+    // 用 FIFO 队列做 LRU 砍头：上限 20000（≈ 持续多日对话），砍头一次保留 15000 条；
+    // 普通会话几乎不触发。避免暴力 clear() 导致残留旧 id 被重新认作新事件
+    if (this._processedToolIds.size > PROCESSED_TOOL_IDS_MAX) {
+      const trimCount = this._processedToolIds.size - PROCESSED_TOOL_IDS_KEEP;
+      const toRemove = this._processedToolIdQueue.splice(0, trimCount);
+      for (const id of toRemove) this._processedToolIds.delete(id);
+    }
+
+    // ─── Pass 1: 收集 tool_use 索引（id → {name, input}）─────────────────
+    // 同时扫 mainAgentSessions（含流式 response.body.content）与 requests（subAgent/teammate）
+    const toolUseMap = new Map();
+    for (const session of sessions) {
+      collectToolUseBlocks(session.response?.body?.content, toolUseMap);
+      if (Array.isArray(session.messages)) {
+        for (const msg of session.messages) {
+          if (msg.role === 'assistant') collectToolUseBlocks(msg.content, toolUseMap);
+        }
+      }
+    }
+    for (const req of requests) {
+      collectToolUseBlocks(req.response?.body?.content, toolUseMap);
+      if (Array.isArray(req.body?.input)) {
+        for (const msg of req.body.input) {
+          if (msg.role === 'assistant') collectToolUseBlocks(msg.content, toolUseMap);
+        }
+      }
+    }
+
+    // ─── Pass 2: 扫 tool_result 触发刷新 ─────────────────────────────
+    const flags = { needFileRefresh: false, needGitRefresh: false, needContentRefresh: false };
+
+    for (const session of sessions) {
+      if (!Array.isArray(session.messages)) continue;
+      for (const msg of session.messages) {
+        if (msg.role === 'user' && Array.isArray(msg.content)) {
+          for (const block of msg.content) this._processToolResult(block, toolUseMap, flags);
+        }
+      }
+    }
+    for (const req of requests) {
+      if (!Array.isArray(req.body?.input)) continue;
+      for (const msg of req.body.input) {
+        if (msg.role === 'user' && Array.isArray(msg.content)) {
+          for (const block of msg.content) this._processToolResult(block, toolUseMap, flags);
+        }
+      }
+    }
+    const { needFileRefresh, needGitRefresh, needContentRefresh } = flags;
+    const state = this.host.getState();
+
+    if (needFileRefresh) {
+      if (state.fileExplorerOpen) {
+        clearTimeout(this._fileRefreshTimer);
+        this._fileRefreshTimer = setTimeout(() => {
+          this.host.setState(prev => ({ fileExplorerRefresh: prev.fileExplorerRefresh + 1 }));
+        }, 500);
+      } else {
+        // 面板关闭期间记 pending，由 _setFileExplorerOpen(true) 消费
+        this.host.setPendingFileRefresh();
+      }
+    }
+    if (needGitRefresh) {
+      if (state.gitChangesOpen) {
+        clearTimeout(this._gitRefreshTimer);
+        this._gitRefreshTimer = setTimeout(() => {
+          this.host.setState(prev => ({ gitChangesRefresh: prev.gitChangesRefresh + 1 }));
+        }, 500);
+      } else {
+        this.host.setPendingGitRefresh();
+      }
+    }
+    if (needContentRefresh) {
+      clearTimeout(this._contentRefreshTimer);
+      this._contentRefreshTimer = setTimeout(() => {
+        this.host.setState(prev => ({ fileVersion: prev.fileVersion + 1 }));
+      }, 500);
+    }
+  }
+
+  dispose() {
+    if (this._fileRefreshTimer) clearTimeout(this._fileRefreshTimer);
+    if (this._gitRefreshTimer) clearTimeout(this._gitRefreshTimer);
+    if (this._contentRefreshTimer) clearTimeout(this._contentRefreshTimer);
+  }
+}