@bubblebrain-ai/bubble 0.0.58 → 0.0.60

package/dist/tui/controller/controller.js

@@ -7,8 +7,9 @@ import { AgentRunInputQueue } from "../../agent/input-controller.js";
 import { OverlayRequestController } from "./overlay-controller.js";
 import { SessionTransitionController } from "./session-transition.js";
 import { moveStatusMessageToEnd, nextDisplayMessageKey, setUserInputStatus, snapshotDisplayParts, } from "../model/display-history.js";
-import { accumulateLiveSubagentUpdate, collectSubagentGroups, mergeSubagentSnapshotsIntoMessages, pruneSettledLiveSubagentTools, } from "../model/subagent-view.js";
+import { applySubagentUpdateToMessages, collectSubagentGroups, mergeSubagentSnapshotsIntoMessages, } from "../model/subagent-view.js";
 import { reconstructDisplayMessages } from "../model/display-reconstruct.js";
+import { applyTaskLifecycleToMessages, landTaskLifecycles, mergeTaskLifecycleIntoLiveTools, taskLifecycleDisplayMessage, UNMATCHED_LAUNCH, } from "../model/task-lifecycle.js";
 import { buildImageContentParts, buildImageContentPartsFromDisplayText } from "../model/image-paste.js";
 import { displayImagesFromPayload, formatImageUserDisplayText } from "../image-display.js";
 import { GoalRuntimeController } from "./goal-runtime-controller.js";
