@tea-agent/loop-agent 0.38.0-next.1 → 0.38.1

package/dist/worker/console/chat/pi-runtime.js

@@ -45,24 +45,26 @@ import { RUNTIME_CONTEXT_TEXT_MAX, redactRuntimeText, } from "./runtime-context.
  * Project governance (operator-only policy, allowedPaths/forbiddenPaths,
  * writer writeSet, taskKind routing, verification matrix, DAG recovery
  * commands, closeout) lives in the loaded target-project AGENTS.md. The
- * prompt below covers: Operator identity, the real tool surface (operator_*
- * first + Pi tools, obey AGENTS.md), denied non-Pi runtimes, safe-* probes,
- * init/init-upgrade fallback for uninitialized repos, DAG supervision with
- * 15/30/60s adaptive polling (operationGet/status/dagReport/dagDoctor), R2
- * recovery (fresh eligible dagRerunPlan → dagRerun; ineligible → same-task
- * rerun/advance, resume, Worker retry) and G2 bounded writeSet auto-approval.
+ * prompt below covers: Operator identity, the real tool surface (typed
+ * operator tools first + Pi tools, obey AGENTS.md), denied non-Pi runtimes,
+ * safe-* probes, init/init-upgrade fallback for uninitialized repos, DAG
+ * supervision with 60/90/120/180s adaptive polling
+ * (operationGet/status/dagReport/dagDoctor/operationWait), R2 recovery
+ * (dagReport → dagRerunPlan → dagRerun; ineligible → standaloneTaskRerun or
+ * workerTaskRetry, never dagResume) and G2 bounded writeSet auto-approval.
  *
  * The old Human Gate tutorial paragraphs (prepare + browser Human Gate,
  * "confirmDagConfirmation is a human-only action", the long "Recovery default
  * order" table) are REMOVED — bounded DAGs start and recover autonomously
- * (AC-01: ≤ 1900 chars and ≤ 80% of the 2498-char baseline).
+ * (AC-01: ≤ 2500 chars; 2498-slimming ratio retired 2026-08-18).
  */
 export const OPERATOR_CHAT_SYSTEM_PROMPT_BASE = [
     "You are General Operator Chat.",
-    "Use operator_* tools first. Pi read/write/edit/bash/grep/find/ls are available; obey repository AGENTS.md. apply_patch, full-tools, shell and coding-chat are denied. Prefer safe-read/safe-grep for sensitive probes.",
+    "Use operator tools first (dagReport, dagRerunPlan, dagRerun). Pi read/write/edit/bash/grep/find/ls are available; obey repository AGENTS.md. apply_patch, full-tools, shell and coding-chat are denied. Prefer safe-read/safe-grep for probes.",
     "No harness and asked to init: `loop-agent init instructions --repo-root .`, then `loop-agent init --repo-root . --profile full --merge`; verify with doctor, inspect and docs audit. Updates: `loop-agent init upgrade --repo-root . --json` until stable; `loop-agent init check-update` is read-only.",
     "Long DAGs: prepareDagExecution → runDag → operationId. Never foreground-Bash task advance, tail/head pipes or nohup/Start-Process/start; do not end on accepted/queued/running or an operationId — NOT completion. Supervise operationGet/status/dagReport/dagDoctor/operationWait with 60s → 90s → 120s → 180s backoff; reset to 60s on state change; 30-60s re-checks when stall suspected. Every operationWait continuation MUST use afterSeq=previous nextSeq (prefer recommendedNextCall); never reuse an older cursor. Heartbeats are not meaningful progress.",
-    "On failure consume terminal runSummary first. If progress exists, wait; else use a fresh dagRerunPlan; when ineligible use same-task rerun/advance, resume, or Worker retry. A run-failed task without an open gate is terminal: do not re-advance a run-failed task. Before run start, two identical lifecycleState/blocker/revision/DAG-hash observations mean no progress: stop and report after one bounded probe; never loop identical bash/read/grep. Auto-approve only bounded writeSet inside allowedPaths, outside forbiddenPaths, with structured verification.",
+    "On failure consume terminal runSummary first. If progress exists, wait; else dagReport then dagRerunPlan(fromNode=primaryFailure.nodeId); eligible → dagRerun (node rerun only: reruns the failed subgraph, keeps prior successes). If plan ineligible (unsafe-shell subgraph, binding/workspace drift): Worker Failed → workerTaskRetry; standalone → standaloneTaskRerun after contract adopt (regenerates the whole task, not node continue). Do not call dagResume. A run-failed task without an open gate is terminal: do not re-advance a run-failed task. Before run start, two identical lifecycleState/blocker/revision/DAG-hash observations mean no progress: stop and report after one bounded probe; never loop identical bash/read/grep. Auto-approve only bounded writeSet inside allowedPaths, outside forbiddenPaths, with structured verification.",
+    "Iterate toward the goal in bounded rounds: first summarize the previous round's error in one line (wrong fix, wrong node, or environment), fix its root cause — not the symptom — then rerun the failed node with a fresh plan. Never resubmit an unchanged fix; after two rounds failing the same way, stop and report evidence and remaining routes.",
     "Continue until success, user stop, or no safe recovery remains; then stop and report failure/evidence. Never create a new task for a transient failure or replace repair-pi with direct edits.",
 ].join("\n");
 /** Compose the inspectable system prompt actually injected into Operator Chat. */
@@ -151,6 +153,63 @@ export function computeOperatorChatActiveToolNames(session) {
     }
     return extras.length > 0 ? [...baseline, ...extras] : baseline;
 }
