cc-viewer 1.6.348 → 1.7.1

package/src/utils/svgSanitize.js

@@ -0,0 +1,48 @@
+// SVG sanitize: allow SMIL animation tags through DOMPurify's strict svg profile so previewed
+// *.svg files animate, but reject <set>/<animate*> retargeting onto on*/href/style — defending
+// against post-sanitize attribute injection via the SMIL animation engine.
+//
+// Uses a PRIVATE DOMPurify instance so the SMIL guard hook stays scoped to SVG sanitize calls
+// (no leakage into the markdown / Mermaid sanitize pipelines that share the default singleton).
+
+import DOMPurify from 'dompurify';
+
+export const SMIL_TAGS = new Set(['set', 'animate', 'animatemotion', 'animatetransform']);
+export const FORBIDDEN_ANIM_TARGET = /^(on|href$|xlink:href$|style$)/i;
+
+export function isHostileAnimAttr(tagName, attrName, attrValue) {
+  // DOMPurify lowercases attrName before passing to hooks; the explicit toLowerCase is cheap
+  // insurance against version drift / direct callers (unit tests).
+  if (String(attrName || '').toLowerCase() !== 'attributename') return false;
+  if (!SMIL_TAGS.has((tagName || '').toLowerCase())) return false;
+  return FORBIDDEN_ANIM_TARGET.test(String(attrValue || '').trim());
+}
+
+export const SVG_SANITIZE_CONFIG = Object.freeze({
+  USE_PROFILES: { svg: true },
+  ADD_TAGS: ['animate', 'animateMotion', 'animateTransform', 'set', 'mpath'],
+  ADD_ATTR: [
+    'attributeName', 'attributeType', 'calcMode', 'values', 'keyTimes', 'keySplines',
+    'dur', 'repeatCount', 'repeatDur', 'begin', 'end', 'from', 'to', 'by',
+    'restart', 'min', 'max', 'additive', 'accumulate', 'path', 'rotate',
+    'fill', 'href', 'xlink:href', 'type', 'origin',
+  ],
+});
+
+// DOMPurify default export is both an instance and a factory: calling it with a window returns a
+// fresh instance whose hook chain is independent. In SSR / node:test (no window) the default
+// instance is a stub without addHook/sanitize — guard so this module is import-safe everywhere.
+const svgPurify = typeof window !== 'undefined' ? DOMPurify(window) : DOMPurify;
+
+if (typeof svgPurify.addHook === 'function') {
+  svgPurify.addHook('uponSanitizeAttribute', (node, data) => {
+    if (isHostileAnimAttr(node && node.nodeName, data && data.attrName, data && data.attrValue)) {
+      data.keepAttr = false;
+    }
+  });
+}
+
+export function sanitizeSvg(text) {
+  if (typeof svgPurify.sanitize !== 'function') return text;
+  return svgPurify.sanitize(text, SVG_SANITIZE_CONFIG);
+}

package/src/utils/systemTags.js

@@ -0,0 +1,47 @@
+export const SYSTEM_TAGS = [
+  'system-reminder', 'local-command-caveat', 'project-reminder',
+  'important-instruction-reminders', 'file-modified-reminder', 'todo-reminder',
+  'user-prompt-submit-hook', 'local-command-stdout', 'command-name',
+  'task-notification', 'environment_details', 'context'
+];
+
+export function parseSystemTags(text) {
+  if (!text) return { segments: [] };
+  const tagPattern = new RegExp(
+    '<(' + SYSTEM_TAGS.join('|') + ')\\b[^>]*>([\\s\\S]*?)</\\1>',
+    'gi'
+  );
+  const segments = [];
+  let lastIndex = 0;
+  let match;
+  while ((match = tagPattern.exec(text)) !== null) {
+    if (match.index > lastIndex) {
+      const before = text.slice(lastIndex, match.index).trim();
+      if (before) segments.push({ type: 'text', content: before });
+    }
+    segments.push({ type: 'system-tag', tag: match[1], content: match[2].trim() });
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < text.length) {
+    const rest = text.slice(lastIndex).trim();
+    if (rest) segments.push({ type: 'text', content: rest });
+  }
+  return { segments };
+}
+
+const _tagCache = new Map();
+const _TAG_CACHE_MAX = 512;
+
+export function renderAssistantText(text) {
+  if (!text) return { segments: [] };
+  const hit = _tagCache.get(text);
+  if (hit) return hit;
+
+  const result = parseSystemTags(text);
+
+  if (_tagCache.size >= _TAG_CACHE_MAX) {
+    _tagCache.delete(_tagCache.keys().next().value);
+  }
+  _tagCache.set(text, result);
+  return result;
+}

