Show parent-level Codex subagent activity

Keep compact collaboration rows and accurate status while child-thread output and lifecycle notifications remain isolated from the parent session.

Generated-By: PostHog Code
Task-Id: 971044c5-e622-4f07-b1b5-dca9b06d040c

Author: richardsolomou

packages/agent/src/adapters/codex-app-server/codex-app-server-agent.test.ts

@@ -153,6 +153,19 @@ describe("CodexAppServerAgent", () => {
       sessionId: "thr_1",
       prompt: [{ type: "text", text: "delegate this" }],
     } as unknown as PromptRequest);
+    stub.emit("item/started", {
+      threadId: "thr_1",
+      turnId: "turn_1",
+      item: {
+        type: "collabAgentToolCall",
+        id: "spawn_1",
+        tool: "spawnAgent",
+        status: "inProgress",
+        senderThreadId: "thr_1",
+        receiverThreadIds: ["subagent_1"],
+        prompt: "Review the implementation",
+      },
+    });
     const sessionUpdateCount = sessionUpdates.length;
     const extNotificationCount = extNotifications.length;
 
@@ -211,7 +224,9 @@ describe("CodexAppServerAgent", () => {
     });
 
     await expect(promptDone).resolves.toMatchObject({ stopReason: "end_turn" });
-    expect(JSON.stringify(sessionUpdates)).toContain("parent response");
+    const serializedUpdates = JSON.stringify(sessionUpdates);
+    expect(serializedUpdates).toContain("spawn_agent");
+    expect(serializedUpdates).toContain("parent response");
   });
 
   it("includes buffered command output when completion omits aggregatedOutput", async () => {

packages/agent/src/adapters/codex-app-server/mapping.test.ts

@@ -230,6 +230,74 @@ describe("mapAppServerNotification", () => {
     });
   });
 