+const OPERATOR_CHAT_SESSION_EXCLUDE_TOOLS = Object.freeze([
+    "apply_patch",
+    "apply-patch",
+    "full-tools",
+    "full_tools",
+    "coding-chat",
+    "coding_chat",
+    "shell",
+]);
+function createConsoleExtensionBindings() {
+    return {
+        mode: "rpc",
+        onError: (error) => {
+            const message = error instanceof Error
+                ? error.message
+                : typeof error === "object" &&
+                    error &&
+                    "error" in error &&
+                    typeof error.error === "string"
+                    ? String(error.error)
+                    : String(error);
+            process.stderr.write(`[console] extension: ${message}\n`);
+        },
+        uiContext: {
+            select: async () => undefined,
+            confirm: async () => false,
+            input: async () => undefined,
+            editor: async () => undefined,
+            notify: () => undefined,
+            onTerminalInput: () => () => undefined,
+            setStatus: () => undefined,
+            setWorkingMessage: () => undefined,
+            setWorkingVisible: () => undefined,
+            setWorkingIndicator: () => undefined,
+            setHiddenThinkingLabel: () => undefined,
+            setWidget: () => undefined,
+            setFooter: () => undefined,
+            setHeader: () => undefined,
+            setTitle: () => undefined,
+            custom: async () => undefined,
+            pasteToEditor: () => undefined,
+            setEditorText: () => undefined,
+            getEditorText: () => "",
+            addAutocompleteProvider: () => undefined,
+            setEditorComponent: () => undefined,
+            getEditorComponent: () => undefined,
+        },
+    };
+}
+async function bindSessionExtensions(session) {
+    if (typeof session.bindExtensions !== "function")
+        return;
+    await session.bindExtensions(createConsoleExtensionBindings());
+}
+function pinOperatorChatTools(session) {
+    session.setActiveToolsByName(computeOperatorChatActiveToolNames(session));
+}
 /**
  * Build Pi custom ToolDefinition objects for every whitelisted operator action.
  * Each tool's execute() routes into the operator action dispatcher (Gate 3).
@@ -505,6 +564,29 @@ export function projectRuntimeSnapshot(input) {
         })),
         diagnostics: pkg.diagnostics.map((diag) => field(diag, 400) ?? ""),
     });
+    const projectMcpTool = (tool) => ({
+        name: field(tool.name, 200) ?? "",
+        description: field(tool.description, 600) ?? "",
+        ...(tool.server ? { server: field(tool.server, 200) } : {}),
+        source: field(tool.source, 200) ?? "",
+        scope: tool.scope,
+        ...(tool.path ? { path: field(tool.path, 400) } : {}),
+        active: tool.active,
+    });
+    const projectMcp = (mcp) => ({
+        servers: mcp.servers.map((server) => ({
+            name: field(server.name, 200) ?? "",
+            scope: server.scope,
+            status: server.status,
+            enabled: server.enabled,
+            ...(server.transport ? { transport: field(server.transport, 80) } : {}),
+            ...(server.command ? { command: field(server.command, 400) } : {}),
+            ...(server.url ? { url: field(server.url, 400) } : {}),
+            ...(server.configPath ? { configPath: field(server.configPath, 400) } : {}),
+            tools: server.tools.map(projectMcpTool),
+        })),
+        unassignedTools: mcp.unassignedTools.map(projectMcpTool),
+    });
     const projectDiagnostic = (diag) => ({
         type: diag.type,
         ...(diag.code ? { code: diag.code } : {}),
@@ -560,6 +642,7 @@ export function projectRuntimeSnapshot(input) {
         skills: input.skills.map(projectSkill),
         extensions: input.extensions.map(projectExtension),
         packages: input.packages.map(projectPackage),
+        mcp: projectMcp(input.mcp ?? { servers: [], unassignedTools: [] }),
         diagnostics: input.diagnostics.map(projectDiagnostic),
         hasBash: input.hasBash,
     };
@@ -903,36 +986,16 @@ export class ConsolePiRuntime {
         const customTools = await this.loadCustomTools();
         if (this.disposedSessions.has(sessionId))
             return;
-        // The SDK filters BOTH built-in tools and customTools against
-        // `tools` (allowed-tool names) inside _refreshToolRegistry:
-        //   isAllowedTool = (!allowedToolNames || allowedToolNames.has(name))
-        //                    && !excludedToolNames.has(name)
-        // Passing only OPERATOR_CHAT_BUILTIN_EXPLORE_TOOLS here silently dropped
-        // every custom operator tool (prepareDagExecution / runDag /
-        // operationWait / safe-read / git-status / ...) from the registry, so the
-        // model could only ever see bash/read/write/edit/grep/find/ls. The
-        // allowlist must cover the full tool surface that is later activated via
-        // setActiveToolsByName(computeOperatorChatActiveToolNames(session)) —
-        // operator actions + built-in explore tools + safe explore tools.
-        // Hard write/coding channels stay blocked via excludeTools below (they
-        // are removed even when present in the allowed list).
+        // pi-web parity: do NOT pass `tools`. A closed allowlist becomes
+        // SDK allowedToolNames and filters extension MCP tools out of the
+        // registry before Gate 2 can re-add them. Operator/safe customTools
+        // still register via customTools; non-Pi write channels stay blocked
+        // by excludeTools. After create, bindExtensions emits session_start
+        // so MCP adapters can register, then pin the active set.
         const { session } = await this.bindings.createSessionFromServices({
             services,
             sessionManager: init.sessionManager,
-            tools: [
-                ...OPERATOR_CHAT_BUILTIN_EXPLORE_TOOLS,
-                ...OPERATOR_CHAT_ALLOWED_TOOLS,
-                ...OPERATOR_CHAT_SAFE_EXPLORE_TOOL_IDS,
-            ],
-            excludeTools: [
-                "apply_patch",
-                "apply-patch",
-                "full-tools",
-                "full_tools",
-                "coding-chat",
-                "coding_chat",
-                "shell",
-            ],
+            excludeTools: [...OPERATOR_CHAT_SESSION_EXCLUDE_TOOLS],
             ...(customTools.length > 0 ? { customTools } : {}),
             ...(resolvedModel ? { model: resolvedModel } : {}),
         });
@@ -945,7 +1008,8 @@ export class ConsolePiRuntime {
             }
             return;
         }
-        session.setActiveToolsByName(computeOperatorChatActiveToolNames(session));
+        await bindSessionExtensions(session);
+        pinOperatorChatTools(session);
         // Register then re-check dispose race: a concurrent dispose must win.
         this.sessions.set(sessionId, session);
         this.sessionManagers.set(sessionId, init.sessionManager);
@@ -1616,6 +1680,24 @@ export class ConsolePiRuntime {
                 retryable: true,
             });
         }
+        const { readMcpInventory } = await import("./mcp-inventory.js");
+        let mcp = { servers: [], unassignedTools: [] };
+        try {
+            mcp = await readMcpInventory({
+                agentDir: await safeGetAgentDir(this.bindings),
+                cwd: this.options.cwd,
+                tools: session.getAllTools?.() ?? [],
+                activeToolNames: session.getActiveToolNames(),
+            });
+        }
+        catch (error) {
+            diagnostics.push({
+                type: "error",
+                code: "MCP_INVENTORY_FAILED",
+                message: error instanceof Error ? error.message : String(error),
+                retryable: true,
+            });
+        }
         return projectRuntimeSnapshot({
             sessionId,
             revision: this.revisions.get(sessionId) ?? 0,
@@ -1651,6 +1733,7 @@ export class ConsolePiRuntime {
             skills,
             extensions,
             packages,
+            mcp,
             diagnostics,
             hasBash: true,
         });
@@ -1833,29 +1916,15 @@ export class ConsolePiRuntime {
             : undefined;
         assertNoWriteToolInList(OPERATOR_CHAT_ALLOWED_TOOLS);
         const customTools = await this.loadCustomTools();
-        // Same allowlist rationale as materializeSession: the SDK filters
-        // customTools against `tools`, so the allowed names must cover the full
-        // operator + explore surface or every custom tool is silently dropped.
         const { session } = await this.bindings.createSessionFromServices({
             services,
             sessionManager: init.sessionManager,
-            tools: [
-                ...OPERATOR_CHAT_BUILTIN_EXPLORE_TOOLS,
-                ...OPERATOR_CHAT_ALLOWED_TOOLS,
-                ...OPERATOR_CHAT_SAFE_EXPLORE_TOOL_IDS,
-            ],
-            excludeTools: [
-                "apply_patch",
-                "apply-patch",
-                "full-tools",
-                "full_tools",
-                "coding-chat",
-                "coding_chat",
-                "shell",
-            ],
+            excludeTools: [...OPERATOR_CHAT_SESSION_EXCLUDE_TOOLS],
             ...(customTools.length > 0 ? { customTools } : {}),
             ...(resolvedModel ? { model: resolvedModel } : {}),
         });
+        await bindSessionExtensions(session);
+        pinOperatorChatTools(session);
         return {
             session,
             modelRuntime,
@@ -1950,6 +2019,32 @@ export class ConsolePiRuntime {
             if (options?.signal?.aborted) {
                 return;
             }
+            const emitContextUsage = () => {
+                try {
+                    const contextUsage = session.getSessionStats?.()?.contextUsage;
+                    if (!contextUsage)
+                        return;
+                    if (contextUsage.contextWindow <= 0 &&
+                        contextUsage.percent === null &&
+                        contextUsage.tokens === null) {
+                        return;
+                    }
+                    onEvent({
+                        type: "usage",
+                        sessionId,
+                        usage: {
+                            inputTokens: 0,
+                            outputTokens: 0,
+                            totalTokens: 0,
+                            contextUsage,
+                        },
+                    });
+                }
+                catch {
+                    // Stats getter is best-effort; never break the event stream.
+                }
+            };
+            emitContextUsage();
             unsub = session.subscribe((event) => {
                 const mapped = mapSdkEvent(sessionId, event);
                 if (mapped)
@@ -1962,31 +2057,13 @@ export class ConsolePiRuntime {
                     const usage = extractUsageSample(event);
                     if (usage)
                         onEvent({ type: "usage", sessionId, usage });
+                    emitContextUsage();
                 }
-                // Context usage rides the usage event: refresh on agent_settled so the
-                // bar reflects the post-turn context window fill (pi-web parity).
-                if (event.type === "agent_settled") {
-                    try {
-                        const stats = session.getSessionStats?.();
-                        const contextUsage = stats?.contextUsage;
-                        if (contextUsage) {
-                            onEvent({
-                                type: "usage",
-                                sessionId,
-                                usage: {
-                                    inputTokens: 0,
-                                    outputTokens: 0,
-                                    totalTokens: 0,
-                                    ...(contextUsage.tokens === null
-                                        ? {}
-                                        : { contextUsage }),
-                                },
-                            });
-                        }
-                    }
-                    catch {
-                        // Stats getter is best-effort; never break the event stream.
-                    }
+                // Keep the context fill bar live through the turn (pi-web SessionInfoBar).
+                if (event.type === "agent_start" ||
+                    event.type === "agent_settled" ||
+                    event.type === "tool_execution_end") {
+                    emitContextUsage();
                 }
             });
             options?.signal?.addEventListener("abort", onAbort);

package/dist/worker/console/chat/repo-walk.js

@@ -77,6 +77,7 @@ function isBinaryExt(p) {
 export async function walkRepoFiles(repoRoot, options) {
     const skipSensitive = options?.skipSensitive ?? true;
     const maxFiles = options?.maxFiles ?? 5000;
+    const includeDirs = options?.includeDirs ?? false;
     const filter = options?.glob ? globToRe(options.glob) : undefined;
     const out = [];
     async function walk(dir, prefix) {
@@ -96,7 +97,15 @@ export async function walkRepoFiles(repoRoot, options) {
             if (entry.isDirectory()) {
                 if (SKIP_DIRS.has(name))
                     continue;
-                await walk(path.join(dir, name), `${prefix}${name}/`);
+                const dirRelative = `${prefix}${name}/`;
+                if (includeDirs) {
+                    const dirEntry = {
+                        abs: path.join(dir, name),
+                        repoRelative: dirRelative,
+                    };
+                    out.push(dirEntry);
+                }
+                await walk(path.join(dir, name), dirRelative);
                 continue;
             }
             if (!entry.isFile())

package/dist/worker/console/chat/routes.js

@@ -51,7 +51,7 @@ function turnSummary(turn) {
 function isTerminalTurnState(state) {
     return state === "settled" || state === "aborted" || state === "failed";
 }
-const DEFAULT_ABORT_WAIT_MS = 8_000;
+const DEFAULT_ABORT_WAIT_MS = 2_500;
 /** Parse Chat's `<epoch>:<seq>` SSE cursor. Legacy `<sessionId>:<seq>` has
  * the same wire shape; its prefix intentionally fails the current process
  * epoch comparison and triggers safe snapshot recovery (M5.1). */