package/src/utils/tClaude.js

@@ -0,0 +1,20 @@
+// Claude 配置目录感知的 i18n 包装。由 AppBase 在 /api/preferences 响应里调
+// setClaudeConfigDir() 注入；tc(key) 在调用时把 {configDir} 占位符替换成
+// home-friendly 展示路径（默认 "~/.claude"，设了 CLAUDE_CONFIG_DIR 时为绝对路径）。
+
+import { t } from '../i18n';
+
+let _configDir = '~/.claude';
+
+export function setClaudeConfigDir(path) {
+  if (typeof path === 'string' && path.length > 0) _configDir = path;
+}
+
+export function getClaudeConfigDir() {
+  return _configDir;
+}
+
+// 注入的 configDir 不可被 params 覆盖——UI 必须反映真实的配置目录。
+export function tc(key, params) {
+  return t(key, { ...params, configDir: _configDir });
+}

package/src/utils/teamModalBuilder.js

@@ -0,0 +1,351 @@
+/**
+ * Build team modal visualization data from requests and sessions.
+ * Pure function — no React/state dependencies.
+ */
+
+import { classifyUserContent, isMainAgent, extractDisplayText } from './contentFilter';
+import { restoreSlimmedEntry } from './entry-slim.js';
+import { classifyRequest, formatRequestTag, formatTeammateLabel } from './requestType';
+import { getModelInfo, getEffectiveModel } from './helpers';
+import { getTeammateAvatar } from './teammateAvatars';
+import { buildSubAgentResultMap, buildGlobalToolResultIndex } from './toolResultBuilder';
+
+export function buildTeamModalData(team, requests, mainAgentSessions) {
+  const startIdx = team.requestIndex;
+  const endIdx = team.endRequestIndex != null ? team.endRequestIndex + 1 : requests.length;
+  const teamRequests = requests.slice(startIdx, endIdx);
+  const teamStartTime = team.startTime;
+  const teamEndTime = team.endTime || (requests[endIdx - 1]?.response?.timestamp || requests[endIdx - 1]?.timestamp);
+
+  // 构建 tsToIndex 和 modelInfo
+  const tsToIndex = {};
+  let modelName = null;
+  for (let i = startIdx; i < endIdx && i < requests.length; i++) {
+    const req = requests[i];
+    if (req.timestamp) tsToIndex[req.timestamp] = i;
+    const effective = getEffectiveModel(req);
+    if (effective) modelName = effective;
+  }
+  const modelInfo = getModelInfo(modelName);
+
+  // 用户消息提取：展示触发 team 的用户 prompt，帮助理解 team 要解决什么问题。
+  const entries = [];
+  let hasUserMsg = false;
+
+  // 策略 1：从 mainAgentSessions 按时间范围提取
+  if (mainAgentSessions) {
+    let closestBeforeTs = null;
+    for (const session of mainAgentSessions) {
+      for (const msg of session.messages || []) {
+        const ts = msg._timestamp;
+        if (!ts || msg.role !== 'user') continue;
+        if (ts <= teamStartTime && (!closestBeforeTs || ts > closestBeforeTs)) {
+          closestBeforeTs = ts;
+        }
+      }
+    }
+    const effectiveStart = closestBeforeTs || teamStartTime;
+    for (const session of mainAgentSessions) {
+      for (const msg of session.messages || []) {
+        const ts = msg._timestamp;
+        if (!ts || ts < effectiveStart) continue;
+        if (teamEndTime && ts > teamEndTime) continue;
+        if (msg.role !== 'user') continue;
+        const content = msg.content;
+        if (Array.isArray(content)) {
+          const { textBlocks } = classifyUserContent(content);
+          for (const tb of textBlocks) {
+            if (tb.text && tb.text.trim()) {
+              entries.push({ type: 'user', text: tb.text, timestamp: ts });
+              hasUserMsg = true;
+            }
+          }
+        } else if (typeof content === 'string') {
+          const dispText = extractDisplayText(content);
+          if (dispText) {
+            entries.push({ type: 'user', text: dispText, timestamp: ts });
+            hasUserMsg = true;
+          }
+        }
+      }
+    }
+  }
+
+  // 策略 2：从 TeamCreate request 的 body.messages 直接提取
+  if (!hasUserMsg) {
+    const tcRaw = requests[team.requestIndex];
+    const tcReq = tcRaw?._slimmed ? restoreSlimmedEntry(tcRaw, requests) : tcRaw;
+    const tcMsgs = tcReq?.body?.messages || [];
+    for (let m = tcMsgs.length - 1; m >= 0; m--) {
+      if (tcMsgs[m].role !== 'user') continue;
+      const c = tcMsgs[m].content;
+      if (Array.isArray(c)) {
+        const { textBlocks } = classifyUserContent(c);
+        for (const tb of textBlocks) {
+          if (tb.text && tb.text.trim()) {
+            entries.push({ type: 'user', text: tb.text, timestamp: teamStartTime });
+            hasUserMsg = true;
+          }
+        }
+      } else if (typeof c === 'string') {
+        const dispText = extractDisplayText(c);
+        if (dispText) {
+          entries.push({ type: 'user', text: dispText, timestamp: teamStartTime });
+          hasUserMsg = true;
+        }
+      }
+      if (hasUserMsg) break;
+    }
+  }
+
+  // 策略 3 兜底：/clear 后 messages=[] 时，用首条 assistant 文本作为上下文
+  if (!hasUserMsg) {
+    for (let i = 0; i < teamRequests.length; i++) {
+      const resp = teamRequests[i].response?.body?.content;
+      if (!Array.isArray(resp)) continue;
+      for (const block of resp) {
+        if (block.type === 'text' && block.text && block.text.trim()) {
+          entries.push({ type: 'context', text: block.text.trim(), timestamp: teamRequests[i].response?.timestamp || teamRequests[i].timestamp });
+          hasUserMsg = true;
+          break;
+        }
+      }
+      if (hasUserMsg) break;
+    }
+  }
+
+  // 全局 tool_result 索引(team 范围内):并行 sub-agent 请求穿插,K+1 不可预测;
+  // 一次性建 id → result 索引,O(1) 查询。
+  const teamGlobalIndex = buildGlobalToolResultIndex(teamRequests);
+
+  // 收集 assistant + sub-agent 条目
+  for (let i = 0; i < teamRequests.length; i++) {
+    const req = teamRequests[i];
+    const respContent = req.response?.body?.content;
+    if (!Array.isArray(respContent) || respContent.length === 0) continue;
+    const cls = classifyRequest(req, teamRequests[i + 1]);
+    const isMA = isMainAgent(req);
+    const isSub = cls.type === 'SubAgent' || cls.type === 'Teammate';
+
+    if (isMA) {
+      entries.push({ type: 'assistant', content: respContent, timestamp: req.response?.timestamp || req.timestamp, requestIndex: startIdx + i, modelInfo });
+    } else if (isSub) {
+      const subToolResultMap = buildSubAgentResultMap(req, teamGlobalIndex);
+      entries.push({
+        type: 'sub-agent',
+        content: respContent,
+        toolResultMap: subToolResultMap,
+        label: cls.type === 'Teammate' ? formatTeammateLabel(cls.subType, req.body?.model) : formatRequestTag(cls.type, cls.subType),
+        isTeammate: cls.type === 'Teammate',
+        timestamp: req.timestamp,
+        requestIndex: startIdx + i,
+      });
+    }
+  }
+
+  // 按时间排序
+  entries.sort((a, b) => (a.timestamp || '').localeCompare(b.timestamp || ''));
+
+  // 提取每个 agent 的时间数据（用于状态卡片和甘特图）
+  const palette = ['#1668dc', '#52c41a', '#faad14', '#eb2f96', '#722ed1', '#13c2c2', '#fa541c', '#2f54eb'];
+  const teamAgents = [];
+  const agentMap = new Map();
+  const teamTotalStart = new Date(teamStartTime).getTime();
+  const teamTotalEnd = new Date(teamEndTime || Date.now()).getTime();
+  const leadSegments = [];
+  let lastLeadTs = teamTotalStart;
+  const _taskCreateSubjects = new Map();
+  const _taskOwnerMap = new Map();
+  let _taskCreateCounter = 1;
+
+  for (let i = 0; i < teamRequests.length; i++) {
+    const req = teamRequests[i];
+    const resp = req.response?.body?.content;
+    if (!Array.isArray(resp)) continue;
+    const tsStr = req.response?.timestamp || req.timestamp;
+    const ts = tsStr;
+    const tsMs = new Date(tsStr).getTime();
+    const isMA = isMainAgent(req);
+    for (const block of resp) {
+      if (block.type !== 'tool_use') continue;
+      const n = block.name;
+      const inp = typeof block.input === 'string' ? (() => { try { return JSON.parse(block.input); } catch { return {}; } })() : (block.input || {});
+      if (n === 'Agent' && inp.name) {
+        const idx = teamAgents.length;
+        teamAgents.push({
+          name: inp.name,
+          color: palette[idx % palette.length],
+          type: inp.subagent_type?.split(':').pop() || '',
+          spawnTime: ts,
+          claimTime: null,
+          doneTime: null,
+          shutdownTime: null,
+          taskSubject: null,
+          events: [{ ts: tsMs, label: 'spawn' }],
+        });
+        agentMap.set(inp.name, idx);
+      } else if (n === 'TaskCreate') {
+        if (inp.subject) {
+          const tId = String(inp.taskId || _taskCreateCounter++);
+          _taskCreateSubjects.set(tId, inp.subject);
+        }
+      } else if (n === 'TaskUpdate') {
+        const owner = inp.owner;
+        const taskId = inp.taskId != null ? String(inp.taskId) : null;
+        if (owner && taskId) _taskOwnerMap.set(taskId, owner);
+
+        let targetAg = null;
+        if (owner && agentMap.has(owner)) {
+          targetAg = teamAgents[agentMap.get(owner)];
+        } else if (taskId) {
+          const prevOwner = _taskOwnerMap.get(taskId);
+          if (prevOwner && agentMap.has(prevOwner)) {
+            targetAg = teamAgents[agentMap.get(prevOwner)];
+          } else {
+            const taskNum = parseInt(taskId, 10);
+            if (taskNum > 0 && taskNum <= teamAgents.length) {
+              targetAg = teamAgents[taskNum - 1];
+              _taskOwnerMap.set(taskId, targetAg.name);
+            }
+          }
+        }
+        if (targetAg) {
+          if (inp.status === 'in_progress' && !targetAg.claimTime) {
+            targetAg.claimTime = ts;
+            targetAg.events.push({ ts: tsMs, label: 'claim' });
+          }
+          if (inp.status === 'completed' && !targetAg.doneTime) {
+            targetAg.doneTime = ts;
+            targetAg.events.push({ ts: tsMs, label: 'done' });
+          }
+          if (taskId && _taskCreateSubjects.has(taskId) && !targetAg.taskSubject) {
+            targetAg.taskSubject = _taskCreateSubjects.get(taskId);
+          }
+        }
+      } else if (n === 'SendMessage') {
+        if (inp.message?.type === 'shutdown_request' && inp.to && agentMap.has(inp.to)) {
+          const ag = teamAgents[agentMap.get(inp.to)];
+          ag.shutdownTime = ts;
+          ag.events.push({ ts: tsMs, label: 'shutdown' });
+        } else if (inp.message?.type === 'shutdown_response' && agentMap.has(inp.to === 'team-lead' ? '' : inp.to)) {
+          // skip
+        } else if (inp.to && inp.to !== 'team-lead' && agentMap.has(inp.to)) {
+          teamAgents[agentMap.get(inp.to)].events.push({ ts: tsMs, label: 'msg-in' });
+        } else if (inp.to === 'team-lead') {
+          if (typeof inp.message === 'string' || (inp.message && !inp.message.type)) {
+            if (tsMs > lastLeadTs) {
+              leadSegments.push({ start: lastLeadTs, end: tsMs, label: 'report-received', color: '#52c41a' });
+              lastLeadTs = tsMs;
+            }
+          }
+        }
+      }
+      if (isMA && (n === 'TeamCreate' || n === 'TaskCreate' || n === 'Agent' || n === 'SendMessage' || n === 'TeamDelete')) {
+        const label = n === 'TeamCreate' ? 'create' : n === 'TaskCreate' ? 'tasks' : n === 'Agent' ? 'spawn' : n === 'SendMessage' ? 'msg' : 'cleanup';
+        if (tsMs > lastLeadTs) {
+          leadSegments.push({ start: lastLeadTs, end: tsMs, label, color: n === 'TeamDelete' ? '#52c41a' : n === 'SendMessage' ? '#ff4d4f' : '#1668dc' });
+          lastLeadTs = tsMs;
+        }
+      }
+    }
+    if (isMA) {
+      for (const block of resp) {
+        if (block.type === 'text' && block.text) {
+          if (tsMs > lastLeadTs) {
+            leadSegments.push({ start: lastLeadTs, end: tsMs, label: 'text', color: '#196ae1' });
+            lastLeadTs = tsMs;
+          }
+        } else if (block.type === 'thinking') {
+          if (tsMs > lastLeadTs) {
+            leadSegments.push({ start: lastLeadTs, end: tsMs, label: 'thinking', color: '#722ed1' });
+            lastLeadTs = tsMs;
+          }
+        }
+      }
+    }
+  }
+  // Second pass: teammate own tool calls (non-MainAgent requests)
+  for (let i = 0; i < teamRequests.length; i++) {
+    const req = teamRequests[i];
+    if (isMainAgent(req)) continue;
+    const resp = req.response?.body?.content;
+    if (!Array.isArray(resp)) continue;
+    const tsStr = req.response?.timestamp || req.timestamp;
+    const tsMs = new Date(tsStr).getTime();
+    const cls = classifyRequest(req, teamRequests[i + 1]);
+    const label = cls.type === 'Teammate' ? cls.subType : null;
+    if (label) {
+      let agIdx = agentMap.has(label) ? agentMap.get(label) : undefined;
+      if (agIdx === undefined) {
+        for (const [name, idx] of agentMap) {
+          if (label.includes(name) || name.includes(label)) { agIdx = idx; break; }
+        }
+      }
+      if (agIdx !== undefined) {
+        const ag = teamAgents[agIdx];
+        for (const block of resp) {
+          if (block.type === 'tool_use' && block.name) {
+            ag.events.push({ ts: tsMs, label: 'tool:' + block.name });
+          }
+        }
+      }
+    }
+  }
+
+  // 提取 <teammate-message> 报告内容
+  const teammateMessageRe = /<teammate-message\s+teammate_id="([^"]+)"[^>]*summary="([^"]*)"[^>]*>([\s\S]*?)<\/teammate-message>/g;
+  const seenTmMsg = new Set();
+  teamAgents.forEach(ag => { ag.teammateMessages = []; });
+  for (let i = 0; i < teamRequests.length; i++) {
+    const raw = teamRequests[i];
+    const req = raw?._slimmed ? restoreSlimmedEntry(raw, requests) : raw;
+    const msgs = req.body?.messages || [];
+    for (const m of msgs) {
+      if (m.role !== 'user' || !Array.isArray(m.content)) continue;
+      for (const b of m.content) {
+        if (b.type !== 'text' || !b.text) continue;
+        let match;
+        teammateMessageRe.lastIndex = 0;
+        while ((match = teammateMessageRe.exec(b.text)) !== null) {
+          const [, tid, summary, content] = match;
+          if (tid === 'system' || tid === 'team-lead') continue;
+          const dedupKey = tid + '|' + summary + '|' + content.trim().slice(0, 100);
+          if (seenTmMsg.has(dedupKey)) continue;
+          seenTmMsg.add(dedupKey);
+          for (const ag of teamAgents) {
+            if (tid === ag.name || tid.includes(ag.name) || ag.name.includes(tid)) {
+              if (summary && content.trim()) {
+                ag.teammateMessages.push({ summary, content: content.trim() });
+                const reqTs = req.timestamp || req.response?.timestamp;
+                entries.push({ type: 'teammate-report', agentName: ag.name, agentColor: getTeammateAvatar(ag.name).color, summary, content: content.trim(), timestamp: reqTs });
+              }
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // 闭合 lead 最后一段
+  if (lastLeadTs < teamTotalEnd) {
+    leadSegments.push({ start: lastLeadTs, end: teamTotalEnd, label: 'idle', color: '#333' });
+  }
+
+  // 从事件节点构建每个 agent 的分段 + 计算持续时间
+  const segColors = { spawn: '#555', claim: '#faad14', done: '#52c41a', shutdown: '#ff4d4f', 'msg-in': '#1668dc', report: '#52c41a', 'report-received': '#52c41a', text: '#196ae1', thinking: '#722ed1' };
+  teamAgents.forEach(ag => {
+    const start = new Date(ag.spawnTime).getTime();
+    const end = new Date(ag.doneTime || ag.shutdownTime || teamEndTime || Date.now()).getTime();
+    ag.duration = end - start;
+    ag.events.sort((a, b) => a.ts - b.ts);
+    ag.segments = [];
+    for (let e = 0; e < ag.events.length; e++) {
+      const ev = ag.events[e];
+      const nextTs = ag.events[e + 1]?.ts || (ag.shutdownTime ? new Date(ag.shutdownTime).getTime() : teamTotalEnd);
+      ag.segments.push({ start: ev.ts, end: nextTs, label: ev.label, color: segColors[ev.label] || (ev.label.startsWith('tool:') ? '#888' : ag.color) });
+    }
+  });
+
+  return { entries, teamAgents, leadSegments, teamTotalStart, teamTotalEnd, modelInfo, teamRequests };
+}

package/src/utils/teamSessionParser.js

@@ -0,0 +1,190 @@
+/**
+ * Parse team lifecycle (TeamCreate → TeamDelete) from requests.
+ * Pure function, no React/state dependencies.
+ *
+ * endReason 取值（详见 END_REASON 常量）：
+ *   'deleteConfirmed' — TeamDelete 返回 success（强证据，终态 ✓）
+ *   'successorCreate' — 新 TeamCreate 顶掉旧的（强证据，lead 已转移，等同 ✓）
+ *   'shutdownRequest' — 没看到 TeamDelete，但有 shutdown_request（弱证据，待 runtime 收敛）
+ *   'logTail'         — 纯 log 末尾兜底（弱证据，待 runtime 收敛）
+ *
+ * _hasInferredEnd 派生含义：**只要 endReason 存在且不是 deleteConfirmed 就为 true**
+ * ⚠️ 注意：此字段**同时覆盖强证据 (successorCreate) 和弱证据 (shutdownRequest/logTail)**，
+ * 仅用于"是否经过推断流程结束"的存在性提示，不能用来判断强弱。
+ * **判断强弱证据请用 `isStrongTerminal(team)`**（它是权威的 API）。
+ * 旧代码里的 `_inferredEnd` 已重命名为 `_hasInferredEnd` 以避免"inferred 一定是弱证据"的直觉误读。
+ */
+
+import { restoreSlimmedEntry } from './entry-slim.js';
+
+export const END_REASON = Object.freeze({
+  DELETE_CONFIRMED: 'deleteConfirmed',
+  SUCCESSOR_CREATE: 'successorCreate',
+  SHUTDOWN_REQUEST: 'shutdownRequest',
+  LOG_TAIL: 'logTail',
+});
+
+export function isStrongTerminal(team) {
+  if (!team) return false;
+  return team.endReason === END_REASON.DELETE_CONFIRMED
+      || team.endReason === END_REASON.SUCCESSOR_CREATE;
+}
+
+// 从 requests 中提取 Team 会话列表
+export function extractTeamSessions(requests) {
+  const teams = [];
+  let currentTeamIdx = -1; // 当前唯一打开的 team 在 teams[] 中的 index
+
+  // 查找 tool_use 对应的 tool_result（在后续 request 的 messages 中）
+  // 搜索窗口扩大到 10 以应对空行/非主agent请求插入导致的距离增大
+  function findToolResult(toolUseId, fromRequestIdx) {
+    for (let j = fromRequestIdx + 1; j < requests.length && j <= fromRequestIdx + 10; j++) {
+      const entry = requests[j]?._slimmed ? restoreSlimmedEntry(requests[j], requests) : requests[j];
+      const msgs = entry?.body?.messages;
+      if (!Array.isArray(msgs)) continue;
+      for (const msg of msgs) {
+        const blocks = msg.role === 'user' && Array.isArray(msg.content) ? msg.content : [];
+        for (const b of blocks) {
+          if (b.type === 'tool_result' && b.tool_use_id === toolUseId) {
+            return typeof b.content === 'string' ? b.content : JSON.stringify(b.content || '');
+          }
+        }
+      }
+    }
+    return null;
+  }
+
+  function isDeleteSuccessful(resultText) {
+    // tool_result 可能因 entry-slim/delta 压缩而不可达，默认视为成功
+    // 只有明确包含 "Cannot cleanup" 才判定失败
+    if (!resultText) return true;
+    if (resultText.includes('"success":true') || resultText.includes('"success": true')) return true;
+    if (resultText.includes('Cleaned up')) return true;
+    if (resultText.includes('Cannot cleanup')) return false;
+    // 没有明确失败标记的默认视为成功
+    return true;
+  }
+
+  for (let i = 0; i < requests.length; i++) {
+    const req = requests[i];
+    const respContent = req.response?.body?.content;
+    if (!Array.isArray(respContent)) continue;
+    for (const block of respContent) {
+      if (block.type !== 'tool_use') continue;
+      const name = block.name;
+      const input = typeof block.input === 'string' ? (() => { try { return JSON.parse(block.input); } catch { return {}; } })() : (block.input || {});
+      if (name === 'TeamCreate') {
+        // 检查 TeamCreate 是否成功（tool_result 中不能有错误标记）
+        const createResult = findToolResult(block.id, i);
+        if (createResult && (createResult.includes('"error":') || createResult.includes('"error" :') || createResult.includes('Already leading team'))) continue;
+        const teamName = input.team_name || input.teamName || 'unknown';
+        const ts = req.timestamp || req.response?.timestamp;
+        // 新 TeamCreate 出现时，自动关闭前一个未关闭的 team（避免孤立）
+        if (currentTeamIdx >= 0 && !teams[currentTeamIdx].endTime) {
+          teams[currentTeamIdx].endTime = ts;
+          teams[currentTeamIdx].endRequestIndex = Math.max(teams[currentTeamIdx].requestIndex, i - 1);
+          teams[currentTeamIdx].endReason = END_REASON.SUCCESSOR_CREATE;
+          teams[currentTeamIdx]._hasInferredEnd = true;
+        }
+        const team = { name: teamName, startTime: ts, endTime: null, requestIndex: i, endRequestIndex: null, taskCount: 0, teammateCount: 0, _teammates: new Set() };
+        teams.push(team);
+        currentTeamIdx = teams.length - 1;
+      } else if (name === 'TeamDelete') {
+        const resultText = findToolResult(block.id, i);
+        if (!isDeleteSuccessful(resultText)) continue; // 失败的 TeamDelete 不关闭 team
+        const ts = req.timestamp || req.response?.timestamp;
+        if (currentTeamIdx < 0) {
+          // Cross-file: TeamCreate 在上一个 JSONL 中，从 tool_result 反向推断 team
+          let teamName = 'unknown';
+          try { const parsed = JSON.parse(resultText); teamName = parsed.team_name || teamName; } catch {}
+          // 回溯寻找最早的关联 Agent 调用作为 startTime
+          let startIdx = 0;
+          let startTs = requests[0]?.timestamp || requests[0]?.response?.timestamp;
+          for (let k = 0; k < i; k++) {
+            const kResp = requests[k]?.response?.body?.content;
+            if (!Array.isArray(kResp)) continue;
+            for (const kb of kResp) {
+              if (kb.type === 'tool_use' && kb.name === 'Agent') {
+                const kInp = typeof kb.input === 'string' ? (() => { try { return JSON.parse(kb.input); } catch { return {}; } })() : (kb.input || {});
+                if ((kInp.team_name || kInp.teamName) === teamName) {
+                  startIdx = k;
+                  startTs = requests[k]?.timestamp || requests[k]?.response?.timestamp;
+                  break;
+                }
+              }
+            }
+            if (startIdx > 0) break;
+          }
+          const team = { name: teamName, startTime: startTs, endTime: ts, endReason: END_REASON.DELETE_CONFIRMED, requestIndex: startIdx, endRequestIndex: i, taskCount: 0, teammateCount: 0, _teammates: new Set(), _inferredStart: true };
+          // 回填 teammate 和 task 计数
+          for (let k = startIdx; k < i; k++) {
+            const kResp = requests[k]?.response?.body?.content;
+            if (!Array.isArray(kResp)) continue;
+            for (const kb of kResp) {
+              if (kb.type !== 'tool_use') continue;
+              if (kb.name === 'Agent') {
+                const kInp = typeof kb.input === 'string' ? (() => { try { return JSON.parse(kb.input); } catch { return {}; } })() : (kb.input || {});
+                const an = kInp.name || '';
+                if (!team._teammates.has(an)) { team._teammates.add(an); team.teammateCount++; }
+              } else if (kb.name === 'TaskCreate' || kb.name === 'TaskUpdate') {
+                team.taskCount++;
+              }
+            }
+          }
+          teams.push(team);
+          continue;
+        }
+        teams[currentTeamIdx].endTime = ts;
+        teams[currentTeamIdx].endRequestIndex = i;
+        teams[currentTeamIdx].endReason = END_REASON.DELETE_CONFIRMED;
+        currentTeamIdx = -1; // 清理：team 已关闭
+      } else if (name === 'SendMessage') {
+        // 跟踪 shutdown_request 作为备用结束信号
+        if (currentTeamIdx >= 0 && input.message?.type === 'shutdown_request') {
+          const shutdownTs = req.timestamp || req.response?.timestamp;
+          teams[currentTeamIdx]._lastShutdownTime = shutdownTs;
+          teams[currentTeamIdx]._lastShutdownRequestIdx = i;
+        }
+      } else if (name === 'TaskCreate' || name === 'TaskUpdate') {
+        if (currentTeamIdx >= 0) teams[currentTeamIdx].taskCount++;
+      } else if (name === 'Agent') {
+        const teamName = input.team_name || input.teamName;
+        const agentName = input.name || '';
+        let targetIdx = -1;
+        if (teamName) {
+          // 按 team_name 精确匹配（使用反向搜索，优先匹配最近的同名 team）
+          for (let ti = teams.length - 1; ti >= 0; ti--) {
+            if (teams[ti].name === teamName && !teams[ti].endTime) { targetIdx = ti; break; }
+          }
+        }
+        // fallback：如果没有 team_name 但有唯一打开的 team
+        if (targetIdx < 0 && currentTeamIdx >= 0) targetIdx = currentTeamIdx;
+        if (targetIdx >= 0) {
+          const t = teams[targetIdx];
+          if (!t._teammates.has(agentName)) { t._teammates.add(agentName); t.teammateCount++; }
+        }
+      }
+    }
+  }
+  // 后处理：为未关闭的 team 推断 endTime
+  for (const team of teams) {
+    if (team.endTime) continue;
+    // 优先使用 shutdown_request 时间戳，其次使用最后一条请求的时间戳
+    if (team._lastShutdownTime) {
+      team.endTime = team._lastShutdownTime;
+      team.endRequestIndex = team._lastShutdownRequestIdx;
+      team.endReason = END_REASON.SHUTDOWN_REQUEST;
+      team._hasInferredEnd = true;
+    } else {
+      const lastReq = requests[requests.length - 1];
+      const lastTs = lastReq?.response?.timestamp || lastReq?.timestamp;
+      if (lastTs && team.startTime !== lastTs) {
+        team.endTime = lastTs;
+        team.endRequestIndex = requests.length - 1;
+        team.endReason = END_REASON.LOG_TAIL;
+        team._hasInferredEnd = true;
+      }
+    }
+  }
+  return teams;
+}