cx-viewer 1.0.2 → 1.0.4

package/src/utils/ptyChunkBuilder.js

@@ -0,0 +1,251 @@
+/**
+ * PTY Chunk Builder — pure functions for building keystroke sequences.
+ * Separates "what to send" from "how to send".
+ *
+ * Codex request_user_input prompt model:
+ * - Single question: options list, Enter selects and submits
+ * - Multi question: tabbed form [Q1] [Q2] ... [Submit]
+ *   - Single select: ↓↓...Enter (selects and auto-advances to next tab)
+ *   - Multi select: ↓Space↓Space...→ (toggles then → to next tab)
+ *   - Last tab → to Submit, Enter to confirm
+ */
+
+const ARROW_DOWN = '\x1b[B';
+const ARROW_UP = '\x1b[A';
+const ARROW_RIGHT = '\x1b[C';
+const SPACE = ' ';
+const ENTER = '\r';
+
+/**
+ * Build navigation arrows from currentIdx to targetIdx.
+ */
+function buildArrows(currentIdx, targetIdx) {
+  const chunks = [];
+  const diff = targetIdx - currentIdx;
+  const arrow = diff > 0 ? ARROW_DOWN : ARROW_UP;
+  for (let i = 0; i < Math.abs(diff); i++) {
+    chunks.push(arrow);
+  }
+  return chunks;
+}
+
+/**
+ * Get current cursor position from prompt.
+ */
+function getCursorIdx(prompt) {
+  if (prompt && prompt.options) {
+    const idx = prompt.options.findIndex(o => o.selected);
+    return idx >= 0 ? idx : 0;
+  }
+  return 0;
+}
+
+/**
+ * Build chunks for a single-select answer.
+ * Navigate to target option, then Enter.
+ * @param {object} answer - { optionIndex, isLast }
+ * @param {object} prompt - ptyPrompt with options
+ * @param {boolean} isMultiQuestion - whether this is part of a multi-question form
+ */
+export function buildSingleSelectChunks(answer, prompt, isMultiQuestion = false) {
+  const chunks = [];
+  let currentIdx = getCursorIdx(prompt);
+
+  // For multi-question, map optionIndex to prompt option by number
+  let targetIdx = answer.optionIndex;
+  if (prompt && prompt.options) {
+    const targetNumber = answer.optionIndex + 1;
+    const found = prompt.options.findIndex(o => o.number === targetNumber);
+    if (found >= 0) targetIdx = found;
+  }
+
+  chunks.push(...buildArrows(currentIdx, targetIdx));
+  chunks.push(ENTER); // Select and confirm (auto-advances in multi-question)
+
+  // Multi-question last question: Enter above advances to Review page,
+  // need another Enter to confirm "Submit answers"
+  if (isMultiQuestion && answer.isLast) {
+    chunks.push(ENTER);
+  }
+  return chunks;
+}
+
+/**
+ * Build chunks for a multi-select answer.
+ * Navigate + Space for each selection, then → to advance tab.
+ * @param {object} answer - { selectedIndices, isLast }
+ * @param {object} prompt - ptyPrompt with options
+ * @param {boolean} isMultiQuestion - whether this is part of a multi-question form
+ */
+export function buildMultiSelectChunks(answer, prompt, isMultiQuestion = false) {
+  const chunks = [];
+  const indices = (answer.selectedIndices || []).slice().sort((a, b) => a - b);
+  let currentIdx = getCursorIdx(prompt);
+
+  for (const targetIdx of indices) {
+    chunks.push(...buildArrows(currentIdx, targetIdx));
+    chunks.push(SPACE); // Toggle
+    currentIdx = targetIdx;
+  }
+
+  // → to advance to next tab (or Submit tab if last)
+  chunks.push(ARROW_RIGHT);
+
+  // Last question in multi-question, or single question: Enter on Submit tab
+  if (answer.isLast || !isMultiQuestion) {
+    chunks.push(ENTER);
+  }
+
+  return chunks;
+}
+
+/**
+ * Build chunks for a single-select "Other" (free text) answer.
+ *
+ * Single-question mode:
+ *   Navigate to "Type something" → Enter (activate text input) → type text → Enter (confirm)
+ *
+ * Multi-question tabbed form:
+ *   In tabbed forms, Enter on "Type something" auto-advances to the next tab
+ *   (same as regular single-select). Text input is NOT inline — Codex
+ *   prompts for it separately after the form is submitted.
+ *   So we treat it like a regular single-select: navigate → Enter.
+ *
+ * @param {object} answer - { optionIndex, text, isLast }
+ * @param {object} prompt - ptyPrompt with options
+ * @param {boolean} isMultiQuestion - whether part of multi-question form
+ */
+export function buildOtherChunks(answer, prompt, isMultiQuestion = false) {
+  const chunks = [];
+  let currentIdx = getCursorIdx(prompt);
+  const targetIdx = answer.optionIndex;
+
+  chunks.push(...buildArrows(currentIdx, targetIdx));
+
+  // "Type something" 选项：直接输入文字，不需要 Enter 激活
+  // inquirer 在光标停在此选项时接受直接键入文字
+  const text = answer.text || '';
+  for (const ch of text) {
+    chunks.push(ch);
+  }
+  chunks.push(ENTER); // Confirm text and submit
+
+  // Multi-question last question: Enter above auto-advances to Submit tab,
+  // need another Enter to confirm
+  if (isMultiQuestion && answer.isLast) {
+    chunks.push(ENTER);
+  }
+  return chunks;
+}
+
+/**
+ * Build chunks for a multi-select "Other" (Type something) answer.
+ * "Type something" is a text-input option in the checkbox list.
+ * Sequence: navigate → type text + sacrifice_char → → (settle) → ↑ (exit, drops sacrifice_char) → → (next tab) → Enter (if last)
+ * inquirer drops the last char on ↓/↑ exit; sacrifice char absorbs the loss.
+ * Uses ↑ instead of ↓ to exit: "Type something" is the last option, so ↓ keeps cursor there
+ * and → may re-enter text mode. ↑ moves to a non-text option, making → reliably navigate tabs.
+ * @param {object} answer - { optionIndex, text, isLast }
+ * @param {object} prompt - ptyPrompt with options
+ * @param {boolean} isMultiQuestion - whether part of multi-question form
+ */
+export function buildMultiSelectOtherChunks(answer, prompt, isMultiQuestion = false) {
+  const chunks = [];
+  let currentIdx = getCursorIdx(prompt);
+  const targetIdx = answer.optionIndex;
+
+  chunks.push(...buildArrows(currentIdx, targetIdx));
+
+  // Type text directly into the "Type something" field
+  // Typing auto-checks the checkbox — no Space/Enter needed
+  const text = answer.text || '';
+  for (const ch of text) {
+    chunks.push(ch);
+  }
+
+  // Sacrifice char: ↑/↓ drops exactly one character when exiting text input mode.
+  // Append ONE duplicate of the last char so the exit key drops the sacrifice, not the real text.
+  if (text.length > 0) {
+    const chars = [...text]; // handle multi-byte (e.g. CJK) correctly
+    chunks.push(chars[chars.length - 1]); // sacrifice for ↑
+  }
+
+  // → in text input mode: no-op (cursor already at end), provides settleMs delay
+  chunks.push(ARROW_RIGHT);
+  // ↑ exits text input mode — drops one char (the sacrifice above), real text preserved.
+  // Use ↑ instead of ↓: "Type something" is typically the last option, so ↓ may leave
+  // cursor on the same item (no option below). ↑ moves to the previous *non-text* option,
+  // ensuring the subsequent → is interpreted as tab navigation, not text cursor movement.
+  chunks.push(ARROW_UP);
+  // → goes to next tab (Submit tab for last/single question, next question tab otherwise)
+  chunks.push(ARROW_RIGHT);
+
+  // Enter on Submit/Review page to confirm — only for last question or single-question form
+  if (answer.isLast || !isMultiQuestion) {
+    chunks.push(ENTER);
+  }
+
+  return chunks;
+}
+
+/**
+ * Build chunks for a single answer (dispatches by type).
+ * @param {object} answer - { type, optionIndex, selectedIndices, text, isLast, isMultiSelect }
+ * @param {object} prompt - ptyPrompt with options
+ * @param {boolean} isMultiQuestion - whether part of multi-question form
+ */
+export function buildChunksForAnswer(answer, prompt, isMultiQuestion = false) {
+  if (answer.type === 'multi') {
+    return buildMultiSelectChunks(answer, prompt, isMultiQuestion);
+  }
+  if (answer.type === 'other' && answer.isMultiSelect) {
+    return buildMultiSelectOtherChunks(answer, prompt, isMultiQuestion);
+  }
+  if (answer.type === 'other') {
+    return buildOtherChunks(answer, prompt, isMultiQuestion);
+  }
+  return buildSingleSelectChunks(answer, prompt, isMultiQuestion);
+}
+
+/**
+ * settleMs after a bracket-paste-end chunk. Ink TUI needs ~1 frame to settle
+ * paste→normal state; if \r arrives in the same PTY write it gets swallowed.
+ */
+export const BRACKET_PASTE_SUBMIT_SETTLE_MS = 250;
+
+/**
+ * 剥离粘贴文本里内嵌的 bracketed-paste end 序列 `\x1b[201~`。
+ *
+ * 防 paste-injection：xterm.js 6.0 的 bracketed paste 不 sanitize 粘贴内容（上游修复
+ * PR #5716 在 7.0），剪贴板里的 `\x1b[201~` 会提前闭合 paste 包裹，余下字节被当作真实
+ * 按键/控制序列注入。剥离后再包裹即可堵住（该序列正常文本中不会出现，剥离无副作用）。
+ * 同时剥 `\x1b[200~` 以防成对伪造。
+ *
+ * 循环剥离到稳定：单趟 /g replace 删掉中间一个完整序列后，左右残片会重新相邻拼成
+ * 新序列（如 `\x1b[20` + `\x1b[201~` + `1~` → 删中段后 `\x1b[20`+`1~` = `\x1b[201~`），
+ * 绕过单趟剥离。循环到不再变化才安全。
+ * 正则覆盖 7-bit `\x1b[`（ESC [）与 8-bit C1 CSI `\x9b` 两种 introducer。
+ * @param {string} text
+ * @returns {string}
+ */
+export function sanitizeBracketPasteText(text) {
+  if (typeof text !== 'string') return text;
+  const re = /(?:\x1b\[|\x9b)20[01]~/g;
+  let prev;
+  do {
+    prev = text;
+    text = text.replace(re, '');
+  } while (text !== prev);
+  return text;
+}
+
+/**
+ * Wrap content in bracket paste mode and append Enter as a separate chunk,
+ * so the consumer can space them with settleMs.
+ * @param {string} content - non-empty string to paste-and-submit
+ * @returns {string[]} [pasteBlock, '\r']; [] if content is falsy or non-string
+ */
+export function buildBracketPasteSubmitChunks(content) {
+  if (typeof content !== 'string' || content.length === 0) return [];
+  return [`\x1b[200~${sanitizeBracketPasteText(content)}\x1b[201~`, ENTER];
+}

package/src/utils/quickMenuHoverIntent.js

@@ -0,0 +1,35 @@
+// 级联子菜单 hover-intent（终端工具栏与对话输入栏的四芒星快捷菜单共用）：
+// 从下排行斜向上滑向其子菜单高处选项时，路径会扫过相邻行，立即切换会抢走展开态
+// 致子菜单中途消失。进入（已有展开行时）/离开都延迟 HOVER_INTENT_MS 提交，扫过的
+// 行来不及生效，路径上的误触发被后续 clearTimeout 撤销；无展开行时进入即时响应不付延迟。
+
+export const HOVER_INTENT_MS = 140;
+
+// getExpanded 必须现场读宿主最新值（class 读 this.state，hooks 读 latest-value ref）：
+// 延迟提交时展开行可能已被后续 enter/点击改写，闭包快照会误收别行的展开态。
+// skip：宿主整体不参与 hover 展开（如 iPad tap 的 synthetic mouseEnter 会与 click 切换互抵）；
+// holdOpen：延迟收起提交时刻判定是否保住展开（如 AgentTeam 启用请求进行中保住 loading 反馈）。
+export function createQuickMenuHoverIntent({ getExpanded, setExpanded, skip, holdOpen }) {
+  let timer = null;
+  return {
+    enter(key) {
+      if (skip?.()) return;
+      clearTimeout(timer);
+      const current = getExpanded();
+      if (current === key) return;
+      if (current === null) setExpanded(key);
+      else timer = setTimeout(() => setExpanded(key), HOVER_INTENT_MS);
+    },
+    leave(key) {
+      if (skip?.()) return;
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        if (holdOpen?.(key)) return;
+        if (getExpanded() === key) setExpanded(null);
+      }, HOVER_INTENT_MS);
+    },
+    cancel() {
+      clearTimeout(timer);
+    },
+  };
+}