+  it("maps a spawned Codex agent to an explicit subagent tool call", () => {
+    const result = mapAppServerNotification(
+      "s-1",
+      APP_SERVER_NOTIFICATIONS.ITEM_STARTED,
+      {
+        item: {
+          type: "collabAgentToolCall",
+          id: "spawn-1",
+          tool: "spawnAgent",
+          status: "inProgress",
+          senderThreadId: "main-thread",
+          receiverThreadIds: ["child-thread"],
+          prompt: "Review the authentication changes\nFocus on security.",
+          model: "gpt-5.5",
+          reasoningEffort: "high",
+        },
+      },
+    );
+
+    expect(result).toEqual({
+      sessionId: "s-1",
+      update: {
+        sessionUpdate: "tool_call",
+        toolCallId: "spawn-1",
+        title: "Review the authentication changes",
+        kind: "other",
+        status: "in_progress",
+        rawInput: {
+          prompt: "Review the authentication changes\nFocus on security.",
+          receiverThreadIds: ["child-thread"],
+          model: "gpt-5.5",
+          reasoningEffort: "high",
+        },
+        _meta: { posthog: { toolName: "spawn_agent" } },
+      },
+    });
+  });
+
+  it("keeps a completed spawn tool call active while its subagent is running", () => {
+    const result = mapAppServerNotification(
+      "s-1",
+      APP_SERVER_NOTIFICATIONS.ITEM_COMPLETED,
+      {
+        item: {
+          type: "collabAgentToolCall",
+          id: "spawn-1",
+          tool: "spawnAgent",
+          status: "completed",
+          senderThreadId: "main-thread",
+          receiverThreadIds: ["child-thread"],
+          prompt: "Review the authentication changes",
+          agentsStates: {
+            "child-thread": { status: "running", message: null },
+          },
+        },
+      },
+    );
+
+    expect(result).toEqual({
+      sessionId: "s-1",
+      update: {
+        sessionUpdate: "tool_call_update",
+        toolCallId: "spawn-1",
+        status: "in_progress",
+      },
+    });
+  });
+
   it("drops agent message items (their deltas already streamed)", () => {
     expect(
       mapAppServerNotification("s-1", APP_SERVER_NOTIFICATIONS.ITEM_COMPLETED, {

packages/agent/src/adapters/codex-app-server/mapping.ts

@@ -206,6 +206,15 @@ export type AppServerItem = {
   // Present on message/reasoning items replayed from thread history.
   text?: string;
   content?: unknown;
+  senderThreadId?: string;
+  receiverThreadIds?: string[];
+  prompt?: string | null;
+  model?: string | null;
+  reasoningEffort?: string | null;
+  agentsStates?: Record<
+    string,
+    { status?: string; message?: string | null } | undefined
+  >;
 };
 
 function mcpResultText(
@@ -295,14 +304,20 @@ export function mapHistoryItem(
             status: mapStatus(item.status),
             ...(tool.rawInput !== undefined ? { rawInput: tool.rawInput } : {}),
             ...(tool.locations?.length ? { locations: tool.locations } : {}),
-            ...(tool.mcp
+            ...(item.type === "collabAgentToolCall"
               ? {
                   _meta: posthogToolMeta({
-                    toolName: mcpToolKey(tool.mcp),
-                    mcp: tool.mcp,
+                    toolName: collabAgentToolName(item.tool),
                   }),
                 }
-              : {}),
+              : tool.mcp
+                ? {
+                    _meta: posthogToolMeta({
+                      toolName: mcpToolKey(tool.mcp),
+                      mcp: tool.mcp,
+                    }),
+                  }
+                : {}),
             ...(content ? { content } : {}),
           },
         },
@@ -394,13 +409,64 @@ function describeTool(item: AppServerItem): ToolDescriptor | null {
         rawInput: item.arguments,
         output: dynamicToolText(item.contentItems),
       };
+    case "collabAgentToolCall":
+      return {
+        title: collabAgentTitle(item),
+        kind: "other",
+        rawInput: {
+          ...(item.prompt ? { prompt: item.prompt } : {}),
+          ...(item.receiverThreadIds?.length
+            ? { receiverThreadIds: item.receiverThreadIds }
+            : {}),
+          ...(item.model ? { model: item.model } : {}),
+          ...(item.reasoningEffort
+            ? { reasoningEffort: item.reasoningEffort }
+            : {}),
+        },
+      };
     case "webSearch":
       return { title: item.query ?? "Web search", kind: "fetch" };
     default:
       return null;
   }
 }
 
+function collabAgentTitle(item: AppServerItem): string {
+  switch (item.tool) {
+    case "spawnAgent":
+      return item.prompt
+        ? item.prompt.split("\n", 1)[0].slice(0, 120)
+        : "Spawn subagent";
+    case "sendInput":
+      return "Message subagent";
+    case "resumeAgent":
+      return "Resume subagent";
+    case "wait":
+      return "Wait for subagents";
+    case "closeAgent":
+      return "Close subagent";
+    default:
+      return "Subagent";
+  }
+}
+
+function collabAgentToolName(tool: string | undefined): string {
+  switch (tool) {
+    case "spawnAgent":
+      return "spawn_agent";
+    case "sendInput":
+      return "send_input";
+    case "resumeAgent":
+      return "resume_agent";
+    case "wait":
+      return "wait_agent";
+    case "closeAgent":
+      return "close_agent";
+    default:
+      return "subagent";
+  }
+}
+
 /** Distinct, non-empty changed paths for a fileChange item, order-preserved. */
 export function changePaths(changes: AppServerItem["changes"]): string[] {
   if (!changes?.length) return [];
@@ -459,14 +525,20 @@ function mapItem(
         status: "in_progress",
         ...(tool.rawInput !== undefined ? { rawInput: tool.rawInput } : {}),
         ...(tool.locations?.length ? { locations: tool.locations } : {}),
-        ...(tool.mcp
+        ...(item.type === "collabAgentToolCall"
           ? {
               _meta: posthogToolMeta({
-                toolName: mcpToolKey(tool.mcp),
-                mcp: tool.mcp,
+                toolName: collabAgentToolName(item.tool),
               }),
             }
-          : {}),
+          : tool.mcp
+            ? {
+                _meta: posthogToolMeta({
+                  toolName: mcpToolKey(tool.mcp),
+                  mcp: tool.mcp,
+                }),
+              }
+            : {}),
       },
     };
   }
@@ -477,7 +549,7 @@ function mapItem(
     update: {
       sessionUpdate: "tool_call_update",
       toolCallId: item.id,
-      status: mapStatus(item.status),
+      status: mapToolStatus(item),
       ...(content ? { content } : {}),
     },
   };
@@ -523,6 +595,20 @@ function mapStatus(
   return "in_progress";
 }
 
+function mapToolStatus(
+  item: AppServerItem,
+): "completed" | "failed" | "in_progress" {
+  if (
+    item.type === "collabAgentToolCall" &&
+    Object.values(item.agentsStates ?? {}).some(
+      (agent) => agent?.status === "pendingInit" || agent?.status === "running",
+    )
+  ) {
+    return "in_progress";
+  }
+  return mapStatus(item.status);
+}
+
 function readItem(params: unknown): AppServerItem | null {
   if (params && typeof params === "object" && "item" in params) {
     const item = (params as Record<string, unknown>).item;

packages/ui/src/features/sessions/components/new-thread/buildThreadGroups.test.ts

@@ -73,4 +73,26 @@ describe("buildThreadGroups MCP detection", () => {
     expect(grouping.idToRowIndex.get("t1")).toBe(0);
     expect(grouping.idToRowIndex.get("t2")).toBe(0);
   });
+
+  it("counts only spawned agents as subagents", () => {
+    const items = [
+      toolCallItem("spawn-1", {
+        posthog: { toolName: "spawn_agent" },
+      }),
+      toolCallItem("wait-1", {
+        posthog: { toolName: "wait_agent" },
+      }),
+      toolCallItem("close-1", {
+        posthog: { toolName: "close_agent" },
+      }),
+    ];
+
+    const grouping = buildThreadGroups(items, "all", {});
+    const row = grouping.rows[0];
+    expect(row.kind).toBe("tool_group");
+    if (row.kind !== "tool_group") return;
+    expect(row.summary.counts.subagents).toBe(1);
+    expect(row.summary.counts.other).toBe(2);
+    expect(row.summary.doneLabel).toBe("1 subagent, 2 tool calls");
+  });
 });

packages/ui/src/features/sessions/components/new-thread/conversationThreadConfig.ts

@@ -55,10 +55,19 @@ export const COLLAPSE_MODE_OPTIONS: {
 
 export const grouping = {
   /**
-   * Tool names that spawn a subagent. Counted separately in the chip summary.
-   * @see ToolCallBlock — same names drive the SubagentToolView branch.
+   * Tool names that create a subagent. Counted separately in the chip summary.
    */
-  subagentToolNames: new Set<string>(["Task", "Agent"]),
+  subagentToolNames: new Set<string>(["Task", "Agent", "spawn_agent"]),
+  /** Collaboration tools rendered with the dedicated subagent view. */
+  collaborationToolNames: new Set<string>([
+    "Task",
+    "Agent",
+    "spawn_agent",
+    "send_input",
+    "resume_agent",
+    "wait_agent",
+    "close_agent",
+  ]),
   /**
    * MCP-app tool calls are excluded from collapsing so their iframes stay
    * mounted (the `keepMounted` contract). Flip to false to fold them in.

packages/ui/src/features/sessions/components/session-update/SubagentToolView.tsx

@@ -86,7 +86,8 @@ export function SubagentToolView({
               </TooltipContent>
             </Tooltip>
             <Text className="text-[13px] text-gray-10">
-              {title || "Subagent"}
+              <span className="font-medium text-gray-12">Subagent</span>
+              {title && title !== "Subagent" ? ` · ${title}` : ""}
             </Text>
             <StatusIndicators isFailed={isFailed} wasCancelled={wasCancelled} />
           </Flex>
@@ -135,7 +136,10 @@ export function SubagentToolView({
         wasCancelled={wasCancelled}
         content={childContent}
       >
-        {title || "Subagent"}
+        <span>
+          <span className="font-medium text-gray-12">Subagent</span>
+          {title && title !== "Subagent" ? ` · ${title}` : ""}
+        </span>
       </ToolRow>
     </div>
   );

packages/ui/src/features/sessions/components/session-update/ToolCallBlock.tsx

@@ -16,6 +16,7 @@ import type { ToolCall } from "@posthog/ui/features/sessions/types";
 import { Box } from "@radix-ui/themes";
 import type { ConversationItem, TurnContext } from "../buildConversationItems";
 import { useChatThreadChrome } from "../chat-thread/chatThreadChrome";
+import { grouping } from "../new-thread/conversationThreadConfig";
 import {
   MCP_TOOL_BLOCK_COMPONENT,
   type McpToolBlockComponent,
@@ -47,13 +48,10 @@ export function ToolCallBlock({
 
   const props = { toolCall, turnCancelled, turnComplete };
 
-  if (
-    (toolName === "Task" || toolName === "Agent") &&
-    childItems &&
-    childItems.length > 0
-  ) {
+  if (isSubagentTool(toolName)) {
+    const subagentChildItems = childItems ?? [];
     const turnContext: TurnContext = {
-      toolCalls: buildChildToolCallsMap(childItems),
+      toolCalls: buildChildToolCallsMap(subagentChildItems),
       childItems: childItemsMap ?? new Map(),
       turnCancelled: turnCancelled ?? false,
       turnComplete: turnComplete ?? false,
@@ -62,7 +60,7 @@ export function ToolCallBlock({
       <Box>
         <SubagentToolView
           {...props}
-          childItems={childItems}
+          childItems={subagentChildItems}
           turnContext={turnContext}
         />
       </Box>
@@ -111,6 +109,10 @@ export function ToolCallBlock({
   return <Box>{content}</Box>;
 }
 
+function isSubagentTool(toolName: string | undefined): boolean {
+  return grouping.collaborationToolNames.has(toolName ?? "");
+}
+
 function buildChildToolCallsMap(
   childItems: ConversationItem[],
 ): Map<string, ToolCall> {