@@ -1642,16 +1642,27 @@ async function handleChatFiles(res, deps, sessionId, query) {
     if (!(await requireChatSession(res, deps, sessionId)))
         return;
     const q = query.trim().toLowerCase();
-    const files = (await walkRepoFiles(deps.appData.repoRoot, {
+    const walked = await walkRepoFiles(deps.appData.repoRoot, {
         skipSensitive: true,
         maxFiles: 5000,
-    }))
-        .map((entry) => entry.repoRelative)
-        .filter((file) => !isSensitivePath(file) && (!q || file.toLowerCase().includes(q)))
-        .sort((a, b) => a.localeCompare(b))
+        includeDirs: true,
+    });
+    const entries = walked
+        .filter((entry) => !isSensitivePath(entry.repoRelative) &&
+        (!q || entry.repoRelative.toLowerCase().includes(q)))
+        .sort((a, b) => {
+        const aDir = a.repoRelative.endsWith("/");
+        const bDir = b.repoRelative.endsWith("/");
+        if (aDir !== bDir)
+            return aDir ? -1 : 1;
+        return a.repoRelative.localeCompare(b.repoRelative);
+    })
         .slice(0, 50)
-        .map((path) => ({ path }));
-    sendJson(res, 200, { ok: true, files });
+        .map((entry) => ({
+        path: entry.repoRelative,
+        isDir: entry.repoRelative.endsWith("/"),
+    }));
+    sendJson(res, 200, { ok: true, files: entries });
 }
 export async function handleChatCommands(res, deps, sessionId) {
     try {

package/dist/worker/console/chat/semantic-activity.js

@@ -39,9 +39,11 @@ const OPERATION_TITLES = {
     dagDoctor: "执行诊断",
     dagReport: "执行结果",
     dagRerunPlan: "恢复评估",
+    dagRerun: "从节点续跑",
     dagInterruptEligibility: "中止资格",
-    standaloneTaskRerun: "恢复执行",
-    workerTaskRetry: "重试任务",
+    standaloneTaskRerun: "完整重跑任务",
+    workerTaskRetry: "重试 Worker 任务",
+    workerPoolDoctor: "任务池诊断",
     promoteRun: "任务推进",
     status: "任务状态",
 };
@@ -96,10 +98,20 @@ const TOOL_SEMANTICS = {
         success: "中止资格已经确认",
         error: "当前运行不能协作中止",
     },
+    dagRerun: {
+        running: "正在从失败节点续跑",
+        success: "已经从失败节点继续执行",
+        error: "从失败节点续跑时遇到问题",
+    },
     standaloneTaskRerun: {
-        running: "正在从失败位置恢复执行",
-        success: "已经从失败位置继续执行",
-        error: "从失败位置恢复执行时遇到问题",
+        running: "正在完整重跑整单任务",
+        success: "已经启动完整重跑",
+        error: "完整重跑任务时遇到问题",
+    },
+    workerPoolDoctor: {
+        running: "正在读取任务池状态",
+        success: "任务池状态已经读取",
+        error: "读取任务池状态时遇到问题",
     },
     promoteRun: {
         running: "正在推进任务状态",

package/dist/worker/console/chat/turn-process.js

@@ -92,36 +92,25 @@ function sortToolsStable(tools) {
     });
 }
 /**
- * Flush buffered consecutive tools into process items. Semantic operator
- * tools stay as individual activity events; plain tools group into a
- * `tool-group` ("并行调用 · N 项") when two or more land back to back.
+ * Flush buffered consecutive tools into process items (pi-web aligned:
+ * strict sequential flow, no synthetic grouping). Semantic operator tools
+ * stay as individual activity events; plain tools each render as their own
+ * card in stable server order (eventSeq first, createdAt fallback).
  * Thinking/text/activity boundaries break the buffer upstream.
  */
 function flushToolBuffer(processItems, buffer) {
     if (buffer.length === 0)
         return;
     const sorted = sortToolsStable(buffer);
-    let plainGroup = [];
-    const flushPlain = () => {
-        if (plainGroup.length === 1) {
-            processItems.push({ kind: "tool", tool: plainGroup[0] });
-        }
-        else if (plainGroup.length > 1) {
-            processItems.push({ kind: "tool-group", tools: plainGroup });
-        }
-        plainGroup = [];
-    };
     for (const tool of sorted) {
         const activity = semanticActivityForTool(tool);
         if (activity) {
-            flushPlain();
             processItems.push({ kind: "activity", activity });
         }
         else {
-            plainGroup.push(tool);
+            processItems.push({ kind: "tool", tool });
         }
     }
-    flushPlain();
 }
 function emitProcessBlocks(blocks, group, processItems, usedToolIds) {
     let buffer = [];
@@ -227,9 +216,6 @@ export function buildTurnProcessGroups(input) {
             current = startGroup(`assistant-${message.id}`);
         current.assistants.push(message);
     }
-    if (groups.length === 0 && input.toolCalls.length > 0) {
-        groups.push(emptyGroup("orphan-tools"));
-    }
     const assigned = new Set();
     const assistantToGroup = new Map();
     for (const group of groups) {
@@ -276,17 +262,12 @@ export function buildTurnProcessGroups(input) {
             const end = next?.user?.createdAt ?? Number.POSITIVE_INFINITY;
             return tool.createdAt >= start && tool.createdAt < end;
         });
+        // Time window only. Never dump unmatched tools onto the latest group:
+        // that is how a previous turn's bash cards jump under a new prompt.
         if (windowGroup) {
             windowGroup.tools.push(tool);
             assigned.add(tool.id);
         }
-        else {
-            const lastGroup = groups.at(-1);
-            if (lastGroup) {
-                lastGroup.tools.push(tool);
-                assigned.add(tool.id);
-            }
-        }
     }
     for (const group of groups) {
         group.tools.sort((a, b) => {
@@ -303,6 +284,14 @@ export function buildTurnProcessGroups(input) {
     }
     return groups;
 }
+/** Keep the most recent complete turns. Slice groups, never raw messages. */
+export function selectRecentTurnGroups(groups, limit) {
+    if (limit <= 0)
+        return [];
+    if (groups.length <= limit)
+        return [...groups];
+    return groups.slice(-limit);
+}
 export function processGroupSummary(tools, options) {
     const count = tools.length;
     const thinkingCount = options?.thinkingCount ?? 0;
@@ -324,7 +313,7 @@ export function processGroupSummary(tools, options) {
         parts.push("运行中");
     return { count, errorCount, runningCount, stepCount, label: parts.join(" · ") };
 }
-/** Summary over rendered process items (tool-group tools count individually). */
+/** Summary over rendered process items. */
 export function summarizeProcessItems(items) {
     const tools = [];
     let thinkingCount = 0;
@@ -344,10 +333,8 @@ export function summarizeProcessItems(items) {
             else if (item.activity.kind === "progress")
                 activityRunningCount += 1;
         }
-        else if (item.kind === "tool")
-            tools.push(item.tool);
         else
-            tools.push(...item.tools);
+            tools.push(item.tool);
     }
     return processGroupSummary(tools, {
         thinkingCount,