fix(vscode): attribute DynamicWorkflow steps to their own subagent

Every subagent in a DynamicWorkflow batch shares one parentToolCallId, so the
webview funnelled all of them into a single flat subagent_steps array and
targeted the array tail as the "current step". Two agents streaming at once
wrote text, thinking, and tool calls into each other's steps.

Steps now carry the emitting agent's identity and are targeted per agent. The
subagent lifecycle events the adapter already received but discarded
(started/completed/failed/suspended) are mapped to a SubagentStatus event, which
gives each lane a status, a duration, and a result or error.

On top of that attribution, DynamicWorkflow renders as per-agent lanes instead
of an escaped-JSON argument dump: live activity, a step count, a status, and a
progress bar filled relative to the busiest lane. There is no per-agent step
total to divide by, so an absolute percentage would be fabricated; the caption
names the denominator.

Lane derivation lives in lib/workflow-lanes.ts rather than the store module, and
the pure tool-argument helpers move to lib/tool-args.ts. Tool rendering is
mutually recursive, so WorkflowCard receives its step-item renderer as a prop
rather than importing it and closing an import cycle.

The new test file is excluded from the extension tsconfig, which is where the
webview-side tests are kept out of the extension program.

Author: elkaix

apps/vscode/shared/legacy-sdk.ts

