Bubble nested agents' tool calls into the parent's status line

The collapsed status only scanned a group's OWN tool items and skipped nested
agent groups, so a parent that had delegated froze on its last own tool while
its child did the actual work — the line described nothing that was running.
Status now walks the whole subtree: any tool at any depth counts, the most
recently started running one is shown, and the rest become the same '+ n'
overflow. With nothing running it falls back to the last tool at any depth,
so an idle parent still reflects where its subtree got to.

Author: Sg312

apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.test.ts

@@ -229,3 +229,77 @@ describe('AgentGroup browser takeover', () => {
     act(() => root.unmount())
   })
 })
+
+describe('AgentGroup nested status line', () => {
+  let container: HTMLDivElement
+  let root: Root
+
+  beforeEach(() => {
+    container = document.createElement('div')
+    document.body.appendChild(container)
+    root = createRoot(container)
+  })
+
+  afterEach(() => {
+    act(() => root.unmount())
+    container.remove()
+  })
+
+  const namedTool = (
+    displayTitle: string,
+    status: ToolCallStatus,
+    startedAt?: number
+  ): AgentGroupItem => ({
+    type: 'tool',
+    data: {
+      id: `${displayTitle}-${startedAt ?? 0}`,
+      toolName: 'grep',
+      displayTitle,
+      status,
+      startedAt,
+    },
+  })
+
+  const render = (items: AgentGroupItem[]) => {
+    act(() => {
+      root.render(
+        createElement(AgentGroup, {
+          agentName: 'workflow',
+          agentLabel: 'Workflow Agent',
+          items,
+          isStreaming: true,
+          isLaneOpen: true,
+        })
+      )
+    })
+    return container.textContent ?? ''
+  }
+
+  it("shows a nested agent's running tool instead of the parent's finished one", () => {
+    const header = render([
+      namedTool('Reading workflow', 'success' as ToolCallStatus, 1),
+      group([namedTool('Deploying Invoice Sync as API', 'executing' as ToolCallStatus, 2)]),
+    ])
+    expect(header).toContain('Workflow Agent — Deploying Invoice Sync as API')
+  })
+
+  it('counts running tools across depths with the + n suffix', () => {
+    const header = render([
+      namedTool('Reading workflow', 'executing' as ToolCallStatus, 1),
+      group([
+        namedTool('Deploying Invoice Sync as API', 'executing' as ToolCallStatus, 3),
+        namedTool('Checking deployment status', 'executing' as ToolCallStatus, 2),
+      ]),
+    ])
+    // Latest start wins; the other two running become the overflow count.
+    expect(header).toContain('Deploying Invoice Sync as API + 2')
+  })
+
+  it('falls back to the last tool at any depth when nothing is running', () => {
+    const header = render([
+      namedTool('Reading workflow', 'success' as ToolCallStatus, 1),
+      group([namedTool('Deploying Invoice Sync as API', 'success' as ToolCallStatus, 2)]),
+    ])
+    expect(header).toContain('Workflow Agent — Deploying Invoice Sync as API')
+  })
+})

apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.tsx

@@ -1,6 +1,6 @@
 'use client'
 
-import { useEffect, useLayoutEffect, useRef, useState } from 'react'
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
 import { ChevronDown, cn, Expandable, ExpandableContent } from '@sim/emcn'
 import { ShimmerText } from '@/components/ui'
 import { isBrowserAgentAvailable } from '@/lib/browser-agent/transport'
@@ -43,6 +43,27 @@ interface AgentGroupProps {
   isLaneOpen?: boolean
 }
 
+function toolStatusTitle(tool: ToolCallData): string {
+  return tool.displayTitle || String(tool.toolName ?? '')
+}
+
+/**
+ * Every tool in a group, in stream order, including those run by nested
+ * agents. A parent's status line speaks for the whole subtree it delegated,
+ * so a grandchild's work is what surfaces while the parent itself waits.
+ */
+function collectGroupTools(items: AgentGroupItem[]): ToolCallData[] {
+  const tools: ToolCallData[] = []
+  const walk = (list: AgentGroupItem[]) => {
+    for (const item of list) {
+      if (item.type === 'tool') tools.push(item.data)
+      else if (item.type === 'agent_group') walk(item.group.items)
+    }
+  }
+  walk(items)
+  return tools
+}
+
 /** True when any row in this group (or a nested one) is waiting on a permission decision. */
 function hasAwaitingApproval(items: AgentGroupItem[]): boolean {
   return items.some((item) => {
@@ -117,27 +138,26 @@ export function AgentGroup({
   const isMainAgent = agentName === 'mothership'
   // Collapsed status line: the latest tool call, always in its RUNNING
   // phrasing — it never flips to the completed rewrite (that lives in the
-  // expanded log). With parallel tools, the most recently started
-  // still-running one wins, with a +N for its running siblings; between
+  // expanded log). Work delegated further down bubbles up, so a group whose
+  // own turn is idle still narrates what its nested agent is doing rather
+  // than freezing on its last own tool. With several tools running at any
+  // depth, the most recently started wins and the rest become "+ n"; between
   // rounds the last tool's title stays frozen; a closed lane shows the bare
   // name.
-  const status = (() => {
+  const status = useMemo(() => {
     if (isMainAgent || !isLaneOpen) return undefined
-    let running: string | undefined
-    let runningCount = 0
-    let lastAny: string | undefined
-    for (const it of items) {
-      if (it.type !== 'tool') continue
-      const title = it.data.displayTitle || String(it.data.toolName ?? '')
-      lastAny = title
-      if (it.data.status === ToolCallStatus.executing) {
-        running = title
-        runningCount += 1
-      }
+    const tools = collectGroupTools(items)
+    const running = tools.filter((tool) => tool.status === ToolCallStatus.executing)
+    if (running.length > 0) {
+      const latest = running.reduce((newest, tool) =>
+        (tool.startedAt ?? 0) >= (newest.startedAt ?? 0) ? tool : newest
+      )
+      const title = toolStatusTitle(latest)
+      return running.length > 1 ? `${title} + ${running.length - 1}` : title
     }
-    if (running) return runningCount > 1 ? `${running} + ${runningCount - 1}` : running
-    return lastAny
-  })()
+    const last = tools.at(-1)
+    return last ? toolStatusTitle(last) : undefined
+  }, [isLaneOpen, isMainAgent, items])
   const headerText = status ? `${agentLabel} — ${status}` : agentLabel
   const hasItems = items.length > 0
   const resolved = isAgentGroupResolved(items)