package/src/utils/rateLimitParser.js

@@ -0,0 +1,249 @@
+// 解析 Codex / OpenAI 响应头里的限流信息，归一化成前端血条旁
+// 「套餐用量」组件可直接用的结构。
+//
+// 纯函数、零依赖：仅做字符串 → 数值的安全转换，便于单元测试，也避免被
+// ESM 后缀缺失的传递依赖污染（参考 readResultPool 测试注释）。
+//
+// 数据来源：cx-viewer 拦截器已把响应头原样写进日志(interceptor.js)，前端的
+// request.response.headers 即可直接读到，无需任何服务端改动。
+//
+// Codex 当前源码解析的默认 header family：
+//   - x-codex-primary-used-percent / x-codex-primary-window-minutes / x-codex-primary-reset-at
+//   - x-codex-secondary-used-percent / x-codex-secondary-window-minutes / x-codex-secondary-reset-at
+// 也可能出现 x-{limit-id}-primary-* 的多 limit family。普通 OpenAI API 还可能返回
+// x-ratelimit-* headers。解析必须容忍缺失/多余 key。
+
+const LEGACY_PREFIX = 'anthropic-ratelimit-unified-';
+const CODEX_PREFIX = 'x-codex-';
+
+// 安全转数值：非有限值（NaN/Infinity/null/空串）一律返回 null，避免污染显示。
+function toNum(v) {
+  if (v == null || v === '') return null;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : null;
+}
+
+// 把 headers 的 key 统一成小写做大小写无关查找（fetch 一般已小写，这里再兜底一次）。
+function lowerKeyMap(headers) {
+  const map = {};
+  for (const k of Object.keys(headers)) map[k.toLowerCase()] = headers[k];
+  return map;
+}
+
+function toEpochMillis(value) {
+  const n = toNum(value);
+  return n == null ? null : n * 1000;
+}
+
+function openAiResetToMillis(value) {
+  if (value == null || value === '') return null;
+  const raw = String(value).trim().toLowerCase();
+  const epoch = toNum(raw);
+  if (epoch != null) return epoch > 1000000000000 ? epoch : epoch * 1000;
+  const match = raw.match(/^(\d+(?:\.\d+)?)(ms|s|m|h|d)$/);
+  if (!match) return null;
+  const n = Number(match[1]);
+  const unit = match[2];
+  const mult = unit === 'ms' ? 1 : unit === 's' ? 1000 : unit === 'm' ? 60000 : unit === 'h' ? 3600000 : 86400000;
+  return Date.now() + n * mult;
+}
+
+function normalizeLimitId(name) {
+  return String(name || 'codex').trim().toLowerCase().replace(/-/g, '_');
+}
+
+/**
+ * 解析单个窗口（如 '5h' / '7d'）。三项全缺则返回 null（该窗口不存在）。
+ * @returns {{id:string, utilization:number|null, status:string|null, resetAt:number|null}|null}
+ */
+function parseLegacyWindow(map, id) {
+  const utilization = toNum(map[`${LEGACY_PREFIX}${id}-utilization`]);
+  const resetSec = toNum(map[`${LEGACY_PREFIX}${id}-reset`]);
+  const status = map[`${LEGACY_PREFIX}${id}-status`] || null;
+  if (utilization == null && resetSec == null && !status) return null;
+  return {
+    id,
+    utilization,                                   // 0~1 占比
+    status,                                         // allowed / rejected / queued ...
+    resetAt: resetSec != null ? resetSec * 1000 : null, // epoch 秒 → 毫秒
+  };
+}
+
+function parseLegacyRateLimitHeaders(map) {
+  const hasUnified = Object.keys(map).some((k) => k.startsWith(LEGACY_PREFIX));
+  if (!hasUnified) return null;
+
+  const windows = [parseLegacyWindow(map, '5h'), parseLegacyWindow(map, '7d')].filter(Boolean);
+  if (windows.length === 0) return null;
+
+  return {
+    source: 'legacy-plan',
+    windows,
+    overallStatus: map[`${LEGACY_PREFIX}status`] || null,
+    representativeClaim: map[`${LEGACY_PREFIX}representative-claim`] || null,
+    overage: {
+      status: map[`${LEGACY_PREFIX}overage-status`] || null,
+      disabledReason: map[`${LEGACY_PREFIX}overage-disabled-reason`] || null,
+    },
+    fallbackPercentage: toNum(map[`${LEGACY_PREFIX}fallback-percentage`]),
+  };
+}
+
+function parseCodexWindow(map, limitPrefix, slot, id, label) {
+  const usedPercent = toNum(map[`${limitPrefix}-${slot}-used-percent`]);
+  const windowMinutes = toNum(map[`${limitPrefix}-${slot}-window-minutes`]);
+  const resetAt = toEpochMillis(map[`${limitPrefix}-${slot}-reset-at`]);
+  if (usedPercent == null && windowMinutes == null && resetAt == null) return null;
+  return {
+    id,
+    label,
+    utilization: usedPercent == null ? null : usedPercent / 100,
+    status: null,
+    resetAt,
+    windowMinutes,
+  };
+}
+
+function headerNameToCodexLimitId(headerName) {
+  const suffix = '-primary-used-percent';
+  if (!headerName.startsWith('x-') || !headerName.endsWith(suffix)) return null;
+  return normalizeLimitId(headerName.slice(2, -suffix.length));
+}
+
+function parseCodexRateLimitHeaders(map) {
+  const limitIds = new Set(['codex']);
+  for (const key of Object.keys(map)) {
+    const limitId = headerNameToCodexLimitId(key);
+    if (limitId) limitIds.add(limitId);
+  }
+
+  const windows = [];
+  let limitName = null;
+  for (const limitId of limitIds) {
+    const limitPrefix = `x-${limitId.replace(/_/g, '-')}`;
+    const name = map[`${limitPrefix}-limit-name`] || (limitId === 'codex' ? 'Codex' : limitId);
+    const primary = parseCodexWindow(map, limitPrefix, 'primary', `${limitId}:primary`, `${name} primary`);
+    const secondary = parseCodexWindow(map, limitPrefix, 'secondary', `${limitId}:secondary`, `${name} secondary`);
+    if (primary) windows.push(primary);
+    if (secondary) windows.push(secondary);
+    if ((primary || secondary) && !limitName) limitName = name;
+  }
+
+  const hasCredits =
+    map[`${CODEX_PREFIX}credits-has-credits`] != null
+    || map[`${CODEX_PREFIX}credits-unlimited`] != null
+    || map[`${CODEX_PREFIX}credits-balance`] != null;
+  if (windows.length === 0 && !hasCredits) return null;
+
+  return {
+    source: 'codex',
+    windows,
+    overallStatus: map[`${CODEX_PREFIX}rate-limit-reached-type`] || null,
+    representativeClaim: limitName,
+    overage: {
+      status: null,
+      disabledReason: null,
+    },
+    fallbackPercentage: null,
+    credits: hasCredits ? {
+      hasCredits: map[`${CODEX_PREFIX}credits-has-credits`] ?? null,
+      unlimited: map[`${CODEX_PREFIX}credits-unlimited`] ?? null,
+      balance: map[`${CODEX_PREFIX}credits-balance`] ?? null,
+    } : null,
+  };
+}
+
+function parseOpenAiWindow(map, id, label, limitKey, remainingKey, resetKey) {
+  const limit = toNum(map[limitKey]);
+  const remaining = toNum(map[remainingKey]);
+  const resetAt = openAiResetToMillis(map[resetKey]);
+  if (limit == null && remaining == null && resetAt == null) return null;
+  const utilization = limit != null && limit > 0 && remaining != null
+    ? Math.max(0, Math.min(1, (limit - remaining) / limit))
+    : null;
+  return {
+    id,
+    label,
+    utilization,
+    status: null,
+    resetAt,
+    limit,
+    remaining,
+  };
+}
+
+function parseOpenAiRateLimitHeaders(map) {
+  const windows = [
+    parseOpenAiWindow(map, 'requests', 'Requests', 'x-ratelimit-limit-requests', 'x-ratelimit-remaining-requests', 'x-ratelimit-reset-requests'),
+    parseOpenAiWindow(map, 'tokens', 'Tokens', 'x-ratelimit-limit-tokens', 'x-ratelimit-remaining-tokens', 'x-ratelimit-reset-tokens'),
+  ].filter(Boolean);
+  if (windows.length === 0) return null;
+  return {
+    source: 'openai',
+    windows,
+    overallStatus: null,
+    representativeClaim: null,
+    overage: {
+      status: null,
+      disabledReason: null,
+    },
+    fallbackPercentage: null,
+  };
+}
+
+/**
+ * 解析限流响应头。
+ * @param {Record<string,string>|null|undefined} headers - request.response.headers
+ * @returns {null | {
+ *   source: 'codex'|'openai'|'legacy-plan',
+ *   windows: Array<{id, utilization, status, resetAt}>,
+ *   overallStatus: string|null,
+  *   representativeClaim: string|null,
+ *   overage: { status: string|null, disabledReason: string|null },
+ *   fallbackPercentage: number|null,
+ * }}
+ * 无任何 unified header 时返回 null（调用方据此决定不渲染套餐用量）。
+ */
+export function parseRateLimitHeaders(headers) {
+  if (!headers || typeof headers !== 'object') return null;
+  const map = lowerKeyMap(headers);
+  return parseCodexRateLimitHeaders(map)
+    || parseOpenAiRateLimitHeaders(map)
+    || parseLegacyRateLimitHeaders(map);
+}
+
+/**
+ * 从 requests 列表里取「最近一条带限流头」的响应，解析成套餐用量。
+ * 限流头是账号级、随每条响应下发的，所以从后往前找第一条可解析的即可
+ * （不依赖 isMainAgent，保持本模块零依赖、可独立单测）。
+ * @param {Array} requests
+ * @returns {ReturnType<typeof parseRateLimitHeaders>}
+ */
+export function extractLatestPlanUsage(requests) {
+  if (!Array.isArray(requests)) return null;
+  for (let i = requests.length - 1; i >= 0; i--) {
+    const headers = requests[i] && requests[i].response && requests[i].response.headers;
+    if (!headers) continue;
+    const pu = parseRateLimitHeaders(headers);
+    if (pu) return pu;
+  }
+  return null;
+}
+
+/**
+ * 选出「当前绑定」的代表窗口，用于 pill 的主色与主进度。
+ * 规则：representative-claim='five_hour' → 5h；明显的周/天 → 7d；
+ *      无法识别时回落到使用率更高的窗口（更接近“离限额最近”的语义）。
+ */
+export function pickHeadlineWindow(planUsage) {
+  if (!planUsage || !Array.isArray(planUsage.windows) || planUsage.windows.length === 0) return null;
+  const claim = planUsage.representativeClaim;
+  let id = null;
+  if (claim === 'five_hour') id = '5h';
+  else if (claim && /(day|week|7d|seven)/i.test(claim)) id = '7d';
+  if (id) {
+    const hit = planUsage.windows.find((w) => w.id === id);
+    if (hit) return hit;
+  }
+  return planUsage.windows.reduce((a, b) => ((b.utilization || 0) > (a.utilization || 0) ? b : a));
+}