@@ -29,6 +30,7 @@ export class BubbleTuiController {
     queue = createInputQueueState();
     sessionTransition;
     startedAtMs;
+    turnStartedAt;
     goalRuntime;
     taskRuntime;
     pendingTaskAnnouncements = new Map();
@@ -36,9 +38,6 @@ export class BubbleTuiController {
     transcript = [];
     runActive = false;
     runState = null;
-    /** Background subagent updates can outlive the provider turn that launched
-     * them. Keep their latest synthetic tool snapshot in the live trace. */
-    liveSubagentTools = new Map();
     /** Provider-turn accumulators for true child-session inspection. */
     childRuns = new Map();
     activeInputController = null;
@@ -51,10 +50,7 @@ export class BubbleTuiController {
     constructor(deps) {
         this.deps = deps;
         this.sessionManager = deps.sessionManager;
-        this.transcript = [
-            ...reconstructDisplayMessages([...deps.agent.messages]),
-            ...restoredTaskLifecycleMessages(this.sessionManager),
-        ];
+        this.transcript = landTaskLifecycles(reconstructDisplayMessages([...deps.agent.messages]), restoredTaskLifecycles(this.sessionManager));
         this.overlays = new OverlayRequestController();
         this.startedAtMs = Date.now();
         this.sessionTransition = new SessionTransitionController({
@@ -70,17 +66,18 @@ export class BubbleTuiController {
                 this.externalGeneration += 1;
             },
             clearLiveSubagentTools: () => {
-                this.liveSubagentTools.clear();
                 this.childRuns.clear();
-                this.liveSubagentVersion += 1;
             },
             commit: (manager, transcript) => {
                 this.sessionManager = manager;
                 this.deps.ports.flush.cancelFlush();
-                this.transcript = [...transcript, ...restoredTaskLifecycleMessages(manager)];
+                this.transcript = landTaskLifecycles(transcript, restoredTaskLifecycles(manager));
                 this.queue.queued.length = 0;
                 this.liveStreamVisible = false;
                 this.runState = null;
+                // Session-scoped: the restored session has not started a run, so none
+                // of its subagents or tasks belong to a "current turn".
+                this.turnStartedAt = undefined;
                 this.activeInputController = null;
                 this.activeAbortController = null;
                 this.commandActivity = null;
@@ -143,7 +140,6 @@ export class BubbleTuiController {
             }));
     }
     externalGeneration = 0;
-    liveSubagentVersion = 0;
     subscribe(listener) {
         this.listeners.add(listener);
         return () => this.listeners.delete(listener);
@@ -172,7 +168,11 @@ export class BubbleTuiController {
         this.goalRuntime.handleCommand(input, cwd);
     }
     getSubagentGroups() {
-        const fromTrace = collectSubagentGroups(this.transcript, [...this.liveSubagentTools.values()]);
+        // Launches from earlier rounds live in the transcript (kept current by
+        // applySubagentUpdateToMessages); this round's launches are still in the
+        // streaming accumulator until turn_end commits them.
+        const streamingTools = this.runActive && this.runState ? this.runState.accumulator.toolCalls : [];
+        const fromTrace = collectSubagentGroups(this.transcript, streamingTools);
         const claimed = new Set(fromTrace.flatMap((group) => group.members.map((member) => member.subAgentId).filter(Boolean)));
         const direct = this.deps.agent.listSubAgents()
             .filter((snapshot) => !claimed.has(snapshot.agentId))
@@ -201,6 +201,14 @@ export class BubbleTuiController {
         }));
         return [...fromTrace, ...direct];
     }
+    /**
+     * Start of the current (or, when idle, the latest) agent run. The tasks pane
+     * keeps finished work that was launched since then; wall clock on purpose,
+     * it is compared with subagent/task/workflow creation stamps.
+     */
+    getTurnStartedAt() {
+        return this.turnStartedAt;
+    }
     getWorkflows() {
         return this.deps.agent.listWorkflows();
     }
@@ -262,16 +270,48 @@ export class BubbleTuiController {
         // Switching back to the owner session reconstructs terminal task rows
         // from its persisted marker before held completions are released. Treat
         // that row as the same lifecycle event instead of appending a duplicate.
-        if (this.transcript.some((message) => message.toolCalls?.some((tool) => tool.metadata?.taskId === task.id && tool.metadata?.taskLifecycle !== undefined))) {
+        // Task ids repeat across processes, so the row must be this very run.
+        if (this.transcript.some((message) => message.toolCalls?.some((tool) => tool.metadata?.taskId === task.id
+            && tool.metadata?.taskLifecycle !== undefined
+            && tool.metadata?.endedAt === task.endedAt))) {
+            return;
+        }
+        const output = this.deps.processManager?.taskOutputTail(task.id, 12_000);
+        // Land the outcome on the launch row: this round's launches are still in
+        // the streaming accumulator, earlier rounds' have committed.
+        if (this.runActive && this.runState
+            && mergeTaskLifecycleIntoLiveTools(this.runState.accumulator.toolCalls, task, output)) {
+            this.state.touch();
+            this.notify();
+            return;
+        }
+        const landed = applyTaskLifecycleToMessages(this.transcript, task, output);
+        if (landed.merged) {
+            this.transcript = landed.messages;
+            this.state.touch();
+            this.notify();
             return;
         }
         if (this.runActive) {
+            // Launch row not settled yet (or absent): retry on the next tool_end,
+            // and fall back to a detached row when the round commits.
             this.pendingTaskAnnouncements.set(task.id, task);
             this.state.touch();
             this.notify();
             return;
         }
-        this.appendDisplayMessage(taskLifecycleDisplayMessage(task, this.deps.processManager?.taskOutputTail(task.id, 12_000)));
+        this.appendDisplayMessage(taskLifecycleDisplayMessage(task, output));
+    }
+    /** Pending completions whose launch row has settled since they arrived. */
+    landPendingTaskAnnouncementsInLiveRound() {
+        if (!this.runState || this.pendingTaskAnnouncements.size === 0)
+            return;
+        for (const [id, task] of this.pendingTaskAnnouncements) {
+            const output = this.deps.processManager?.taskOutputTail(task.id, 12_000);
+            if (mergeTaskLifecycleIntoLiveTools(this.runState.accumulator.toolCalls, task, output)) {
+                this.pendingTaskAnnouncements.delete(id);
+            }
+        }
     }
     /** Move the newest live Bash Execute into the unified task manager. */
     promoteActiveBash() {
@@ -288,7 +328,6 @@ export class BubbleTuiController {
     /** Drop every transcript row (/clear). */
     clearTranscript() {
         this.transcript = [];
-        this.liveSubagentTools.clear();
         this.childRuns.clear();
         this.state.touch();
         this.notify();
@@ -296,13 +335,8 @@ export class BubbleTuiController {
     /** Re-project the visible transcript after a non-controller command rewrites Agent history. */
     rebuildTranscriptFromAgent() {
         this.state.withTransaction(() => {
-            this.transcript = [
-                ...reconstructDisplayMessages([...this.deps.agent.messages]),
-                ...restoredTaskLifecycleMessages(this.sessionManager),
-            ];
-            this.liveSubagentTools.clear();
+            this.transcript = landTaskLifecycles(reconstructDisplayMessages([...this.deps.agent.messages]), restoredTaskLifecycles(this.sessionManager));
             this.childRuns.clear();
-            this.liveSubagentVersion += 1;
             this.state.touch();
         });
         this.notify();
@@ -320,13 +354,8 @@ export class BubbleTuiController {
             this.state.withTransaction(() => {
                 purgeForSessionSwitch(this.queue);
                 this.queue.queued.length = 0;
-                this.transcript = [
-                    ...reconstructDisplayMessages([...this.deps.agent.messages]),
-                    ...restoredTaskLifecycleMessages(this.sessionManager),
-                ];
-                this.liveSubagentTools.clear();
+                this.transcript = landTaskLifecycles(reconstructDisplayMessages([...this.deps.agent.messages]), restoredTaskLifecycles(this.sessionManager));
                 this.childRuns.clear();
-                this.liveSubagentVersion += 1;
                 this.liveStreamVisible = false;
                 this.runState = null;
                 this.state.touch();
@@ -493,20 +522,7 @@ export class BubbleTuiController {
         if (!this.runActive || !this.runState || !this.liveStreamVisible)
             return null;
         const acc = this.runState.accumulator;
-        const currentIds = new Set(acc.toolCalls.map((tool) => tool.id));
-        const carriedTools = [...this.liveSubagentTools.values()].filter((tool) => !currentIds.has(tool.id));
-        const allTools = [...acc.toolCalls, ...carriedTools];
         const parts = snapshotDisplayParts(acc.parts);
-        if (carriedTools.length > 0) {
-            parts.push({
-                type: "tools",
-                toolCalls: carriedTools.map((tool) => ({
-                    ...tool,
-                    args: { ...tool.args },
-                    metadata: tool.metadata ? { ...tool.metadata } : undefined,
-                })),
-            });
-        }
         return {
             content: acc.content,
             // Ink kept the current provider turn's reasoning visible even after
@@ -514,7 +530,7 @@ export class BubbleTuiController {
             reasoning: acc.reasoning,
             // Return a render-safe snapshot: reducer events continue mutating the
             // accumulator in place while the TUI may still hold the previous tail.
-            tools: allTools.map((tool) => ({
+            tools: acc.toolCalls.map((tool) => ({
                 ...tool,
                 args: { ...tool.args },
                 metadata: tool.metadata ? { ...tool.metadata } : undefined,
@@ -524,7 +540,7 @@ export class BubbleTuiController {
             parts,
             // Phase is provider-turn local, matching Ink's clearAssistantStream().
             // A tool in an earlier committed turn must not suppress fresh Thinking.
-            phase: allTools.length > 0 ? "working" : "thinking",
+            phase: acc.toolCalls.length > 0 ? "working" : "thinking",
         };
     }
     pendingOverlayCount() {
@@ -558,6 +574,7 @@ export class BubbleTuiController {
         const agentInput = isSubmitPayload(input) ? this.submitAgentInput(input) : input;
         this.runActive = true;
         this.liveStreamVisible = true;
+        this.turnStartedAt = Date.now();
         this.runState = createRunState(Date.now());
         const inputController = new AgentRunInputQueue(`run-${this.runState.accumulator.runId}`);
         const abortController = new AbortController();
@@ -583,7 +600,6 @@ export class BubbleTuiController {
             upstreamAbort();
         else
             options?.abortSignal?.addEventListener("abort", upstreamAbort, { once: true });
-        pruneSettledLiveSubagentTools(this.liveSubagentTools);
         this.state.touch();
         this.notify();
         const ctx = {
@@ -611,22 +627,28 @@ export class BubbleTuiController {
                 }
                 const { state, effects } = reduceAgentEvent(this.runState, event, ctx);
                 this.runState = state;
+                if (event.type === "tool_end")
+                    this.landPendingTaskAnnouncementsInLiveRound();
                 const subagentMetadata = event.type === "tool_update"
                     ? event.update.metadata
                     : event.type === "tool_end"
                         ? event.result.metadata
                         : undefined;
-                if (subagentMetadata?.kind === "subagent") {
-                    this.transcript = mergeSubagentSnapshotsIntoMessages(this.transcript, subagentMetadata);
-                }
                 if (event.type === "tool_update"
+                    && subagentMetadata?.kind === "subagent"
                     && effects.some((effect) => effect.kind === "live-subagent-changed")) {
-                    accumulateLiveSubagentUpdate(this.liveSubagentTools, {
+                    // The launching call already committed: merge the update into its
+                    // transcript entry so the settled row stays the single source of
+                    // truth for live and settled rendering alike.
+                    this.transcript = applySubagentUpdateToMessages(this.transcript, {
                         id: event.id,
                         name: event.name,
-                        metadata: event.update.metadata,
+                        metadata: subagentMetadata,
                     });
                 }
+                else if (subagentMetadata?.kind === "subagent") {
+                    this.transcript = mergeSubagentSnapshotsIntoMessages(this.transcript, subagentMetadata);
+                }
                 if (event.type === "tool_update" && event.update.childEvent) {
                     this.reduceChildEvent(event.update.subAgentId, event.update.childEvent);
                 }
@@ -763,10 +785,10 @@ export class BubbleTuiController {
                 this.activeInputController = null;
                 this.activeAbortController = null;
                 if (this.pendingTaskAnnouncements.size > 0) {
-                    this.transcript = [
-                        ...this.transcript,
-                        ...[...this.pendingTaskAnnouncements.values()].map((task) => taskLifecycleDisplayMessage(task, this.deps.processManager?.taskOutputTail(task.id, 12_000))),
-                    ];
+                    this.transcript = landTaskLifecycles(this.transcript, [...this.pendingTaskAnnouncements.values()].map((task) => ({
+                        task,
+                        output: this.deps.processManager?.taskOutputTail(task.id, 12_000),
+                    })));
                     this.pendingTaskAnnouncements.clear();
                 }
                 this.state.touch();
@@ -929,42 +951,7 @@ export class BubbleTuiController {
         return { reason, wallMs: Date.now() - this.startedAtMs };
     }
 }
-function taskLifecycleDisplayMessage(task, output) {
-    const status = task.status === "killed"
-        ? "cancelled"
-        : task.status === "failed"
-            ? "failed"
-            : "completed";
-    const tool = {
-        id: `task-lifecycle:${task.id}:${task.endedAt ?? Date.now()}`,
-        name: "bash",
-        args: {
-            command: task.command,
-            ...(task.description ? { description: task.description } : {}),
-        },
-        status,
-        isError: task.status === "failed",
-        result: output?.trim() ? output : undefined,
-        startedAt: task.startedAt,
-        metadata: {
-            kind: "shell",
-            background: true,
-            taskId: task.id,
-            taskLifecycle: task.status,
-            exitCode: task.exitCode ?? null,
-            endedAt: task.endedAt,
-            outputLines: task.outputLines,
-        },
-    };
-    return {
-        key: nextDisplayMessageKey("task"),
-        role: "assistant",
-        content: "",
-        toolCalls: [tool],
-        parts: [{ type: "tools", toolCalls: [tool] }],
-    };
-}
-function restoredTaskLifecycleMessages(manager) {
+function restoredTaskLifecycles(manager) {
     let entries;
     try {
         entries = manager.getEntries();
@@ -981,7 +968,10 @@ function restoredTaskLifecycleMessages(manager) {
         }
     }
     const starts = new Map();
-    const completed = new Map();
+    // Ids restart at task_0001 per process: count launches per id so each
+    // terminal marker lands on the launch row it belongs to.
+    const launches = new Map();
+    const terminals = [];
     for (let index = startIndex; index < entries.length; index += 1) {
         const entry = entries[index];
         if (entry?.type !== "marker" || !entry.value)
@@ -998,6 +988,7 @@ function restoredTaskLifecycleMessages(manager) {
             continue;
         if (entry.kind === "task_started") {
             starts.set(id, payload);
+            launches.set(id, (launches.get(id) ?? 0) + 1);
             continue;
         }
         if (entry.kind !== "task_finished" && entry.kind !== "task_killed")
@@ -1010,8 +1001,11 @@ function restoredTaskLifecycleMessages(manager) {
                 : "completed";
         const startedAt = numeric(payload.startedAt) ?? numeric(start.startedAt) ?? entry.timestamp;
         const endedAt = numeric(payload.endedAt) ?? entry.timestamp;
-        completed.set(id, {
-            order: index,
+        const seen = launches.get(id) ?? 0;
+        terminals.push({
+            // A start persisted before conversation_clear is out of scope: keep its
+            // terminal state detached rather than landing it on a later reuse.
+            occurrence: seen > 0 ? seen - 1 : UNMATCHED_LAUNCH,
             task: {
                 kind: "task",
                 id,
@@ -1030,9 +1024,7 @@ function restoredTaskLifecycleMessages(manager) {
             output: stringValue(payload.output),
         });
     }
-    return [...completed.values()]
-        .sort((left, right) => left.order - right.order)
-        .map(({ task, output }) => taskLifecycleDisplayMessage(task, output));
+    return terminals;
 }
 function numeric(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;

package/dist/tui/controller/goal-runtime-controller.js

@@ -179,7 +179,7 @@ export class GoalRuntimeController {
     persistGoal(goal) {
         try {
             const manager = this.deps.getSessionManager();
-            manager.setMetadata({ ...manager.getMetadata(), goal: goal ?? undefined });
+            manager.mutateMetadata((current) => ({ ...current, goal: goal ?? undefined }));
         }
         catch {
             // Persistence is best-effort; a filesystem failure must not break a run.

package/dist/tui/controller/session-transition.js

@@ -42,7 +42,7 @@ export class SessionTransitionController {
             this.deps.agent.setSessionID(manager.getSessionFile());
             // 7. External binding refresh comes from the new manager's metadata.
             void manager.getMetadata().externalRuntime;
-            // 8. Drop live subagent accumulators (ghost-group defense).
+            // 8. Drop child-run accumulators (ghost-group defense).
             this.deps.clearLiveSubagentTools();
             // 11. Settle every blocking request (behavior delta vs legacy).
             this.deps.overlays.settleAll("session-switch");

package/dist/tui/model/subagent-view.d.ts

@@ -41,6 +41,8 @@ export interface SubagentGroup {
     label: string;
     members: SubagentDisplay[];
 }
+/** Maps every tool call in the transcript; returns the same array when nothing changed. */
+export declare function mapTranscriptTools(messages: DisplayMessage[], updateTool: (tool: DisplayToolCall) => DisplayToolCall): DisplayMessage[];
 /**
  * Projects a newer lifecycle snapshot back onto every existing trace that
  * already references the same child. spawn_agent settles as soon as the child
@@ -58,29 +60,19 @@ export declare function synchronizeSubagentSnapshots(messages: DisplayMessage[])
  */
 export declare function mergeToolMetadata(current: ToolResultMetadata | undefined, incoming: ToolResultMetadata | undefined): ToolResultMetadata | undefined;
 /**
- * Drops accumulator entries whose every member reached a final status: by then
- * the authoritative snapshot lives in the settled transcript (wait_workflow /
- * wait_agent result), so the entry is dead weight that would otherwise pile up
- * for the life of the process. Entries with running/queued members stay — for
- * a workflow spanning turns they are the only live view. Returns whether the
- * map changed (callers bump their version counter on true).
+ * Applies a subagent tool_update whose launching call has already settled out
+ * of the streaming round. Children keep reporting against the launching
+ * spawn_agent / run_workflow call id across later rounds (e.g. while a
+ * wait_workflow blocks), so the update is merged into that entry by id — which
+ * absorbs members a workflow spawned after commit — and then projected onto
+ * every echo referencing the same members. The settled transcript is the only
+ * data source; the live tail never carries synthetic tool rows.
  */
-export declare function pruneSettledLiveSubagentTools(map: Map<string, DisplayToolCall>): boolean;
-/**
- * Accumulates a subagent tool_update whose originating tool call has already
- * settled out of the current streaming round. The TUI clears its streaming
- * toolCalls on every turn_start, but background children keep reporting
- * against the launching run_workflow/spawn_agent call id across later rounds
- * (e.g. while a wait_workflow blocks) — without this side-channel those
- * updates are dropped and traces only appear after the whole team finishes.
- * Entries act as synthetic tool calls feeding collectSubagentGroups.
- * Returns true when the update was absorbed.
- */
-export declare function accumulateLiveSubagentUpdate(map: Map<string, DisplayToolCall>, event: {
+export declare function applySubagentUpdateToMessages(messages: DisplayMessage[], update: {
     id: string;
     name: string;
     metadata?: ToolResultMetadata;
-}): boolean;
+}): DisplayMessage[];
 /**
  * Collects every spawned subagent from the live transcript + streaming tools,
  * grouped by their originating tool call, for the inspector. Pure.

package/dist/tui/model/subagent-view.js

@@ -103,6 +103,39 @@ function freshestSubagentSnapshots(messages) {
     }
     return [...freshest.values()];
 }
+/** Maps every tool call in the transcript; returns the same array when nothing changed. */
+export function mapTranscriptTools(messages, updateTool) {
+    let anyChanged = false;
+    const updated = messages.map((message) => {
+        let messageChanged = false;
+        const toolCalls = message.toolCalls?.map((tool) => {
+            const next = updateTool(tool);
+            if (next !== tool)
+                messageChanged = true;
+            return next;
+        });
+        const parts = message.parts?.map((part) => {
+            if (part.type !== "tools")
+                return part;
+            let partChanged = false;
+            const nextTools = part.toolCalls.map((tool) => {
+                const next = updateTool(tool);
+                if (next !== tool)
+                    partChanged = true;
+                return next;
+            });
+            if (!partChanged)
+                return part;
+            messageChanged = true;
+            return { ...part, toolCalls: nextTools };
+        });
+        if (!messageChanged)
+            return message;
+        anyChanged = true;
+        return { ...message, toolCalls, parts };
+    });
+    return anyChanged ? updated : messages;
+}
 /**
  * Projects a newer lifecycle snapshot back onto every existing trace that
  * already references the same child. spawn_agent settles as soon as the child
@@ -140,36 +173,7 @@ export function mergeSubagentSnapshotsIntoMessages(messages, incoming) {
         });
         return changed ? { ...tool, metadata: { ...tool.metadata, subagents } } : tool;
     };
-    let anyChanged = false;
-    const updated = messages.map((message) => {
-        let messageChanged = false;
-        const toolCalls = message.toolCalls?.map((tool) => {
-            const next = updateTool(tool);
-            if (next !== tool)
-                messageChanged = true;
-            return next;
-        });
-        const parts = message.parts?.map((part) => {
-            if (part.type !== "tools")
-                return part;
-            let partChanged = false;
-            const nextTools = part.toolCalls.map((tool) => {
-                const next = updateTool(tool);
-                if (next !== tool)
-                    partChanged = true;
-                return next;
-            });
-            if (!partChanged)
-                return part;
-            messageChanged = true;
-            return { ...part, toolCalls: nextTools };
-        });
-        if (!messageChanged)
-            return message;
-        anyChanged = true;
-        return { ...message, toolCalls, parts };
-    });
-    return anyChanged ? updated : messages;
+    return mapTranscriptTools(messages, updateTool);
 }
 /** Reconciles persisted launch/wait/list echoes when rebuilding a session. */
 export function synchronizeSubagentSnapshots(messages) {
@@ -210,64 +214,31 @@ export function mergeToolMetadata(current, incoming) {
         subagents: [...byId.values()],
     };
 }
-const FINAL_MEMBER_STATUSES = new Set(["completed", "failed", "blocked", "cancelled", "closed"]);
 /**
- * Drops accumulator entries whose every member reached a final status: by then
- * the authoritative snapshot lives in the settled transcript (wait_workflow /
- * wait_agent result), so the entry is dead weight that would otherwise pile up
- * for the life of the process. Entries with running/queued members stay — for
- * a workflow spanning turns they are the only live view. Returns whether the
- * map changed (callers bump their version counter on true).
+ * Applies a subagent tool_update whose launching call has already settled out
+ * of the streaming round. Children keep reporting against the launching
+ * spawn_agent / run_workflow call id across later rounds (e.g. while a
+ * wait_workflow blocks), so the update is merged into that entry by id — which
+ * absorbs members a workflow spawned after commit — and then projected onto
+ * every echo referencing the same members. The settled transcript is the only
+ * data source; the live tail never carries synthetic tool rows.
  */
-export function pruneSettledLiveSubagentTools(map) {
-    let changed = false;
-    for (const [id, tc] of map) {
-        const members = Array.isArray(tc.metadata?.subagents) ? tc.metadata.subagents : [];
-        const allFinal = members.every((member) => typeof member === "object" && member !== null
-            && FINAL_MEMBER_STATUSES.has(String(member.status)));
-        if (allFinal) {
-            map.delete(id);
-            changed = true;
-        }
-    }
-    return changed;
-}
-/**
- * Accumulates a subagent tool_update whose originating tool call has already
- * settled out of the current streaming round. The TUI clears its streaming
- * toolCalls on every turn_start, but background children keep reporting
- * against the launching run_workflow/spawn_agent call id across later rounds
- * (e.g. while a wait_workflow blocks) — without this side-channel those
- * updates are dropped and traces only appear after the whole team finishes.
- * Entries act as synthetic tool calls feeding collectSubagentGroups.
- * Returns true when the update was absorbed.
- */
-export function accumulateLiveSubagentUpdate(map, event) {
-    if (event.metadata?.kind !== "subagent")
-        return false;
-    const prev = map.get(event.id);
-    const metadata = mergeToolMetadata(prev?.metadata, event.metadata);
-    if (!metadata)
-        return false;
-    // Per-child updates carry no mode; group them under the launching workflow
-    // call rather than falling back to one single-agent group per member.
-    if (event.name === "run_workflow" && metadata.mode === undefined)
-        metadata.mode = "workflow";
-    const members = Array.isArray(metadata.subagents)
-        ? metadata.subagents.filter((member) => (typeof member === "object" && member !== null))
-        : [];
-    const statuses = members.map((member) => String(member.status ?? "running"));
-    const stillRunning = statuses.some((status) => status === "queued" || status === "running");
-    const failed = statuses.some((status) => status === "failed" || status === "blocked" || status === "cancelled");
-    map.set(event.id, {
-        id: event.id,
-        name: event.name,
-        args: prev?.args ?? {},
-        metadata,
-        status: stillRunning ? "running" : failed ? "failed" : "completed",
-        isError: failed,
+export function applySubagentUpdateToMessages(messages, update) {
+    if (update.metadata?.kind !== "subagent")
+        return messages;
+    const byId = mapTranscriptTools(messages, (tool) => {
+        if (tool.id !== update.id)
+            return tool;
+        const metadata = mergeToolMetadata(tool.metadata, update.metadata);
+        if (!metadata || metadata === tool.metadata)
+            return tool;
+        // Per-child updates carry no mode; keep them grouped under the launching
+        // workflow call rather than falling back to one single-agent group each.
+        if (update.name === "run_workflow" && metadata.mode === undefined)
+            metadata.mode = "workflow";
+        return { ...tool, metadata };
     });
-    return true;
+    return mergeSubagentSnapshotsIntoMessages(byId, update.metadata);
 }
 /**
  * Collects every spawned subagent from the live transcript + streaming tools,