@@ -1190,30 +1190,8 @@ For git operations while detached:
           }
         }
 
-        // Forward extension notifications to the renderer as ACP messages
-        // The extNotification callback doesn't write to the stream, so we need
-        // to manually emit these to the renderer
-        if (
-          method === "_posthog/sdk_session" ||
-          method === "_posthog/status" ||
-          method === "_posthog/task_notification" ||
-          method === "_posthog/compact_boundary"
-        ) {
-          log.info("Forwarding extension notification to renderer", {
-            method,
-            taskRunId,
-          });
-          const acpMessage: AcpMessage = {
-            type: "acp_message",
-            ts: Date.now(),
-            message: {
-              jsonrpc: "2.0",
-              method,
-              params,
-            } as AcpMessage["message"],
-          };
-          emitToRenderer(acpMessage);
-        }
+        // Extension notifications already flow through the tapped stream
+        // (same pattern as sessionUpdate). No need to re-emit here.
       },
     };
 
 
@@ -224,6 +224,7 @@ const SessionUpdateRow = memo(function SessionUpdateRow({
     <SessionUpdateView
       item={update}
       toolCalls={turnContext.toolCalls}
+      childItems={turnContext.childItems}
       turnCancelled={turnContext.turnCancelled}
       turnComplete={turnContext.turnComplete}
     />
 
@@ -17,6 +17,7 @@ import type { UserShellExecute } from "./session-update/UserShellExecuteView";
 
 export interface TurnContext {
   toolCalls: Map<string, ToolCall>;
+  childItems: Map<string, ConversationItem[]>;
   turnCancelled: boolean;
   turnComplete: boolean;
 }
@@ -154,8 +155,10 @@ function handlePromptRequest(
   const toolCalls = new Map<string, ToolCall>();
   const gitAction = parseGitActionMessage(userContent);
 
+  const childItems = new Map<string, ConversationItem[]>();
   const context: TurnContext = {
     toolCalls,
+    childItems,
     turnCancelled: false,
     turnComplete: false,
   };
@@ -305,17 +308,93 @@ function extractUserContent(params: unknown): string {
   return visibleTextBlocks.map((b) => b.text).join("");
 }
 
+function getParentToolCallId(update: SessionUpdate): string | undefined {
+  const meta = (update as Record<string, unknown>)?._meta as
+    | { claudeCode?: { parentToolCallId?: string } }
+    | undefined;
+  return meta?.claudeCode?.parentToolCallId;
+}
+
+function pushChildItem(b: ItemBuilder, parentId: string, update: RenderItem) {
+  const turn = b.currentTurn;
+  if (!turn) return;
+  let children = turn.context.childItems.get(parentId);
+  if (!children) {
+    children = [];
+    turn.context.childItems.set(parentId, children);
+  }
+  turn.itemCount++;
+  children.push({
+    type: "session_update",
+    id: `${turn.id}-child-${b.nextId()}`,
+    update,
+    turnContext: turn.context,
+  });
+}
+
+function appendTextChunkToChildren(
+  b: ItemBuilder,
+  parentId: string,
+  update: SessionUpdate & {
+    sessionUpdate: "agent_message_chunk" | "agent_thought_chunk";
+  },
+) {
+  if (update.content.type !== "text") return;
+  const turn = b.currentTurn;
+  if (!turn) return;
+  let children = turn.context.childItems.get(parentId);
+  if (!children) {
+    children = [];
+    turn.context.childItems.set(parentId, children);
+  }
+
+  const lastChild = children[children.length - 1];
+  if (
+    lastChild?.type === "session_update" &&
+    lastChild.update.sessionUpdate === update.sessionUpdate &&
+    "content" in lastChild.update &&
+    lastChild.update.content.type === "text"
+  ) {
+    const prevText = (
+      lastChild.update.content as { type: "text"; text: string }
+    ).text;
+    children[children.length - 1] = {
+      ...lastChild,
+      update: {
+        ...lastChild.update,
+        content: {
+          type: "text",
+          text: prevText + update.content.text,
+        },
+      },
+    };
+  } else {
+    turn.itemCount++;
+    children.push({
+      type: "session_update",
+      id: `${turn.id}-child-${b.nextId()}`,
+      update: { ...update, content: { ...update.content } },
+      turnContext: turn.context,
+    });
+  }
+}
+
 function processSessionUpdate(b: ItemBuilder, update: SessionUpdate) {
   switch (update.sessionUpdate) {
     case "user_message_chunk":
       break;
 
     case "agent_message_chunk":
-    case "agent_thought_chunk":
-      if (update.content.type === "text") {
+    case "agent_thought_chunk": {
+      if (update.content.type !== "text") break;
+      const parentId = getParentToolCallId(update);
+      if (parentId) {
+        appendTextChunkToChildren(b, parentId, update);
+      } else {
         appendTextChunk(b, update);
       }
       break;
+    }
 
     case "tool_call": {
       const turn = b.currentTurn!;
@@ -325,7 +404,12 @@ function processSessionUpdate(b: ItemBuilder, update: SessionUpdate) {
       } else {
         const toolCall = { ...update };
         turn.toolCalls.set(update.toolCallId, toolCall);
-        pushItem(b, toolCall);
+        const parentId = getParentToolCallId(update);
+        if (parentId) {
+          pushChildItem(b, parentId, toolCall);
+        } else {
+          pushItem(b, toolCall);
+        }
       }
       break;
     }
 
@@ -1,3 +1,4 @@
+import type { ConversationItem } from "@features/sessions/components/buildConversationItems";
 import type { SessionUpdate, ToolCall } from "@features/sessions/types";
 import { memo } from "react";
 
@@ -44,13 +45,15 @@ export type RenderItem =
 interface SessionUpdateViewProps {
   item: RenderItem;
   toolCalls?: Map<string, ToolCall>;
+  childItems?: Map<string, ConversationItem[]>;
   turnCancelled?: boolean;
   turnComplete?: boolean;
 }
 
 export const SessionUpdateView = memo(function SessionUpdateView({
   item,
   toolCalls,
+  childItems,
   turnCancelled,
   turnComplete,
 }: SessionUpdateViewProps) {
@@ -71,6 +74,8 @@ export const SessionUpdateView = memo(function SessionUpdateView({
           toolCall={toolCalls?.get(item.toolCallId) ?? item}
           turnCancelled={turnCancelled}
           turnComplete={turnComplete}
+          childItems={childItems?.get(item.toolCallId)}
+          childItemsMap={childItems}
         />
       );
     case "tool_call_update":
 
@@ -0,0 +1,99 @@
+import type {
+  ConversationItem,
+  TurnContext,
+} from "@features/sessions/components/buildConversationItems";
+import {
+  ArrowsInSimple as ArrowsInSimpleIcon,
+  ArrowsOutSimple as ArrowsOutSimpleIcon,
+  Brain,
+} from "@phosphor-icons/react";
+import { Box, Flex, IconButton, Text } from "@radix-ui/themes";
+import { useEffect, useState } from "react";
+import { SessionUpdateView } from "./SessionUpdateView";
+import {
+  LoadingIcon,
+  StatusIndicators,
+  type ToolViewProps,
+  useToolCallStatus,
+} from "./toolCallUtils";
+
+interface SubagentToolViewProps extends ToolViewProps {
+  childItems: ConversationItem[];
+  turnContext: TurnContext;
+}
+
+export function SubagentToolView({
+  toolCall,
+  turnCancelled,
+  turnComplete,
+  childItems,
+  turnContext,
+}: SubagentToolViewProps) {
+  const { title } = toolCall;
+  const { isLoading, isFailed, wasCancelled, isComplete } = useToolCallStatus(
+    toolCall.status,
+    turnCancelled,
+    turnComplete,
+  );
+
+  const [isExpanded, setIsExpanded] = useState(true);
+
+  useEffect(() => {
+    if (isComplete || isFailed || wasCancelled) {
+      setIsExpanded(false);
+    }
+  }, [isComplete, isFailed, wasCancelled]);
+
+  const hasChildren = childItems.length > 0;
+
+  return (
+    <Box className="my-2 max-w-4xl overflow-hidden rounded-lg border border-gray-6 bg-gray-1">
+      <button
+        type="button"
+        onClick={() => setIsExpanded(!isExpanded)}
+        className="flex w-full cursor-pointer items-center justify-between border-none bg-transparent px-3 py-2"
+      >
+        <Flex align="center" gap="2">
+          <LoadingIcon
+            icon={Brain}
+            isLoading={isLoading}
+            className="text-gray-10"
+          />
+          <Text size="1" className="text-gray-10">
+            {title || "Subagent"}
+          </Text>
+          <StatusIndicators isFailed={isFailed} wasCancelled={wasCancelled} />
+        </Flex>
+        {hasChildren && (
+          <IconButton asChild size="1" variant="ghost" color="gray">
+            <span>
+              {isExpanded ? (
+                <ArrowsInSimpleIcon size={12} />
+              ) : (
+                <ArrowsOutSimpleIcon size={12} />
+              )}
+            </span>
+          </IconButton>
+        )}
+      </button>
+
+      {isExpanded && hasChildren && (
+        <Box className="space-y-1 border-gray-6 border-t px-2 py-2">
+          {childItems.map((child) => {
+            if (child.type !== "session_update") return null;
+            return (
+              <SessionUpdateView
+                key={child.id}
+                item={child.update}
+                toolCalls={turnContext.toolCalls}
+                childItems={turnContext.childItems}
+                turnCancelled={turnContext.turnCancelled}
+                turnComplete={turnContext.turnComplete}
+              />
+            );
+          })}
+        </Box>
+      )}
+    </Box>
+  );
+}
@@ -1,3 +1,8 @@
+import type {
+  ConversationItem,
+  TurnContext,
+} from "@features/sessions/components/buildConversationItems";
+import type { ToolCall } from "@features/sessions/types";
 import { Box } from "@radix-ui/themes";
 import { DeleteToolView } from "./DeleteToolView";
 import { EditToolView } from "./EditToolView";
@@ -8,15 +13,23 @@ import { PlanApprovalView } from "./PlanApprovalView";
 import { QuestionToolView } from "./QuestionToolView";
 import { ReadToolView } from "./ReadToolView";
 import { SearchToolView } from "./SearchToolView";
+import { SubagentToolView } from "./SubagentToolView";
 import { ThinkToolView } from "./ThinkToolView";
 import { ToolCallView } from "./ToolCallView";
 import type { ToolViewProps } from "./toolCallUtils";
 
+interface ToolCallBlockProps extends ToolViewProps {
+  childItems?: ConversationItem[];
+  childItemsMap?: Map<string, ConversationItem[]>;
+}
+
 export function ToolCallBlock({
   toolCall,
   turnCancelled,
   turnComplete,
-}: ToolViewProps) {
+  childItems,
+  childItemsMap,
+}: ToolCallBlockProps) {
   const meta = toolCall._meta as
     | { claudeCode?: { toolName?: string } }
     | undefined;
@@ -28,6 +41,24 @@ export function ToolCallBlock({
 
   const props = { toolCall, turnCancelled, turnComplete };
 
+  if (toolName === "Task" && childItems && childItems.length > 0) {
+    const turnContext: TurnContext = {
+      toolCalls: buildChildToolCallsMap(childItems),
+      childItems: childItemsMap ?? new Map(),
+      turnCancelled: turnCancelled ?? false,
+      turnComplete: turnComplete ?? false,
+    };
+    return (
+      <Box className="pl-3">
+        <SubagentToolView
+          {...props}
+          childItems={childItems}
+          turnContext={turnContext}
+        />
+      </Box>
+    );
+  }
+
   const content = (() => {
     switch (toolCall.kind) {
       case "switch_mode":
@@ -57,3 +88,21 @@ export function ToolCallBlock({
 
   return <Box className="pl-3">{content}</Box>;
 }
+
+function buildChildToolCallsMap(
+  childItems: ConversationItem[],
+): Map<string, ToolCall> {
+  const map = new Map<string, ToolCall>();
+  for (const item of childItems) {
+    if (
+      item.type === "session_update" &&
+      item.update.sessionUpdate === "tool_call"
+    ) {
+      const tc = item.update as unknown as ToolCall;
+      if (tc.toolCallId) {
+        map.set(tc.toolCallId, tc);
+      }
+    }
+  }
+  return map;
+}