package/src/utils/readResultPool.js

@@ -0,0 +1,106 @@
+/**
+ * tool_result content intern pool.
+ *
+ * 1.6.237 后实测：同一 .jsx 文件被 87 个 SubAgent / 父 user message 各持一份完整副本（30MB+ 重复）。
+ * 对 tool_result 的 resultText 做 content-addressed dedup，让相同内容共享同一字符串引用。
+ * hash 仅用 length + 前 64 / 后 64 字符避免大字符串 O(n) hash；当 length > 512
+ * 再加采中段 64 字符（共三段 192 字节），令仅中段不同的长串也能区分；碰撞概率极低。
+ *
+ * 抽到独立模块（无外部依赖）便于 node --test 直接 import，避免被
+ * toolResultBuilder.js 的传递依赖（./helpers 无 .js 后缀）污染。
+ */
+
+// 容量上限设计：1000 vs entry-slim.js 的 _toolsPool/_systemPool 上限 200，差异源自流量域不同。
+// tools/system 是 entry-level 配置数组，全 session 命中分布稳定，实测 pool size <5（200 极宽松）；
+// readResultPool 池化的是 tool_result 字符串（v4 派生层 + v5 raw payload），
+// 单 session 唯一字符串数量与 tool 调用次数同阶（v4 实测 4400 calls / pool size 363）。
+// B 项加入 raw payload 后预期再 +20-40%，1000 留 ~30% 余量；超阈值由 _poolEvictions 暴露。
+const _MAX_READ_POOL_SIZE = 1000;
+const _MIN_DEDUP_LEN = 256;
+const _SIG_MID_THRESHOLD = 512;
+const _readResultPool = new Map();
+let _poolEvictions = 0;
+
+// v5: sig 增加 mid-slice（当 length > 512）。对齐 entry-slim.js _systemSig 的边界增强模式。
+// B 项把 raw payload tool_result block.content 也接入此 pool（含 shell/log 类
+// 长度+前后缀重合的结构化输出），暴露面变大。length+first 64+last 64 在该场景对碰撞抗性
+// 不足，加 mid-64 后要求"长度+三段共 192 字节"全匹配才视为同串。
+function _readResultSig(s) {
+  if (s.length > _SIG_MID_THRESHOLD) {
+    const midIdx = Math.floor(s.length / 2);
+    return s.length + ':' + s.slice(0, 64) + ':' + s.slice(midIdx, midIdx + 64) + ':' + s.slice(-64);
+  }
+  return s.length + ':' + s.slice(0, 64) + ':' + s.slice(-64);
+}
+
+/**
+ * 把 tool_result 的 resultText 替换为 pool 中的共享引用（命中时）或注册新值。
+ * 短字符串（< 256）跳过 dedup（不值得 sig 开销）。
+ *
+ * @param {string} s - resultText 原文
+ * @returns {string} 池化后的字符串引用
+ */
+export function internReadResult(s) {
+  if (typeof s !== 'string' || s.length < _MIN_DEDUP_LEN) return s;
+  const sig = _readResultSig(s);
+  const pooled = _readResultPool.get(sig);
+  if (pooled !== undefined) return pooled;
+  if (_readResultPool.size >= _MAX_READ_POOL_SIZE) {
+    _readResultPool.delete(_readResultPool.keys().next().value);
+    _poolEvictions++;
+  }
+  _readResultPool.set(sig, s);
+  return s;
+}
+
+/** 测试辅助：清空 tool_result intern pool 和 eviction counter。 */
+export function _resetReadPoolForTest() {
+  _readResultPool.clear();
+  _poolEvictions = 0;
+}
+
+/** 测试辅助：观察 pool 当前 size。 */
+export function _getReadPoolSizeForTest() {
+  return _readResultPool.size;
+}
+
+/** 诊断：FIFO 淘汰累计次数。典型 session <50；>200 提示 _MAX_READ_POOL_SIZE 需上调。 */
+export function _getReadPoolEvictionsForTest() {
+  return _poolEvictions;
+}
+
+/**
+ * 通用版：所有 tool_result（shell/MCP/deferred tools/...）都走同一 pool。
+ * 算法与 internReadResult 完全相同（同 _readResultSig + 同 _readResultPool），
+ * 名字区分只是语义上的扩展，便于 toolResultBuilder.js 默认全 intern。
+ *
+ * @param {string} s - tool_result 的 resultText 原文
+ * @returns {string} 池化后的字符串引用
+ */
+export function internToolResult(s) {
+  return internReadResult(s);
+}
+
+/**
+ * 命中-aware 变体：仅在 pool 已有相同 sig 时返回共享 ref，否则注册并返回 null。
+ *
+ * 设计动机：JS string `===` 是值比较，调用方拿到 internReadResult 的返回值无法判断"这是
+ * pool 命中（应替换 block.content 节省内存）"还是"刚注册（保持原 ref 即可）"。
+ * 此函数把命中信号显式上抛——`null` = 未命中或短结果（无需替换），非 null = 命中（应替换）。
+ * v5 entry-slim.js 的 lazy-clone 路径依赖这个信号决定是否触发 messages 浅克隆。
+ *
+ * @param {string} s - tool_result 内容原文
+ * @returns {string|null} 命中时返回 pool 共享 ref；未命中（已注册）或短结果（< 256）返回 null
+ */
+export function internToolResultIfPooled(s) {
+  if (typeof s !== 'string' || s.length < _MIN_DEDUP_LEN) return null;
+  const sig = _readResultSig(s);
+  const pooled = _readResultPool.get(sig);
+  if (pooled !== undefined) return pooled;
+  if (_readResultPool.size >= _MAX_READ_POOL_SIZE) {
+    _readResultPool.delete(_readResultPool.keys().next().value);
+    _poolEvictions++;
+  }
+  _readResultPool.set(sig, s);
+  return null;
+}