@@ -126,6 +126,22 @@ export interface QuestionResponse {
 export interface SubagentEvent {
   parent_tool_call_id: string;
   event: LegacyWireEvent;
+  /** Emitting subagent. */
+  agent_id: string;
+  /** Display name for the lane, e.g. "explore". Absent for non-DynamicWorkflow subagents. */
+  agent_label?: string;
+  /** Position within the DynamicWorkflow batch, 1-based. Absent when the subagent has none. */
+  agent_index?: number;
+}
+
+export interface SubagentStatusPayload {
+  parent_tool_call_id: string;
+  agent_id: string;
+  agent_label?: string;
+  agent_index?: number;
+  status: 'spawned' | 'running' | 'done' | 'failed' | 'suspended';
+  error?: string;
+  result_summary?: string;
 }
 
 export type LegacyWireEvent =
@@ -142,6 +158,7 @@ export type LegacyWireEvent =
   | { type: 'ToolResult'; payload: ToolResult }
   | { type: 'SteerInput'; payload: { user_input: string | ContentPart[] } }
   | { type: 'SubagentEvent'; payload: SubagentEvent }
+  | { type: 'SubagentStatus'; payload: SubagentStatusPayload }
   | { type: string; payload: unknown };
 
 export type StreamEvent =

apps/vscode/src/runtime/event-adapter.ts

@@ -4,6 +4,7 @@ import type {
   DisplayBlock,
   LegacyWireEvent,
   StatusUpdate,
+  SubagentStatusPayload,
   TokenUsage,
   TurnBegin,
 } from '../../shared/legacy-sdk';
@@ -22,6 +23,9 @@ export interface AdapterTokenUsage {
 export interface SubagentParent {
   readonly parentAgentId: string;
   readonly parentToolCallId: string;
+  readonly subagentName?: string;
+  readonly description?: string;
+  readonly dynamicWorkflowIndex?: number;
 }
 
 export interface EventAdapterState {
@@ -89,22 +93,35 @@ export function adaptSdkEvent(
 
   if (sdkEvent.type === 'subagent.spawned') {
     const parentAgentId = (sdkEvent as any).parentAgentId ?? (sdkEvent as any).callerAgentId ?? sdkEvent.agentId;
-    return {
-      state: {
-        ...state,
-        subagentParents: {
-          ...state.subagentParents,
-          [sdkEvent.subagentId]: {
-            parentAgentId,
-            parentToolCallId: scopedToolCallId(
-              parentAgentId,
-              sdkEvent.parentToolCallId,
-              mainAgentId,
-            ),
-          },
+    const parentToolCallId = scopedToolCallId(parentAgentId, sdkEvent.parentToolCallId, mainAgentId);
+    const nextState: EventAdapterState = {
+      ...state,
+      subagentParents: {
+        ...state.subagentParents,
+        [sdkEvent.subagentId]: {
+          parentAgentId,
+          parentToolCallId,
+          subagentName: sdkEvent.subagentName,
+          description: sdkEvent.description,
+          dynamicWorkflowIndex: sdkEvent.dynamicWorkflowIndex,
         },
       },
     };
+    const statusPayload: SubagentStatusPayload = {
+      parent_tool_call_id: parentToolCallId,
+      agent_id: sdkEvent.subagentId,
+      agent_label: sdkEvent.subagentName,
+      agent_index: sdkEvent.dynamicWorkflowIndex,
+      status: 'spawned',
+    };
+    const routed = routeSubagentEvent(
+      nextState,
+      parentAgentId,
+      { type: 'SubagentStatus', payload: statusPayload },
+      mainAgentId,
+    );
+    if (routed === undefined) return { state: nextState };
+    return { state: nextState, event: withSessionId(routed, sdkEvent.sessionId) };
   }
 
   if (sdkEvent.type === 'turn.started') {
@@ -320,6 +337,14 @@ function mapLegacyWireEvent(
     }
     case 'agent.status.updated':
       return mapStatusUpdate(state, sdkEvent);
+    case 'subagent.started':
+      return mapSubagentStatus(state, sdkEvent, 'running');
+    case 'subagent.completed':
+      return mapSubagentStatus(state, sdkEvent, 'done');
+    case 'subagent.failed':
+      return mapSubagentStatus(state, sdkEvent, 'failed');
+    case 'subagent.suspended':
+      return mapSubagentStatus(state, sdkEvent, 'suspended');
     case 'compaction.started':
       return {
         state,
@@ -368,6 +393,32 @@ function mapStatusUpdate(
   };
 }
 
+function mapSubagentStatus(
+  state: EventAdapterState,
+  sdkEvent: Extract<
+    Event,
+    { type: 'subagent.started' | 'subagent.completed' | 'subagent.failed' | 'subagent.suspended' }
+  >,
+  status: SubagentStatusPayload['status'],
+): MappedLegacyWireEvent {
+  // subagent.spawned always precedes every other lifecycle event for the same
+  // subagentId, so the parent is always known by the time this runs.
+  const parent = state.subagentParents[sdkEvent.subagentId];
+  if (parent === undefined) return { state };
+
+  const payload: SubagentStatusPayload = {
+    parent_tool_call_id: parent.parentToolCallId,
+    agent_id: sdkEvent.subagentId,
+    agent_label: parent.subagentName,
+    agent_index: parent.dynamicWorkflowIndex,
+    status,
+    error: sdkEvent.type === 'subagent.failed' ? sdkEvent.error : undefined,
+    result_summary: sdkEvent.type === 'subagent.completed' ? sdkEvent.resultSummary : undefined,
+  };
+
+  return { state, event: { type: 'SubagentStatus', payload } };
+}
+
 function usageDelta(current: AdapterTokenUsage, previous: AdapterTokenUsage | undefined): TokenUsage {
   return {
     input_other: delta(current.inputOther, previous?.inputOther),
@@ -414,6 +465,9 @@ function routeSubagentEvent(
       type: 'SubagentEvent',
       payload: {
         parent_tool_call_id: parent.parentToolCallId,
+        agent_id: currentAgentId,
+        agent_label: parent.subagentName,
+        agent_index: parent.dynamicWorkflowIndex,
         event: routed,
       },
     };

apps/vscode/src/runtime/replay-adapter.ts

@@ -496,6 +496,9 @@ function wrapSubagentEvent(
           invocation.parentAgentId,
           invocation.parentToolCallId,
         ),
+        // Replay history carries no persisted label or dynamicWorkflowIndex; the UI
+        // falls back to the id's short form.
+        agent_id: invocation.childAgentId,
         event: routed,
       },
     };

apps/vscode/test/event-adapter.test.ts

@@ -360,6 +360,8 @@ describe('event adapter (projects SDK events into the legacy Webview contract)',
       type: 'SubagentEvent',
       payload: {
         parent_tool_call_id: 'agent-call-1',
+        agent_id: 'child-1',
+        agent_label: 'coder',
         event: {
           type: 'ContentPart',
           payload: { type: 'text', text: 'Child result' },
@@ -394,6 +396,8 @@ describe('event adapter (projects SDK events into the legacy Webview contract)',
       type: 'SubagentEvent',
       payload: {
         parent_tool_call_id: 'agent-call-1',
+        agent_id: 'child-1',
+        agent_label: 'coder',
         event: {
           type: 'ToolCall',
           payload: {
@@ -410,6 +414,76 @@ describe('event adapter (projects SDK events into the legacy Webview contract)',
     });
   });
 
+  it('emits a spawned SubagentStatus the moment a subagent is queued', () => {
+    const result = adaptSdkEvent(createEventAdapterState(), {
+      type: 'subagent.spawned',
+      sessionId: 'session-1',
+      agentId: 'main',
+      subagentId: 'child-1',
+      subagentName: 'explore',
+      parentToolCallId: 'wf-1',
+      parentAgentId: 'main',
+      dynamicWorkflowIndex: 2,
+      runInBackground: false,
+    });
+
+    expect(result.event).toEqual({
+      type: 'SubagentStatus',
+      payload: {
+        parent_tool_call_id: 'wf-1',
+        agent_id: 'child-1',
+        agent_label: 'explore',
+        agent_index: 2,
+        status: 'spawned',
+      },
+      _sessionId: 'session-1',
+    });
+  });
+
+  it.each([
+    ['subagent.started' as const, 'running' as const, {}],
+    ['subagent.suspended' as const, 'suspended' as const, { reason: 'waiting on approval' }],
+    ['subagent.completed' as const, 'done' as const, { resultSummary: 'Explored 3 files' }],
+    ['subagent.failed' as const, 'failed' as const, { error: 'timed out' }],
+  ])('routes each %s lifecycle event to one SubagentStatus on the spawning tool call', (sdkType, status, extra) => {
+    const spawned = adaptSdkEvent(createEventAdapterState(), {
+      type: 'subagent.spawned',
+      sessionId: 'session-1',
+      agentId: 'main',
+      subagentId: 'child-1',
+      subagentName: 'explore',
+      parentToolCallId: 'wf-1',
+      parentAgentId: 'main',
+      dynamicWorkflowIndex: 2,
+      runInBackground: false,
+    });
+
+    const lifecycle = adaptSdkEvent(spawned.state, {
+      type: sdkType,
+      sessionId: 'session-1',
+      agentId: 'main',
+      subagentId: 'child-1',
+      parentToolCallId: 'wf-1',
+      ...extra,
+    } as any);
+
+    const expectedPayload: Record<string, unknown> = {
+      parent_tool_call_id: 'wf-1',
+      agent_id: 'child-1',
+      agent_label: 'explore',
+      agent_index: 2,
+      status,
+    };
+    if ('error' in extra) expectedPayload['error'] = (extra as { error: string }).error;
+    if ('resultSummary' in extra) expectedPayload['result_summary'] = (extra as { resultSummary: string }).resultSummary;
+
+    expect(lifecycle.event).toEqual({
+      type: 'SubagentStatus',
+      payload: expectedPayload,
+      _sessionId: 'session-1',
+    });
+  });
+
   it('emits compaction begin when SDK compaction starts', () => {
     const result = adaptSdkEvent(createEventAdapterState(), {
       type: 'compaction.started',