package/src/utils/refreshCachedItemProp.js

@@ -0,0 +1,32 @@
+import React from 'react';
+
+/**
+ * 刷新缓存的 assistant ChatMessage element 上随 ChatView `_sessionItemCache` FULL HIT 而冻结的
+ * 过期 map prop。仅对「持有指定 toolName 的 tool_use」的 element 做 cloneElement 注入 nextMap，
+ * 其余原样返回；prevMap===nextMap 时返回原数组（零分配）。
+ *
+ * 背景：FULL HIT 路径直接返回 `sc.items` 时 React reconciler 看到完全相同的 element 引用就跳过
+ * diff，ChatMessage SCU 根本不会被调用，元素创建时冻结的旧 map（planApprovalMap / askAnswerMap）
+ * 永不刷新——导致 plan 审批后卡片不切「已批准」、request_user_input 答完后仍显示 pending。
+ * 本函数合并自原 refreshPlanApprovalCache / refreshAskAnswerCache 两个孪生模块。
+ *
+ * @param {Array} items - 缓存的 ChatMessage React element 数组
+ * @param {object} prevMap - 上一轮存入 cache 时的 map 引用
+ * @param {object} nextMap - 本轮派生的 map 引用
+ * @param {string|string[]} toolName - 触发刷新的 tool_use 名或兼容别名
+ * @param {string} propName - 要刷新的 prop 名（'planApprovalMap' / 'askAnswerMap'）
+ * @returns {Array} 引用全等时为 items；否则为新数组（仅命中者被 cloneElement）
+ */
+export function refreshCachedItemProp(items, prevMap, nextMap, toolName, propName) {
+  if (prevMap === nextMap) return items;
+  const names = Array.isArray(toolName) ? new Set(toolName) : null;
+  const matchesName = (name) => names ? names.has(name) : name === toolName;
+  let dirty = false;
+  const out = items.map(m => {
+    if (!m || !m.props || m.props.role !== 'assistant' || !Array.isArray(m.props.content)) return m;
+    if (!m.props.content.some(b => b.type === 'tool_use' && matchesName(b.name))) return m;
+    dirty = true;
+    return React.cloneElement(m, { [propName]: nextMap });
+  });
+  return dirty ? out : items;
+}