fix(server): keep short strings whole and typed arrays valid when limiting items

Strings up to 1 KiB are never cut, so a tool call keeps its callId and an
item limits to the same result twice. Arrays drop trailing elements
without inserting a marker element, which typed arrays such as todo items
would reject.

docs/timeline-sync.md

@@ -21,10 +21,16 @@ The invariants are:
 > agent establishes the daemon's current tail in one complete-turn request, with older history reachable
 > through backward pagination.
 
-Tool output is bounded before it enters either delivery path. Canonical shell tool output is sliced
-to 64 KiB, and the same bounded item is used for runtime timeline rows and live stream events.
-Provider history hydration applies the same rule so reopening an agent cannot restore an oversized
-tool payload.
+Every item is bounded before it enters either delivery path, because a timeline page is one
+WebSocket message and the daemon closes a socket whose outbound buffer passes 64 MiB. Tool calls get
+64 KiB and other items 256 KiB. Over budget, the largest strings are cut to a shared length with a
+`…[truncated 12.3 MB]` marker, and an oversized `data:` URL is replaced by the marker. Strings up
+to 1 KiB stay whole, so ids and paths survive. Arrays drop their trailing elements without a marker
+element, so typed arrays still match the wire schema. Limiting an item twice gives the same item. The
+budget does not bound wide objects or multi-byte text. The same
+bounded item is used for runtime timeline rows and live stream events. Provider history hydration
+applies the same rule so reopening an agent cannot restore an oversized payload. Fetches apply it
+again to assistant and reasoning rows the projection merges from many chunks.
 
 ## Presence is not delivery
 

packages/app/src/components/tool-call-details.tsx

@@ -64,7 +64,7 @@ function resolveShouldFill(
 ): boolean {
   if (!fillAvailableHeight) return false;
   const t = detail?.type;
-  return t === "shell" || t === "edit" || t === "write" || t === "read";
+  return t === "shell" || t === "edit" || t === "write" || t === "read" || t === "sub_agent";
 }
 
 function useDetailStyles(
@@ -186,6 +186,184 @@ function ShellDetailSection({ command, output, ds }: ShellDetailProps) {
   );
 }
 
+function resolveSubAgentFallbackHeader(
+  subAgentType: string | null | undefined,
+  description: string | null | undefined,
+  fallbackText: string,
+): string {
+  if (subAgentType && description) {
+    return `${subAgentType}: ${description}`;
+  }
+  return subAgentType ?? description ?? fallbackText;
+}
+
+interface SubAgentDetailProps {
+  log: string;
+  childSessionId: string | null | undefined;
+  subAgentType: string | null | undefined;
+  description: string | null | undefined;
+  ds: DetailStyles;
+}
+
+interface SubAgentActivityRow {
+  index: number;
+  toolName: string;
+  summary?: string;
+}
+
+interface ParsedSubAgentLog {
+  actions: SubAgentActivityRow[];
+  remainingLog: string;
+}
+
+function parseBracketedSubAgentLine(line: string, index: number): SubAgentActivityRow | null {
+  const match = line.match(/^\[([^\]]+)\](?:\s+(.*))?$/);
+  if (!match) {
+    return null;
+  }
+  const toolName = match[1]?.trim();
+  if (!toolName) {
+    return null;
+  }
+  const summary = match[2]?.trim();
+  return {
+    index,
+    toolName,
+    ...(summary ? { summary } : {}),
+  };
+}
+
+function parseSubAgentLog(log: string): ParsedSubAgentLog {
+  const actions: SubAgentActivityRow[] = [];
+  const remainingLines: string[] = [];
+  for (const line of log.replace(/^\n+/, "").split("\n")) {
+    const normalizedLine = line.trim();
+    if (!normalizedLine) {
+      continue;
+    }
+    const parsedAction = parseBracketedSubAgentLine(normalizedLine, actions.length + 1);
+    if (parsedAction) {
+      actions.push(parsedAction);
+    } else {
+      remainingLines.push(line);
+    }
+  }
+  return {
+    actions,
+    remainingLog: remainingLines.join("\n").replace(/^\n+/, ""),
+  };
+}
+
+function SubAgentActionRow({ action }: { action: SubAgentActivityRow }) {
+  return (
+    <View style={styles.subAgentActionRow}>
+      <Text selectable style={styles.subAgentActionTool}>
+        {formatSubAgentToolName(action.toolName)}
+      </Text>
+      {action.summary ? (
+        <Text selectable style={styles.subAgentActionSummary}>
+          {action.summary}
+        </Text>
+      ) : null}
+    </View>
+  );
+}
+
+function formatSubAgentToolName(toolName: string): string {
+  const trimmed = toolName.trim();
+  if (!trimmed) {
+    return toolName;
+  }
+  return trimmed
+    .replace(/[._-]+/g, " ")
+    .split(" ")
+    .filter((segment) => segment.length > 0)
+    .map((segment) => `${segment[0]?.toUpperCase() ?? ""}${segment.slice(1)}`)
+    .join(" ");
+}
+
+function SubAgentLogText({
+  activityLog,
+  fallbackHeader,
+  hasActions,
+}: {
+  activityLog: string;
+  fallbackHeader: string;
+  hasActions: boolean;
+}) {
+  if (activityLog.length > 0) {
+    return (
+      <Text selectable style={styles.scrollText}>
+        {activityLog}
+      </Text>
+    );
+  }
+  if (!hasActions) {
+    return (
+      <Text selectable style={styles.scrollText}>
+        {fallbackHeader}
+      </Text>
+    );
+  }
+  return null;
+}
+
+function SubAgentDetailSection({
+  log,
+  childSessionId,
+  subAgentType,
+  description,
+  ds,
+}: SubAgentDetailProps) {
+  const { t } = useTranslation();
+  const { actions, remainingLog } = useMemo(() => parseSubAgentLog(log), [log]);
+  const fallbackHeader = resolveSubAgentFallbackHeader(
+    subAgentType,
+    description,
+    t("toolCallDetails.subAgentActivity"),
+  );
+  const hasActions = actions.length > 0;
+  return (
+    <View style={ds.sectionFillStyle}>
+      <View style={ds.codeBlockFillStyle}>
+        <ScrollView
+          style={ds.codeVerticalScrollStyle}
+          contentContainerStyle={styles.codeVerticalContent}
+          nestedScrollEnabled
+          showsVerticalScrollIndicator
+        >
+          <ScrollView
+            horizontal
+            nestedScrollEnabled
+            showsHorizontalScrollIndicator
+            contentContainerStyle={styles.codeHorizontalContent}
+          >
+            <View style={styles.codeLine} dataSet={CODE_SURFACE_DATASET}>
+              {childSessionId ? (
+                <Text selectable style={styles.subAgentSessionText}>
+                  session {childSessionId}
+                </Text>
+              ) : null}
+              {hasActions ? (
+                <View style={styles.subAgentActions}>
+                  {actions.map((action) => (
+                    <SubAgentActionRow key={action.index} action={action} />
+                  ))}
+                </View>
+              ) : null}
+              <SubAgentLogText
+                activityLog={remainingLog}
+                fallbackHeader={fallbackHeader}
+                hasActions={hasActions}
+              />
+            </View>
+          </ScrollView>
+        </ScrollView>
+      </View>
+    </View>
+  );
+}
+
 interface EditDetailProps {
   diffLines: DiffLine[] | undefined;
   ds: DetailStyles;
@@ -458,7 +636,19 @@ function buildDetailSections(
       <ShellDetailSection key="shell" command={detail.command} output={detail.output} ds={ds} />,
     ];
   }
-  if (detail.type === "worktree_setup" || detail.type === "sub_agent") return [];
+  if (detail.type === "worktree_setup") return [];
+  if (detail.type === "sub_agent") {
+    return [
+      <SubAgentDetailSection
+        key="sub-agent"
+        log={detail.log}
+        childSessionId={detail.childSessionId}
+        subAgentType={detail.subAgentType}
+        description={detail.description}
+        ds={ds}
+      />,
+    ];
+  }
   if (detail.type === "edit") {
     return [<EditDetailSection key="edit" diffLines={diffLines} ds={ds} />];
   }
@@ -710,6 +900,34 @@ const styles = StyleSheet.create((theme) => {
     shellPrompt: {
       color: theme.colors.foregroundMuted,
     },
+    subAgentSessionText: {
+      fontFamily: theme.fontFamily.mono,
+      fontSize: theme.fontSize.code,
+      color: theme.colors.foregroundMuted,
+      lineHeight: 18,
+      marginBottom: theme.spacing[2],
+    },
+    subAgentActions: {
+      gap: theme.spacing[1],
+      marginBottom: theme.spacing[2],
+    },
+    subAgentActionRow: {
+      flexDirection: "row",
+      alignItems: "center",
+      gap: theme.spacing[2],
+    },
+    subAgentActionTool: {
+      fontFamily: theme.fontFamily.mono,
+      fontSize: theme.fontSize.code,
+      color: theme.colors.foregroundMuted,
+      lineHeight: 18,
+    },
+    subAgentActionSummary: {
+      fontFamily: theme.fontFamily.mono,
+      fontSize: theme.fontSize.code,
+      color: theme.colors.foreground,
+      lineHeight: 18,
+    },
     jsonScroll: {
       borderWidth: theme.borderWidth[1],
       borderColor: theme.colors.border,

packages/app/src/i18n/resources.test.ts

@@ -832,6 +832,7 @@ describe("translation resources", () => {
     expect(en.common.placeholders.search).toBe("Search...");
     expect(en.common.empty.noResults).toBe("No results found");
     expect(en.common.empty.noOptionsMatchSearch).toBe("No options match your search.");
+    expect(en.toolCallDetails.subAgentActivity).toBe("Sub-agent activity");
     expect(en.panels.file.failedToLoadPreview).toBe("Failed to load file preview");
   });
 

packages/app/src/i18n/resources/ar.ts

@@ -2013,6 +2013,7 @@ export const ar: TranslationResources = {
   toolCallDetails: {
     error: "خطأ",
     empty: "لا توجد تفاصيل إضافية متاحة",
+    subAgentActivity: "نشاط الوكيل الفرعي",
     input: "مدخل",
     output: "الإخراج",
   },

packages/app/src/i18n/resources/en.ts

@@ -2038,6 +2038,7 @@ export const en = {
   toolCallDetails: {
     error: "Error",
     empty: "No additional details available",
+    subAgentActivity: "Sub-agent activity",
     input: "Input",
     output: "Output",
   },

packages/app/src/i18n/resources/es.ts

@@ -2061,6 +2061,7 @@ export const es: TranslationResources = {
   toolCallDetails: {
     error: "Error",
     empty: "No hay detalles adicionales disponibles",
+    subAgentActivity: "Actividad de subagente",
     input: "Aporte",
     output: "Producción",
   },

packages/app/src/i18n/resources/fr.ts

@@ -2060,6 +2060,7 @@ export const fr: TranslationResources = {
   toolCallDetails: {
     error: "Erreur",
     empty: "Aucun détail supplémentaire disponible",
+    subAgentActivity: "Activité du sous-agent",
     input: "Entrée",
     output: "Sortie",
   },

packages/app/src/i18n/resources/ja.ts

@@ -2033,6 +2033,7 @@ export const ja: TranslationResources = {
   toolCallDetails: {
     error: "エラー",
     empty: "追加の詳細はありません",
+    subAgentActivity: "サブエージェントアクティビティ",
     input: "入力",
     output: "出力",
   },

packages/app/src/i18n/resources/ko.ts

@@ -2023,6 +2023,7 @@ export const ko: TranslationResources = {
   toolCallDetails: {
     error: "오류",
     empty: "추가 세부 정보가 없습니다",
+    subAgentActivity: "서브에이전트 활동",
     input: "입력",
     output: "출력",
   },

packages/app/src/i18n/resources/pt-BR.ts

@@ -2046,6 +2046,7 @@ export const ptBR: TranslationResources = {
   toolCallDetails: {
     error: "Erro",
     empty: "Nenhum detalhe adicional disponível",
+    subAgentActivity: "Atividade do subagente",
     input: "Entrada",
     output: "Saída",
   },

packages/app/src/i18n/resources/ru.ts

@@ -2046,6 +2046,7 @@ export const ru: TranslationResources = {
   toolCallDetails: {
     error: "Ошибка",
     empty: "Дополнительные сведения отсутствуют",
+    subAgentActivity: "Активность субагента",
     input: "Входные данные",
     output: "Выходные данные",
   },

packages/app/src/i18n/resources/zh-CN.ts

@@ -1991,6 +1991,7 @@ export const zhCN: TranslationResources = {
   toolCallDetails: {
     error: "错误",
     empty: "没有可用的更多详情",
+    subAgentActivity: "Sub-agent 活动",
     input: "输入",
     output: "输出",
   },

packages/app/src/utils/tool-call-detail-state.ts

@@ -40,6 +40,12 @@ function hasMeaningfulFetchDetail(detail: Extract<ToolCallDetail, { type: "fetch
   return Boolean(detail.url || detail.result || detail.codeText);
 }
 
+function hasMeaningfulSubAgentDetail(
+  detail: Extract<ToolCallDetail, { type: "sub_agent" }>,
+): boolean {
+  return Boolean(detail.subAgentType || detail.description || detail.log);
+}
+
 function hasMeaningfulPlainTextDetail(
   detail: Extract<ToolCallDetail, { type: "plain_text" }>,
 ): boolean {
@@ -69,9 +75,9 @@ export function hasMeaningfulToolCallDetail(detail: ToolCallDetail | undefined):
     case "fetch":
       return hasMeaningfulFetchDetail(detail);
     case "worktree_setup":
-    // A sub-agent card is a launch marker; the child's activity lives in the sub-agent panel.
-    case "sub_agent":
       return false;
+    case "sub_agent":
+      return hasMeaningfulSubAgentDetail(detail);
     case "plain_text":
       return hasMeaningfulPlainTextDetail(detail);
     case "plan":
@@ -86,7 +92,7 @@ export function isPendingToolCallDetail(params: {
   status: "executing" | "running" | "completed" | "failed" | "canceled";
   error: unknown;
 }): boolean {
-  if (params.detail?.type === "worktree_setup" || params.detail?.type === "sub_agent") return false;
+  if (params.detail?.type === "worktree_setup") return false;
   const isRunning = params.status === "running" || params.status === "executing";
   return isRunning && params.error == null && !hasMeaningfulToolCallDetail(params.detail);
 }

packages/protocol/src/agent-types.ts

@@ -288,7 +288,7 @@ export type ToolCallDetail =
       subAgentType?: string;
       description?: string;
       childSessionId?: string;
-      log?: string;
+      log: string;
       actions?: Array<{
         index: number;
         toolName: string;

packages/protocol/src/messages.ts

@@ -638,9 +638,7 @@ const ToolCallDetailPayloadSchema: z.ZodType<ToolCallDetail, unknown> = z.discri
       subAgentType: z.string().optional(),
       description: z.string().optional(),
       childSessionId: z.string().optional(),
-      // COMPAT(subagent-log): added in v0.14.1, remove after 2027-04-30. A sub-agent card is a
-      // launch marker; apps before v0.14.1 required `log`, so daemons still send it empty.
-      log: z.string().optional(),
+      log: z.string(),
       // Compat cruft for clients <= 0.1.65-beta.3 that required this field. Producers still
       // emit `[]`; nothing reads it. Drop the field (and the `[]` emissions) once those
       // clients are no longer in the field.

packages/protocol/src/messages.wire-compat.test.ts

@@ -200,8 +200,8 @@ describe("wire schema compatibility", () => {
     });
   });
 
-  test("a sub-agent launch marker still parses against the v0.1.65-beta.3 schema", () => {
-    const card = {
+  test("sub_agent tool-call payload still parses against the v0.1.65-beta.3 schema", () => {
+    const parsed = LegacySubAgentToolCallSchema.parse({
       type: "tool_call",
       callId: "call-sub-agent-1",
       name: "Task",
@@ -212,26 +212,12 @@ describe("wire schema compatibility", () => {
         subAgentType: "Explore",
         description: "Inspect repository structure",
         childSessionId: "child-session-1",
-        log: "",
+        log: "[Read] README.md",
         actions: [],
       },
-    } as const;
-
-    const parsed = LegacySubAgentToolCallSchema.parse(JSON.parse(JSON.stringify(card)));
-    expect(parsed.detail).toMatchObject({ log: "", actions: [] });
-    const { log: _log, ...withoutLog } = card.detail;
-    expect(LegacySubAgentToolCallSchema.safeParse({ ...card, detail: withoutLog }).success).toBe(
-      false,
-    );
-    expect(AgentTimelineItemPayloadSchema.parse({ ...card, detail: withoutLog })).toMatchObject({
-      detail: { type: "sub_agent", description: "Inspect repository structure" },
     });
-    expect(
-      AgentTimelineItemPayloadSchema.parse({
-        ...card,
-        detail: { ...card.detail, log: "[Read] README.md" },
-      }),
-    ).toMatchObject({ detail: { log: "[Read] README.md" } });
+
+    expect(parsed.detail.actions).toEqual([]);
   });
 
   test("old clients parse agent snapshots with rewind capabilities", () => {

packages/server/src/server/agent/activity-curator.test.ts

@@ -247,7 +247,7 @@ second line'`,
     ]);
   });
 
-  it("lists each sub-agent as its launch marker", () => {
+  it("keeps nested sub-agent logs beside the sub-agent that produced them", () => {
     const timeline: AgentTimelineItem[] = [
       { type: "assistant_message", text: "Before first child." },
       toolCallItem({
@@ -257,7 +257,7 @@ second line'`,
           type: "sub_agent",
           subAgentType: "Child one",
           description: "First investigation",
-          log: "",
+          log: "[Assistant] First child result.",
         },
       }),
       { type: "assistant_message", text: "Between children." },
@@ -268,7 +268,7 @@ second line'`,
           type: "sub_agent",
           subAgentType: "Child two",
           description: "Second investigation",
-          log: "",
+          log: "[Assistant] Second child result.",
         },
       }),
       { type: "assistant_message", text: "After second child." },
@@ -279,8 +279,10 @@ second line'`,
     expect(result.split("\n")).toEqual([
       "[Assistant] Before first child.",
       "[Child one] First investigation",
+      "[Assistant] First child result.",
       "[Assistant] Between children.",
       "[Child two] Second investigation",
+      "[Assistant] Second child result.",
       "[Assistant] After second child.",
     ]);
   });

packages/server/src/server/agent/activity-curator.ts

@@ -164,6 +164,9 @@ function curateProjectedActivityEntries(
           break;
         }
         entries.push(formatToolCallEntry(item, options));
+        if (item.detail.type === "sub_agent" && item.detail.log.trim()) {
+          entries.push(activityEntry(item.detail.log.trim()));
+        }
         break;
       }
       case "todo":

packages/server/src/server/agent/agent-manager-stream-coalescing.test.ts

@@ -6,6 +6,7 @@ import { afterEach, describe, expect, test, vi } from "vitest";
 import { createTestLogger } from "../../test-utils/test-logger.js";
 import { AgentManager, type AgentManagerEvent } from "./agent-manager.js";
 import { AGENT_STREAM_COALESCE_DEFAULT_WINDOW_MS } from "./agent-stream-coalescer.js";
+import { limitAgentTimelineItemContent } from "./agent-timeline-content.js";
 import type { AgentTimelineRow } from "./agent-timeline-store-types.js";
 import { projectTimelineRows } from "./timeline-projection.js";
 import type {
@@ -31,7 +32,6 @@ import type {
 
 const COALESCE_WINDOW_MS = AGENT_STREAM_COALESCE_DEFAULT_WINDOW_MS;
 const BEFORE_COALESCE_WINDOW_MS = Math.max(COALESCE_WINDOW_MS - 1, 0);
-const TOOL_CALL_CONTENT_MAX_LENGTH = 64 * 1024;
 
 const TEST_CAPABILITIES: AgentCapabilityFlags = {
   supportsStreaming: false,
@@ -400,10 +400,7 @@ describe("target coalesced behavior", () => {
     try {
       const { agentId, session } = await createManagedSession(harness);
       const output = `${"a".repeat(512 * 1024)}${"z".repeat(512 * 1024)}`;
-      const expectedItem = toolCall({
-        status: "completed",
-        output: "a".repeat(TOOL_CALL_CONTENT_MAX_LENGTH),
-      });
+      const expectedItem = limitAgentTimelineItemContent(toolCall({ status: "completed", output }));
 
       session.pushEvent(timelineEvent(toolCall({ status: "completed", output })));
       await waitForSessionEventQueue();
@@ -425,10 +422,7 @@ describe("target coalesced behavior", () => {
     try {
       const { agentId } = await createManagedSession(harness);
       const output = `${"a".repeat(512 * 1024)}${"z".repeat(512 * 1024)}`;
-      const expectedItem = toolCall({
-        status: "completed",
-        output: "a".repeat(TOOL_CALL_CONTENT_MAX_LENGTH),
-      });
+      const expectedItem = limitAgentTimelineItemContent(toolCall({ status: "completed", output }));
 
       await harness.manager.appendTimelineItem(agentId, toolCall({ status: "completed", output }));
 
@@ -449,10 +443,7 @@ describe("target coalesced behavior", () => {
     try {
       const { agentId, session } = await createManagedSession(harness);
       const output = `${"a".repeat(512 * 1024)}${"z".repeat(512 * 1024)}`;
-      const expectedItem = toolCall({
-        status: "completed",
-        output: "a".repeat(TOOL_CALL_CONTENT_MAX_LENGTH),
-      });
+      const expectedItem = limitAgentTimelineItemContent(toolCall({ status: "completed", output }));
       session.setHistory([timelineEvent(toolCall({ status: "completed", output }))]);
 
       await harness.manager.hydrateTimelineFromProvider(agentId, { force: true });
@@ -470,10 +461,7 @@ describe("target coalesced behavior", () => {
     try {
       const { agentId } = await createManagedSession(harness);
       const output = `${"a".repeat(512 * 1024)}${"z".repeat(512 * 1024)}`;
-      const expectedItem = toolCall({
-        status: "completed",
-        output: "a".repeat(TOOL_CALL_CONTENT_MAX_LENGTH),
-      });
+      const expectedItem = limitAgentTimelineItemContent(toolCall({ status: "completed", output }));
 
       await harness.manager.emitLiveTimelineItem(
         agentId,
@@ -495,10 +483,9 @@ describe("target coalesced behavior", () => {
     try {
       const { agentId, session } = await createManagedSession(harness);
       const content = `${"a".repeat(512 * 1024)}${"z".repeat(512 * 1024)}`;
-      const expectedItem = toolCall({
-        status: "failed",
-        error: { content: "a".repeat(TOOL_CALL_CONTENT_MAX_LENGTH) },
-      });
+      const expectedItem = limitAgentTimelineItemContent(
+        toolCall({ status: "failed", error: { content } }),
+      );
 
       session.pushEvent(timelineEvent(toolCall({ status: "failed", error: { content } })));
       await waitForSessionEventQueue();

packages/server/src/server/agent/agent-manager.test.ts

@@ -21,6 +21,7 @@ import {
 } from "./agent-manager.js";
 import { AgentStorage } from "./agent-storage.js";
 import { InMemoryAgentTimelineStore } from "./agent-timeline-store.js";
+import { limitAgentTimelineItemContent } from "./agent-timeline-content.js";
 import { toAgentPayload } from "./agent-projections.js";
 import { projectTimelineRows } from "./timeline-projection.js";
 import { getOpenAgentTabLabel, PARENT_AGENT_ID_LABEL } from "@getpaseo/protocol/agent-labels";
@@ -4592,7 +4593,7 @@ test("importProviderSession imports the selected session without listing and pub
   expect(manager.getTimeline(imported.id)).toEqual([
     { type: "user_message", text: "Trace provider imports" },
     { type: "assistant_message", text: "Done" },
-    {
+    limitAgentTimelineItemContent({
       type: "tool_call",
       callId: "large-shell-result",
       name: "shell",
@@ -4601,10 +4602,10 @@ test("importProviderSession imports the selected session without listing and pub
       detail: {
         type: "shell",
         command: "print output",
-        output: "x".repeat(64 * 1024),
+        output: "x".repeat(1024 * 1024),
         exitCode: 0,
       },
-    },
+    }),
   ]);
   expect(manager.listProviderSubagents(imported.id)).toEqual([
     expect.objectContaining({ id: "thread-child", title: "Imported child", status: "completed" }),
@@ -11957,10 +11958,7 @@ test("commits startup notices once on create and after restored history", async
       exitCode: 0,
     },
   };
-  const limitedToolOutput: AgentTimelineItem = {
-    ...toolOutput,
-    detail: { type: "shell", command: "print output", output: "x".repeat(64 * 1024), exitCode: 0 },
-  };
+  const limitedToolOutput = limitAgentTimelineItemContent(toolOutput);
   class NotifyingSession extends TestAgentSession {
     readonly initialTimeline = [{ item: notice, timestamp: "2026-09-22T00:00:00.000Z" }];
     override async *streamHistory(): AsyncGenerator<AgentStreamEvent> {

packages/server/src/server/agent/agent-sdk-types.ts

@@ -313,10 +313,7 @@ export type ToolCallDetail =
       subAgentType?: string;
       description?: string;
       childSessionId?: string;
-      // COMPAT(subagent-log): added in v0.14.1, remove after 2027-04-30. Apps before v0.14.1
-      // require `log`; every producer sends it empty and carries the same tag. Optional here because
-      // protocol timeline items, where `log` is optional, flow into this type.
-      log?: string;
+      log: string;
       actions?: Array<{
         index: number;
         toolName: string;

packages/server/src/server/agent/agent-timeline-content.test.ts

@@ -1,12 +1,30 @@
+import { AgentTimelineItemPayloadSchema } from "@getpaseo/protocol/messages";
 import { describe, expect, test } from "vitest";
 
+import type { AgentTimelineItem } from "./agent-sdk-types.js";
 import { limitAgentTimelineItemContent } from "./agent-timeline-content.js";
 
+function serializedBytes(item: AgentTimelineItem): number {
+  return Buffer.byteLength(JSON.stringify(item), "utf8");
+}
+
 describe("agent timeline content", () => {
+  test("returns an item within budget unchanged", () => {
+    const item: AgentTimelineItem = {
+      type: "tool_call",
+      callId: "small",
+      name: "Bash",
+      status: "completed",
+      error: null,
+      detail: { type: "shell", command: "ls", output: "x".repeat(60 * 1024) },
+    };
+    expect(limitAgentTimelineItemContent(item)).toBe(item);
+  });
+
   test.each([false, true])(
-    "preserves the exact UTF-16 prefix for oversized shell output (failed=%s)",
+    "cuts oversized shell output and keeps short fields whole (failed=%s)",
     (failed) => {
-      const text = "x".repeat(64 * 1024 - 1) + "🙂";
+      const text = "x".repeat(1024 * 1024) + "🙂";
       const item = limitAgentTimelineItemContent({
         type: "tool_call",
         callId: "large-shell",
@@ -15,45 +33,116 @@ describe("agent timeline content", () => {
         detail: { type: "shell", command: "echo large", output: text },
         error: failed ? { content: text } : null,
       });
-      expect(item).toEqual({
-        type: "tool_call",
+      expect(item).toMatchObject({
         callId: "large-shell",
         name: "Bash",
-        status: failed ? "failed" : "completed",
-        detail: { type: "shell", command: "echo large", output: text.slice(0, 64 * 1024) },
-        error: failed ? { content: text.slice(0, 64 * 1024) } : null,
+        detail: { type: "shell", command: "echo large" },
       });
+      if (item.type !== "tool_call" || item.detail.type !== "shell") throw new Error("shape");
+      expect(item.detail.output).toMatch(/^x+…\[truncated \d{3}\.\d KB\]$/);
+      expect(serializedBytes(item)).toBeLessThanOrEqual(64 * 1024);
     },
   );
 
-  test("marks truncated plain-text tool content within the content budget", () => {
-    const oversizedInput = "x".repeat(64 * 1024 + 1);
-
+  test("replaces an oversized data URL in an unknown tool result with a marker", () => {
+    const url = `data:image/jpeg;base64,${"A".repeat(14 * 1024 * 1024)}`;
     const item = limitAgentTimelineItemContent({
       type: "tool_call",
-      callId: "terminal-session-4242",
-      name: "terminal",
+      callId: "screenshot",
+      name: "node_repl.js",
       status: "completed",
       error: null,
       detail: {
-        type: "plain_text",
-        text: oversizedInput,
-        icon: "square_terminal",
+        type: "unknown",
+        input: { index: 1 },
+        output: { content: [{ type: "image", url }], note: "captured" },
       },
     });
-
-    expect(limitAgentTimelineItemContent(item)).toEqual(item);
     expect(item).toEqual({
       type: "tool_call",
-      callId: "terminal-session-4242",
-      name: "terminal",
+      callId: "screenshot",
+      name: "node_repl.js",
       status: "completed",
       error: null,
       detail: {
-        type: "plain_text",
-        text: "x".repeat(64 * 1024 - "\n\n[Content truncated]".length) + "\n\n[Content truncated]",
-        icon: "square_terminal",
+        type: "unknown",
+        input: { index: 1 },
+        output: { content: [{ type: "image", url: "…[truncated 14.0 MB]" }], note: "captured" },
       },
     });
   });
+
+  test("gives non-tool items a 256 KiB budget", () => {
+    const text = "a".repeat(10 * 1024 * 1024);
+    const item = limitAgentTimelineItemContent({ type: "assistant_message", text });
+    if (item.type !== "assistant_message") throw new Error("shape");
+    expect(item.text).toMatch(/^a+…\[truncated 9\.\d MB\]$/);
+    expect(item.text.length).toBeGreaterThan(200 * 1024);
+    expect(serializedBytes(item)).toBeLessThanOrEqual(256 * 1024);
+  });
+
+  test("bounds an item whose structure alone exceeds the budget", () => {
+    const item = limitAgentTimelineItemContent({
+      type: "tool_call",
+      callId: "many",
+      name: "query",
+      status: "completed",
+      error: null,
+      detail: { type: "unknown", input: null, output: Array.from({ length: 1_000_000 }, () => 1) },
+    });
+    if (item.type !== "tool_call" || item.detail.type !== "unknown") throw new Error("shape");
+    const output = item.detail.output as unknown[];
+    expect(output.length).toBeLessThan(1_000_000);
+    expect(output.every((value) => value === 1)).toBe(true);
+    expect(serializedBytes(item)).toBeLessThanOrEqual(64 * 1024);
+  });
+
+  test("keeps short strings whole and limits idempotently when an item has many strings", () => {
+    const callId = "3f2b8c1e-9a4d-4e6f-8b2a-1c3d5e7f9a0b";
+    const item = limitAgentTimelineItemContent({
+      type: "tool_call",
+      callId,
+      name: "mcp__search__files",
+      status: "completed",
+      error: null,
+      detail: {
+        type: "unknown",
+        input: { query: "useWorkspaceSomethingVeryDescriptive" },
+        output: Array.from(
+          { length: 10_000 },
+          (_, index) => `${String(index).padStart(5, "0")}${"p".repeat(28)}`,
+        ),
+      },
+    });
+    if (item.type !== "tool_call" || item.detail.type !== "unknown") throw new Error("shape");
+    expect(item.callId).toBe(callId);
+    expect(item.detail.input).toEqual({ query: "useWorkspaceSomethingVeryDescriptive" });
+    const output = item.detail.output as string[];
+    expect(output.length).toBeLessThan(10_000);
+    expect(output.every((path) => path.length === 33)).toBe(true);
+    expect(serializedBytes(item)).toBeLessThanOrEqual(64 * 1024);
+    expect(limitAgentTimelineItemContent(item)).toBe(item);
+  });
+
+  test("keeps a long typed array valid against the wire schema", () => {
+    const item = limitAgentTimelineItemContent({
+      type: "todo",
+      items: Array.from({ length: 20_000 }, (_, index) => ({
+        text: `Task ${index}`,
+        completed: false,
+      })),
+    });
+    if (item.type !== "todo") throw new Error("shape");
+    expect(item.items.length).toBeLessThan(20_000);
+    expect(AgentTimelineItemPayloadSchema.safeParse(item).success).toBe(true);
+    expect(serializedBytes(item)).toBeLessThanOrEqual(256 * 1024);
+  });
+
+  test("is stable on an already-limited item", () => {
+    const item = limitAgentTimelineItemContent({
+      type: "reasoning",
+      text: "r".repeat(1024 * 1024),
+    });
+    expect(limitAgentTimelineItemContent(item)).toBe(item);
+  });
 });

packages/server/src/server/agent/agent-timeline-content.ts

@@ -1,9 +1,19 @@
 import type { AgentTimelineItem } from "./agent-sdk-types.js";
 import type { JsonValue } from "@getpaseo/protocol/agent-types";
 
-const TOOL_CALL_CONTENT_MAX_LENGTH = 64 * 1024;
 export const PLUGIN_TIMELINE_DATA_MAX_BYTES = 64 * 1024;
 
+// One timeline fetch sends its entries in one WebSocket message, so every item must stay small.
+// Budgets count UTF-16 units plus a fixed cost per node; neither is exact JSON bytes. They bound
+// long strings and long arrays, not wide objects (every entry is kept) or multi-byte text.
+const TOOL_CALL_BUDGET = 64 * 1024;
+const ITEM_BUDGET = 256 * 1024;
+const NODE_COST = 8;
+const MARKER_COST = 32;
+// Ids, names, paths and queries stay whole, so an item keeps its identity across passes.
+const SHORT_STRING = 1024;
+const MAX_DEPTH = 64;
+
 export function assertPluginTimelineDataSize(data: JsonValue): void {
   const serializedBytes = Buffer.byteLength(JSON.stringify(data), "utf8");
   if (serializedBytes > PLUGIN_TIMELINE_DATA_MAX_BYTES) {
@@ -17,66 +27,119 @@ function retainTextPrefix(text: string, length: number): string {
   return Buffer.from(text.slice(0, length), "utf16le").toString("utf16le");
 }
 
-function limitFailedShellError(item: AgentTimelineItem): AgentTimelineItem {
-  if (
-    item.type !== "tool_call" ||
-    item.detail.type !== "shell" ||
-    item.status !== "failed" ||
-    typeof item.error !== "object" ||
-    item.error === null ||
-    !("content" in item.error) ||
-    typeof item.error.content !== "string" ||
-    item.error.content.length <= TOOL_CALL_CONTENT_MAX_LENGTH
-  ) {
-    return item;
-  }
-  return {
-    ...item,
-    error: {
-      ...item.error,
-      content: retainTextPrefix(item.error.content, TOOL_CALL_CONTENT_MAX_LENGTH),
-    },
-  };
+function formatSize(units: number): string {
+  if (units < 1024) return `${units} B`;
+  if (units < 1024 * 1024) return `${(units / 1024).toFixed(1)} KB`;
+  return `${(units / (1024 * 1024)).toFixed(1)} MB`;
 }
 
-function limitPlainText(item: AgentTimelineItem): AgentTimelineItem {
-  if (
-    item.type !== "tool_call" ||
-    item.detail.type !== "plain_text" ||
-    typeof item.detail.text !== "string" ||
-    item.detail.text.length <= TOOL_CALL_CONTENT_MAX_LENGTH
-  ) {
-    return item;
-  }
-  const notice = "\n\n[Content truncated]";
-  return {
-    ...item,
-    detail: {
-      ...item.detail,
-      text:
-        retainTextPrefix(item.detail.text, TOOL_CALL_CONTENT_MAX_LENGTH - notice.length) + notice,
-    },
-  };
+function truncatedMarker(units: number): string {
+  return `…[truncated ${formatSize(units)}]`;
 }
 
+interface ItemSize {
+  nodeCost: number;
+  stringLengths: number[];
+  tooDeep: boolean;
+}
+
+function measure(value: unknown, depth: number, size: ItemSize): void {
+  size.nodeCost += NODE_COST;
+  if (depth > MAX_DEPTH) {
+    size.tooDeep = true;
+  } else if (typeof value === "string") {
+    size.stringLengths.push(value.length);
+  } else if (Array.isArray(value)) {
+    for (const element of value) measure(element, depth + 1, size);
+  } else if (typeof value === "object" && value !== null) {
+    for (const [key, child] of Object.entries(value)) {
+      size.nodeCost += key.length;
+      measure(child, depth + 1, size);
+    }
+  }
+}
+
+/** The largest per-string length that keeps all strings, once cut, within `available`. */
+function findStringCap(lengths: readonly number[], available: number): number {
+  let low = 0;
+  let high = 0;
+  for (const length of lengths) high = Math.max(high, length);
+  while (low < high) {
+    const cap = Math.ceil((low + high) / 2);
+    let total = 0;
+    for (const length of lengths) total += Math.min(length, cap);
+    if (total <= available) low = cap;
+    else high = cap - 1;
+  }
+  return low;
+}
+
+interface CutState {
+  stringCap: number;
+  remaining: number;
+}
+
+function cutString(text: string, cap: number): string {
+  if (text.length <= cap) return text;
+  // A partial data URL is useless to every reader, so drop it whole.
+  if (text.startsWith("data:")) return truncatedMarker(text.length);
+  return retainTextPrefix(text, cap) + truncatedMarker(text.length - cap);
+}
+
+function cut(value: unknown, depth: number, state: CutState): unknown {
+  state.remaining -= NODE_COST;
+  if (depth > MAX_DEPTH) return "…[truncated]";
+  if (typeof value === "string") {
+    const text = cutString(value, state.stringCap);
+    state.remaining -= text.length;
+    return text;
+  }
+  if (Array.isArray(value)) {
+    let changed = false;
+    const output: unknown[] = [];
+    for (const element of value) {
+      const remainingBefore = state.remaining;
+      const next = cut(element, depth + 1, state);
+      if (state.remaining < 0) {
+        // Drop this and later elements. A marker element would break typed arrays.
+        state.remaining = remainingBefore;
+        changed = true;
+        break;
+      }
+      changed ||= next !== element;
+      output.push(next);
+    }
+    return changed ? output : value;
+  }
+  if (typeof value === "object" && value !== null) {
+    let changed = false;
+    const output: Record<string, unknown> = {};
+    for (const [key, child] of Object.entries(value)) {
+      state.remaining -= key.length;
+      const next = cut(child, depth + 1, state);
+      changed ||= next !== child;
+      output[key] = next;
+    }
+    return changed ? output : value;
+  }
+  return value;
+}
+
+/** Returns the item itself when it fits its budget; otherwise a copy with its largest strings cut. */
 export function limitAgentTimelineItemContent(item: AgentTimelineItem): AgentTimelineItem {
-  item = limitFailedShellError(item);
-  item = limitPlainText(item);
-  if (
-    item.type !== "tool_call" ||
-    item.detail.type !== "shell" ||
-    typeof item.detail.output !== "string"
-  ) {
-    return item;
-  }
-  if (item.detail.output.length <= TOOL_CALL_CONTENT_MAX_LENGTH) {
-    return item;
-  }
-  return {
-    ...item,
-    detail: {
-      ...item.detail,
-      output: retainTextPrefix(item.detail.output, TOOL_CALL_CONTENT_MAX_LENGTH),
-    },
-  };
+  const budget = item.type === "tool_call" ? TOOL_CALL_BUDGET : ITEM_BUDGET;
+  const size: ItemSize = { nodeCost: 0, stringLengths: [], tooDeep: false };
+  measure(item, 0, size);
+  let stringTotal = 0;
+  for (const length of size.stringLengths) stringTotal += length;
+  if (!size.tooDeep && size.nodeCost + stringTotal <= budget) return item;
+
+  // Strings get what structure leaves, but at least half the budget, less a margin for JSON
+  // escaping. Arrays drop the elements that do not fit, which bounds items whose short strings
+  // or structure alone are too big.
+  const markerCost =
+    MARKER_COST * size.stringLengths.filter((length) => length > SHORT_STRING).length;
+  const available = (budget * 15) / 16 - Math.min(size.nodeCost, budget / 2) - markerCost;
+  const stringCap = Math.max(SHORT_STRING, findStringCap(size.stringLengths, available));
+  return cut(item, 0, { stringCap, remaining: budget }) as AgentTimelineItem;
 }

packages/server/src/server/agent/agent-timeline-store.test.ts

@@ -181,6 +181,20 @@ describe("projected timeline retention", () => {
       },
     ]);
   });
+
+  it("serves a merged assistant message within the item budget", () => {
+    const store = new InMemoryAgentTimelineStore();
+    store.initialize("agent", { epoch: "e" });
+    const chunk = "a".repeat(200 * 1024);
+    for (let index = 0; index < 10; index++) {
+      store.append("agent", { type: "assistant_message", messageId: "m", text: chunk });
+    }
+    const [row] = store.fetch("agent", { limit: 1 }).rows;
+    expect(row).toMatchObject({ seqStart: 1, seqEnd: 10 });
+    expect(row.item).toMatchObject({ type: "assistant_message", messageId: "m" });
+    expect(Buffer.byteLength(JSON.stringify(row.item))).toBeLessThanOrEqual(256 * 1024);
+    expect(store.getLastAssistantMessage("agent")).toHaveLength(10 * chunk.length);
+  });
 });
 
 describe("projected sequence ownership", () => {

packages/server/src/server/agent/agent-timeline-store.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { TimelineProjection, type ProjectedTimelineRow } from "./timeline-projection.js";
+import { limitAgentTimelineItemContent } from "./agent-timeline-content.js";
 import type { AgentTimelineItem } from "./agent-sdk-types.js";
 import type {
   AgentTimelineFetchOptions,
@@ -120,7 +121,12 @@ export class InMemoryAgentTimelineStore {
       hasNewer: page.hasNewer,
       startSeq: page.startSeq,
       endSeq: page.endSeq,
-      rows: page.entries.map((entry) => Object.assign({ seq: entry.seqEnd }, entry)),
+      // Stored rows are already within budget; this bounds assistant and reasoning merges.
+      rows: page.entries.map((entry) =>
+        Object.assign({ seq: entry.seqEnd }, entry, {
+          item: limitAgentTimelineItemContent(entry.item),
+        }),
+      ),
     };
   }
 

packages/server/src/server/agent/provider-subagents/store.test.ts

@@ -80,7 +80,7 @@ describe("ProviderSubagentStore", () => {
     const [row] = subagents.fetchTimeline("parent-a", "child-1").rows;
     expect(row?.item).toMatchObject({
       type: "tool_call",
-      detail: { type: "shell", output: "x".repeat(64 * 1024) },
+      detail: { type: "shell", output: expect.stringMatching(/^x+…\[truncated \d+\.\d KB\]$/) },
     });
   });
 

packages/server/src/server/agent/providers/claude/agent.background-subagent.test.ts

@@ -466,13 +466,13 @@ describe("background Claude subagents", () => {
         type: "sub_agent",
         subAgentType: "general-purpose",
         description: "Count files here",
-        log: "",
+        log: "[Bash] ls -1",
       },
     });
   });
 
   test.each(["before", "after"])(
-    "keeps one Task card when child tools start %s the parent finishes",
+    "keeps one logged Task card when child tools start %s the parent finishes",
     async (timing) => {
       // A child can stream across the main session's turn boundary. Claude opens the next
       // main-session turn with system/init; bare child frames do not open a turn.
@@ -605,7 +605,7 @@ describe("background Claude subagents", () => {
           type: "sub_agent",
           subAgentType: "general-purpose",
           description: "Count files here",
-          log: "",
+          log: "[Bash] ls -1",
         },
       });
     },

packages/server/src/server/agent/providers/claude/agent.sub-agent-replay.test.ts

@@ -737,7 +737,7 @@ describe("ClaudeAgentSession persisted subagent replay", () => {
     );
   }, 120_000);
 
-  test("limits retained child shell output to the timeline's existing content limit", async () => {
+  test("limits retained child shell output to the timeline item budget", async () => {
     const output = "x".repeat(128 * 1024);
     writeSession({
       parentLines: [taskToolUse(), taskToolResult()],
@@ -782,7 +782,10 @@ describe("ClaudeAgentSession persisted subagent replay", () => {
         type: "timeline",
         id: TOOL_USE_ID,
         item: expect.objectContaining({
-          detail: expect.objectContaining({ type: "shell", output: output.slice(0, 64 * 1024) }),
+          detail: expect.objectContaining({
+            type: "shell",
+            output: expect.stringMatching(/^x+…\[truncated \d+\.\d KB\]$/),
+          }),
         }),
       }),
     ]);

packages/server/src/server/agent/providers/claude/agent.sub-agent-sidechain.test.ts

@@ -273,7 +273,7 @@ describe("ClaudeAgentSession sub-agent sidechain updates", () => {
     queryFactory.mockReset();
   });
 
-  test("labels the Task card from its input and preserves callId lifecycle collapse", async () => {
+  test("accumulates lightweight sub_agent detail and preserves callId lifecycle collapse", async () => {
     const session = await new ClaudeAgentClient({
       logger,
       queryFactory,
@@ -307,7 +307,9 @@ describe("ClaudeAgentSession sub-agent sidechain updates", () => {
 
     expect(latest.detail.subAgentType).toBe("Explore");
     expect(latest.detail.description).toBe("Inspect repository structure");
-    expect(latest.detail.log).toBe("");
+    expect(latest.detail.log).toContain("[Read] README.md");
+    expect(latest.detail.log).toContain("[Edit] src/index.ts");
+    expect(latest.detail.log).not.toContain("VERY_LARGE_OLD_STRING");
 
     const rows: AgentTimelineRow[] = timelineToolCalls.map((item, index) => ({
       seq: index + 1,
@@ -394,7 +396,10 @@ describe("ClaudeAgentSession sub-agent sidechain updates", () => {
       .map((event) => event.item)
       .at(-1);
 
-    expect(latestSubAgentUpdate?.detail).toMatchObject({ type: "sub_agent", log: "" });
+    expect(latestSubAgentUpdate?.detail).toMatchObject({
+      type: "sub_agent",
+      log: expect.stringContaining("[Read] README.md"),
+    });
   });
 
   test("routes a resumed SendMessage sidechain to the original child without a second Task card", async () => {
@@ -548,7 +553,7 @@ describe("ClaudeAgentSession sub-agent sidechain updates", () => {
     ).toMatchObject({ type: "upsert", id: "task-tail-1", status: "failed" });
   });
 
-  test("keeps the Task card the same size while the child runs", async () => {
+  test("tails sub-agent actions instead of dropping latest entries at cap", async () => {
     queryFactory.mockImplementation(() => buildQueryMock(buildTailScenarioEvents(205)));
 
     const session = await new ClaudeAgentClient({
@@ -563,27 +568,24 @@ describe("ClaudeAgentSession sub-agent sidechain updates", () => {
     const events = await collectUntilTerminal(streamSession(session, "delegate work"));
     await session.close();
 
-    const runningCards = events
-      .flatMap((event) =>
-        event.type === "timeline" &&
-        event.item.type === "tool_call" &&
-        event.item.callId === "task-tail-1" &&
-        event.item.status === "running" &&
-        event.item.detail.type === "sub_agent"
-          ? [event.item]
-          : [],
+    const timelineToolCalls = events
+      .filter(
+        (event): event is Extract<AgentStreamEvent, { type: "timeline" }> =>
+          event.type === "timeline" && event.item.type === "tool_call",
       )
-      .map((item) => JSON.stringify(item));
-    expect(runningCards).toHaveLength(1);
+      .map((event) => event.item)
+      .filter((item) => item.callId === "task-tail-1");
+    const subAgentUpdates = timelineToolCalls.filter((item) => item.detail.type === "sub_agent");
+    const latest = subAgentUpdates[subAgentUpdates.length - 1];
+    expect(latest).toBeDefined();
+    if (!latest || latest.detail.type !== "sub_agent") {
+      throw new Error("expected sub_agent detail");
+    }
 
-    const childToolCalls = events.filter(
-      (event) =>
-        event.type === "provider_subagent" &&
-        event.event.type === "timeline" &&
-        event.event.id === "task-tail-1" &&
-        event.event.item.type === "tool_call",
-    );
-    expect(childToolCalls).toHaveLength(205);
+    expect(latest.detail.log).not.toContain("[Read] file-1.md");
+    expect(latest.detail.log).not.toContain("[Read] file-5.md");
+    expect(latest.detail.log).toContain("[Read] file-6.md");
+    expect(latest.detail.log).toContain("[Read] file-205.md");
   });
 
   test("keeps a long main-thread tool call out of the subagents track", async () => {

packages/server/src/server/agent/providers/claude/agent.ts

@@ -4667,7 +4667,7 @@ class ClaudeAgentSession implements AgentSession {
   /**
    * The Task card in the parent transcript, built from the declaration.
    *
-   * The sidechain tracker also emits this card when it first sees the child, and the two
+   * The sidechain tracker also emits this card, enriched with the child's action log, and the two
    * collapse on the shared tool-call id. Emitting it at declaration matters because a
    * backgrounded subagent produces no sidechain frames at all — verified on the wire — so the
    * tracker never runs for one and its card would otherwise stay an unlabeled "Task".
@@ -6276,7 +6276,6 @@ function buildClaudeSubagentCardDetail(
     type: "sub_agent",
     ...(facts.title ? { subAgentType: facts.title } : {}),
     ...(facts.description ? { description: facts.description } : {}),
-    // COMPAT(subagent-log): remove after 2027-04-30.
     log: "",
     actions: [],
   };

packages/server/src/server/agent/providers/claude/sidechain-tracker.test.ts

@@ -4,7 +4,7 @@ import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
 import { ClaudeSidechainTracker } from "./sidechain-tracker.js";
 
 describe("ClaudeSidechainTracker", () => {
-  it("keeps a background child's card across the parent finishing", () => {
+  it("retains a background child's actions across the parent finishing", () => {
     const tracker = new ClaudeSidechainTracker({
       getToolInput: () => ({ subagent_type: "general-purpose", description: "List files" }),
       isDescriptorOwnedElsewhere: () => true,
@@ -15,67 +15,27 @@ describe("ClaudeSidechainTracker", () => {
         parent_tool_use_id: "task-1",
         message: { content: [{ type: "tool_use", id, name: "Bash", input: { command } }] },
       }) as unknown as SDKMessage;
-    const parentCards = (events: ReturnType<typeof tracker.handleMessage>) =>
-      events.filter((event) => event.type === "timeline");
-    const childCallIds = (events: ReturnType<typeof tracker.handleMessage>) =>
-      events.flatMap((event) =>
-        event.type === "provider_subagent" &&
-        event.event.type === "timeline" &&
-        event.event.item.type === "tool_call"
-          ? [event.event.item.callId]
-          : [],
-      );
-
-    expect(parentCards(tracker.handleMessage(action("ls", "ls -1"), "task-1"))).toHaveLength(1);
+    tracker.handleMessage(action("ls", "ls -1"), "task-1");
     expect(tracker.finishAll("completed")).toEqual([]);
-    const afterFinish = tracker.handleMessage(action("pwd", "pwd"), "task-1");
-    expect(parentCards(afterFinish)).toEqual([]);
-    expect(childCallIds(afterFinish)).toEqual(["pwd"]);
-
+    const events = tracker.handleMessage(action("pwd", "pwd"), "task-1");
+    expect(events).toContainEqual(
+      expect.objectContaining({
+        type: "timeline",
+        item: expect.objectContaining({
+          detail: expect.objectContaining({ log: "[Bash] ls -1\n[Bash] pwd" }),
+        }),
+      }),
+    );
     tracker.delete("task-1");
     const next = tracker.handleMessage(action("next", "ls"), "task-1");
-    expect(parentCards(next)).toHaveLength(1);
-    expect(childCallIds(next)).toEqual(["next"]);
-  });
-
-  it("shows a streamed child tool call's input once the assistant message brings it", () => {
-    const tracker = new ClaudeSidechainTracker({ getToolInput: () => null });
-    const frames = [
-      {
-        type: "stream_event",
-        parent_tool_use_id: "task-1",
-        event: {
-          type: "content_block_start",
-          index: 0,
-          content_block: { type: "tool_use", id: "bash-1", name: "Bash", input: {} },
-        },
-      },
-      {
-        type: "assistant",
-        parent_tool_use_id: "task-1",
-        message: {
-          content: [
-            { type: "tool_use", id: "bash-1", name: "Bash", input: { command: "echo child" } },
-          ],
-        },
-      },
-    ] as unknown as SDKMessage[];
-
-    const childCards = frames
-      .flatMap((frame) => tracker.handleMessage(frame, "task-1"))
-      .flatMap((event) =>
-        event.type === "provider_subagent" &&
-        event.event.type === "timeline" &&
-        event.event.item.type === "tool_call"
-          ? [event.event.item]
-          : [],
-      );
-
-    expect(childCards.at(-1)).toMatchObject({
-      callId: "bash-1",
-      status: "running",
-      detail: { type: "shell", command: "echo child" },
-    });
+    expect(next).toContainEqual(
+      expect.objectContaining({
+        type: "timeline",
+        item: expect.objectContaining({
+          detail: expect.objectContaining({ log: "[Bash] ls" }),
+        }),
+      }),
+    );
   });
 
   it("uses Claude's native agent name for the provider subagent title", () => {

packages/server/src/server/agent/providers/claude/sidechain-tracker.ts

@@ -5,6 +5,7 @@ import {
   mapClaudeFailedToolCall,
   mapClaudeRunningToolCall,
 } from "./tool-call-mapper.js";
+import { buildToolCallDisplayModel } from "@getpaseo/protocol/tool-call-display";
 import {
   isClaudeSubagentHandbackToolName,
   readClaudeSubagentHandback,
@@ -19,17 +20,21 @@ interface ClaudeContentChunk {
 
 type ClaudeToolCallItem = Extract<AgentTimelineItem, { type: "tool_call" }>;
 
-interface SubAgentChildCall {
+interface SubAgentActionEntry {
+  index: number;
   toolName: string;
   input: unknown;
+  summary?: string;
 }
 
 interface SubAgentActivityState {
   name?: string;
   subAgentType?: string;
   description?: string;
-  /** The child's tool calls awaiting results, which carry no input of their own. */
-  runningCalls: Map<string, SubAgentChildCall>;
+  actions: SubAgentActionEntry[];
+  actionKeys: string[];
+  nextActionIndex: number;
+  actionIndexByKey: Map<string, number>;
   completedActionKeys: Set<string>;
 }
 
@@ -39,6 +44,7 @@ interface SubAgentActionCandidate {
   input: unknown;
 }
 
+const MAX_SUB_AGENT_LOG_ENTRIES = 200;
 const MAX_SUB_AGENT_SUMMARY_CHARS = 160;
 
 function readTrimmedString(value: unknown): string | undefined {
@@ -73,7 +79,8 @@ export class ClaudeSidechainTracker {
     needsSyntheticParentToolCard?: (toolUseId: string) => boolean;
     /**
      * The parent's tool call once Claude has answered it. A background child streams its frames
-     * after that answer, so its card keeps the settled status and output.
+     * after that answer, so its card keeps the settled status and output and gains the child's
+     * action log.
      */
     getSettledParentToolCall?: (toolUseId: string) => ClaudeToolCallItem | undefined;
   }) {
@@ -84,27 +91,28 @@ export class ClaudeSidechainTracker {
   }
 
   handleMessage(message: SDKMessage, parentToolUseId: string): AgentStreamEvent[] {
-    const existingState = this.activeSidechains.get(parentToolUseId);
     const state =
-      existingState ??
+      this.activeSidechains.get(parentToolUseId) ??
       ({
-        runningCalls: new Map<string, SubAgentChildCall>(),
+        actions: [],
+        actionKeys: [],
+        nextActionIndex: 1,
+        actionIndexByKey: new Map<string, number>(),
         completedActionKeys: new Set<string>(),
       } satisfies SubAgentActivityState);
     this.activeSidechains.set(parentToolUseId, state);
 
-    // The parent card is a launch marker: it changes only when the child is first seen or the
-    // task input names it differently, never with the child's activity.
-    const cardUpdated =
-      this.updateSubAgentContextFromTaskInput(state, parentToolUseId) || !existingState;
+    const contextUpdated = this.updateSubAgentContextFromTaskInput(state, parentToolUseId);
     const actionCandidates = this.extractSubAgentActionCandidates(message);
     const childTimelineItems = [
       ...this.extractSubAgentTimelineItems(message, state),
       ...this.extractSubAgentToolResults(message, state),
     ];
+    let actionUpdated = false;
     for (const action of actionCandidates) {
       if (state.completedActionKeys.has(action.key)) continue;
-      if (this.trackChildCall(state, action)) {
+      if (this.appendSubAgentAction(state, action)) {
+        actionUpdated = true;
         const toolCall = mapClaudeRunningToolCall({
           name: action.toolName,
           callId: action.key,
@@ -117,7 +125,7 @@ export class ClaudeSidechainTracker {
       }
     }
 
-    if (!cardUpdated && childTimelineItems.length === 0) {
+    if (!contextUpdated && !actionUpdated && childTimelineItems.length === 0) {
       return [];
     }
 
@@ -137,8 +145,11 @@ export class ClaudeSidechainTracker {
       type: "sub_agent",
       ...(state.subAgentType ? { subAgentType: state.subAgentType } : {}),
       ...(state.description ? { description: state.description } : {}),
-      // COMPAT(subagent-log): remove after 2027-04-30.
-      log: "",
+      log: state.actions
+        .map((action) =>
+          action.summary ? `[${action.toolName}] ${action.summary}` : `[${action.toolName}]`,
+        )
+        .join("\n"),
       actions: [],
     };
 
@@ -159,19 +170,18 @@ export class ClaudeSidechainTracker {
           },
         ];
 
-    const parentCard: AgentStreamEvent[] =
-      cardUpdated && this.needsSyntheticParentToolCard(parentToolUseId)
-        ? [
-            {
-              type: "timeline",
-              item: {
-                ...toolCall,
-                detail,
-              },
-              provider: "claude",
+    const parentCard: AgentStreamEvent[] = this.needsSyntheticParentToolCard(parentToolUseId)
+      ? [
+          {
+            type: "timeline",
+            item: {
+              ...toolCall,
+              detail,
             },
-          ]
-        : [];
+            provider: "claude",
+          },
+        ]
+      : [];
 
     return [
       ...descriptorEvents,
@@ -293,7 +303,8 @@ export class ClaudeSidechainTracker {
       if (!isClaudeContentChunk(block) || !block.type.endsWith("tool_result")) continue;
       const callId = readTrimmedString(block.tool_use_id);
       if (!callId || state.completedActionKeys.has(callId)) continue;
-      const action = state.runningCalls.get(callId);
+      const actionIndex = state.actionIndexByKey.get(callId);
+      const action = actionIndex === undefined ? undefined : state.actions[actionIndex];
       const toolName = action?.toolName ?? readTrimmedString(block.tool_name);
       if (!toolName) continue;
       const params = {
@@ -306,7 +317,6 @@ export class ClaudeSidechainTracker {
         ? mapClaudeFailedToolCall({ ...params, error: block })
         : mapClaudeCompletedToolCall(params);
       if (toolCall) {
-        state.runningCalls.delete(callId);
         state.completedActionKeys.add(callId);
         items.push(toolCall);
       }
@@ -402,12 +412,13 @@ export class ClaudeSidechainTracker {
     const key =
       readTrimmedString(block.id) ??
       `stream:${block.name}:${typeof event.index === "number" ? event.index : 0}`;
-    // A streamed call starts with `{}` until its input arrives, so an empty input is not final.
-    const input =
-      block.input && typeof block.input === "object" && Object.keys(block.input).length > 0
-        ? block.input
-        : null;
-    return [{ key, toolName: block.name, input }];
+    return [
+      {
+        key,
+        toolName: block.name,
+        input: block.input ?? null,
+      },
+    ];
   }
 
   private extractSubAgentActionCandidates(message: SDKMessage): SubAgentActionCandidate[] {
@@ -437,20 +448,84 @@ export class ClaudeSidechainTracker {
     return [];
   }
 
-  /** Returns whether the call is new or has gained its input, so its running card changes. */
-  private trackChildCall(
+  private appendSubAgentAction(
     state: SubAgentActivityState,
     candidate: SubAgentActionCandidate,
   ): boolean {
-    const toolName = readTrimmedString(candidate.toolName);
-    if (!toolName) {
+    const normalizedToolName = readTrimmedString(candidate.toolName);
+    if (!normalizedToolName) {
       return false;
     }
-    const existing = state.runningCalls.get(candidate.key);
-    if (existing && (existing.input !== null || candidate.input === null)) {
-      return false;
+
+    const summary = this.deriveSubAgentActionSummary(normalizedToolName, candidate.input);
+    const existingIndex = state.actionIndexByKey.get(candidate.key);
+
+    if (existingIndex !== undefined) {
+      const existing = state.actions[existingIndex];
+      if (!existing) {
+        return false;
+      }
+      const nextSummary = existing.summary ?? summary;
+      if (existing.toolName === normalizedToolName && existing.summary === nextSummary) {
+        return false;
+      }
+      state.actions[existingIndex] = {
+        ...existing,
+        toolName: normalizedToolName,
+        input: existing.input ?? candidate.input,
+        ...(nextSummary ? { summary: nextSummary } : {}),
+      };
+      return true;
     }
-    state.runningCalls.set(candidate.key, { toolName, input: candidate.input });
+
+    state.actions.push({
+      index: state.nextActionIndex,
+      toolName: normalizedToolName,
+      input: candidate.input,
+      ...(summary ? { summary } : {}),
+    });
+    state.nextActionIndex += 1;
+    state.actionKeys.push(candidate.key);
+    this.trimSubAgentTail(state);
+    this.rebuildSubAgentActionIndex(state);
     return true;
   }
+
+  private trimSubAgentTail(state: SubAgentActivityState): void {
+    while (state.actions.length > MAX_SUB_AGENT_LOG_ENTRIES) {
+      state.actions.shift();
+      const removedKey = state.actionKeys.shift();
+      if (removedKey) state.completedActionKeys.delete(removedKey);
+    }
+  }
+
+  private rebuildSubAgentActionIndex(state: SubAgentActivityState): void {
+    state.actionIndexByKey.clear();
+    for (let index = 0; index < state.actionKeys.length; index += 1) {
+      const key = state.actionKeys[index];
+      if (key) {
+        state.actionIndexByKey.set(key, index);
+      }
+    }
+  }
+
+  private deriveSubAgentActionSummary(toolName: string, input: unknown): string | undefined {
+    const runningToolCall = mapClaudeRunningToolCall({
+      name: toolName,
+      callId: `sub-agent-summary-${toolName}`,
+      input,
+      output: null,
+    });
+    if (!runningToolCall) {
+      return undefined;
+    }
+    const display = buildToolCallDisplayModel({
+      name: runningToolCall.name,
+      status: runningToolCall.status,
+      error: runningToolCall.error,
+      detail: runningToolCall.detail,
+      metadata: runningToolCall.metadata,
+    });
+    return this.normalizeSubAgentText(display.summary);
+  }
 }

packages/server/src/server/agent/providers/codex-app-server-agent.real.e2e.test.ts

@@ -77,19 +77,12 @@ CHILD_SENTINEL in your own response.
 
         const completedChildIndex = events.findIndex(
           (event) =>
-            event.type === "provider_subagent" &&
-            event.event.type === "upsert" &&
-            event.event.status === "completed",
+            event.type === "timeline" &&
+            event.item.type === "tool_call" &&
+            event.item.status === "completed" &&
+            event.item.detail.type === "sub_agent" &&
+            event.item.detail.log.includes("CHILD_SENTINEL"),
         );
-        const childAssistantText = events
-          .flatMap((event) =>
-            event.type === "provider_subagent" &&
-            event.event.type === "timeline" &&
-            event.event.item.type === "assistant_message"
-              ? [event.event.item.text]
-              : [],
-          )
-          .join("");
         const rootMessageIndexes = events.flatMap((event, index) =>
           event.type === "timeline" && event.item.type === "assistant_message" ? [index] : [],
         );
@@ -112,7 +105,6 @@ CHILD_SENTINEL in your own response.
           .map((item) => item.text)
           .join("");
         expect(topLevelAssistantText).not.toContain("CHILD_SENTINEL");
-        expect(childAssistantText).toContain("CHILD_SENTINEL");
         expect(completedChildIndex).toBeGreaterThanOrEqual(0);
         expect(rootMessageIndexes[0]).toBeGreaterThan(completedChildIndex);
         expect(terminalIndexes).toHaveLength(1);

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

@@ -3524,7 +3524,7 @@ describe("Codex app-server provider", () => {
     ]);
   });
 
-  test("keeps child-thread Codex activity out of the parent sub-agent card", async () => {
+  test("folds child-thread Codex activity into the parent sub-agent tool call", async () => {
     const session = createSession();
     const events: AgentStreamEvent[] = [];
     session.subscribe((event) => events.push(event));
@@ -3562,6 +3562,7 @@ describe("Codex app-server provider", () => {
     });
 
     const timelineEvents = events.filter((event) => event.type === "timeline");
+    expect(timelineEvents).toHaveLength(4);
     expect(timelineEvents.every((event) => event.item.type === "tool_call")).toBe(true);
     const finalItem = timelineEvents.at(-1)?.item;
     expect(finalItem).toMatchObject({
@@ -3573,7 +3574,7 @@ describe("Codex app-server provider", () => {
         type: "sub_agent",
         subAgentType: "Sub-agent",
         description: "Report findings.",
-        log: "",
+        log: "[Assistant] Found the path.",
         actions: [],
       },
     });
@@ -3650,9 +3651,13 @@ describe("Codex app-server provider", () => {
         id: "settled-child-thread",
         status: "completed",
       });
-      expect(events.findLast((event) => event.type === "timeline")).toMatchObject({
+      expect(events.at(-1)).toMatchObject({
         type: "timeline",
-        item: { callId: "call-settled-child", status: "completed" },
+        item: {
+          callId: "call-settled-child",
+          status: "completed",
+          detail: { type: "sub_agent", log: "[Assistant] Late trailing output." },
+        },
       });
 
       appServer.completesSubAgentActivity({
@@ -3957,8 +3962,6 @@ describe("Codex app-server provider", () => {
       createTestLogger(),
       async () => appServer.child,
     );
-    const events: AgentStreamEvent[] = [];
-    session.subscribe((event) => events.push(event));
 
     try {
       const resultPromise = session.run("Delegate the investigation, then report the result.");
@@ -4002,18 +4005,11 @@ describe("Codex app-server provider", () => {
         type: "tool_call",
         callId: "spawn-child-early",
         status: "completed",
-        detail: { type: "sub_agent", log: "" },
+        detail: {
+          type: "sub_agent",
+          log: "[Assistant] Early child findings.",
+        },
       });
-      expect(events).toContainEqual(
-        expect.objectContaining({
-          type: "provider_subagent",
-          event: expect.objectContaining({
-            type: "timeline",
-            id: "child-thread-early",
-            item: expect.objectContaining({ type: "assistant_message" }),
-          }),
-        }),
-      );
       appServer.assertNoErrors();
     } finally {
       await session.close();
@@ -4084,7 +4080,10 @@ describe("Codex app-server provider", () => {
       expect(toolCalls.at(-1)).toMatchObject({
         callId: "spawn-child-stable",
         status: "canceled",
-        detail: { type: "sub_agent", log: "" },
+        detail: {
+          type: "sub_agent",
+          log: "[Assistant] Still on the same card.",
+        },
       });
       appServer.assertNoErrors();
     } finally {
@@ -4164,10 +4163,11 @@ describe("Codex app-server provider", () => {
 
       const result = await resultPromise;
       const toolCalls = result.timeline.filter((item) => item.type === "tool_call");
-      expect(toolCalls.map((item) => item.status)).toEqual(["running", "completed"]);
+      expect(toolCalls.map((item) => item.status)).toEqual(["running", "completed", "completed"]);
       expect(toolCalls.at(-1)).toMatchObject({
         callId: "spawn-child-late-compaction",
         status: "completed",
+        detail: { type: "sub_agent", log: "[Compacted]" },
       });
       appServer.assertNoErrors();
     } finally {
@@ -4175,7 +4175,7 @@ describe("Codex app-server provider", () => {
     }
   });
 
-  test("routes legacy child tools to the child timeline", async () => {
+  test("projects legacy child tools into one stable sub-agent log", async () => {
     const appServer = createFakeCodexAppServer();
     const session = new CodexAppServerAgentSession(
       createConfig({ cwd: "/workspace/project" }),
@@ -4183,8 +4183,6 @@ describe("Codex app-server provider", () => {
       createTestLogger(),
       async () => appServer.child,
     );
-    const events: AgentStreamEvent[] = [];
-    session.subscribe((event) => events.push(event));
 
     try {
       const resultPromise = session.run("Delegate the implementation.");
@@ -4227,26 +4225,19 @@ describe("Codex app-server provider", () => {
       expect(finalToolCall).toMatchObject({
         callId: "spawn-legacy-tool-child",
         status: "completed",
-        detail: { type: "sub_agent", log: "" },
+        detail: { type: "sub_agent" },
       });
-      const childToolCalls = events.flatMap((event) =>
-        event.type === "provider_subagent" &&
-        event.event.type === "timeline" &&
-        event.event.id === "legacy-tool-child" &&
-        event.event.item.type === "tool_call"
-          ? [event.event.item]
-          : [],
-      );
-      expect(new Set(childToolCalls.map((item) => item.detail.type))).toEqual(
-        new Set(["shell", "edit"]),
-      );
+      if (finalToolCall?.detail.type === "sub_agent") {
+        expect(finalToolCall.detail.log.match(/\[Shell\]/g)).toHaveLength(1);
+        expect(finalToolCall.detail.log).toContain("[Edit]");
+      }
       appServer.assertNoErrors();
     } finally {
       await session.close();
     }
   });
 
-  test("keeps nested MultiAgentV2 output out of the root sub-agent card", async () => {
+  test("keeps nested MultiAgentV2 output inside the root sub-agent card", async () => {
     const session = createSession();
     const events: AgentStreamEvent[] = [];
     session.subscribe((event) => events.push(event));
@@ -4306,22 +4297,8 @@ describe("Codex app-server provider", () => {
     expect(beforeParentCompletes.at(-1)).toMatchObject({
       callId: "spawn-child-root",
       status: "running",
-      detail: { type: "sub_agent", log: "" },
+      detail: { type: "sub_agent", log: expect.stringContaining("Grandchild findings.") },
     });
-    expect(events).toContainEqual(
-      expect.objectContaining({
-        type: "provider_subagent",
-        event: {
-          type: "timeline",
-          id: "grandchild-thread",
-          item: {
-            type: "assistant_message",
-            messageId: "grandchild-message",
-            text: "Grandchild findings.",
-          },
-        },
-      }),
-    );
 
     await asInternals(session).handleNotification("turn/completed", {
       threadId: "child-thread-root",
@@ -4388,20 +4365,13 @@ describe("Codex app-server provider", () => {
       "child-thread-root",
       "child-thread-root",
     ]);
-    expect(events).toContainEqual(
-      expect.objectContaining({
-        type: "provider_subagent",
-        event: {
-          type: "timeline",
-          id: "grandchild-thread",
-          item: {
-            type: "assistant_message",
-            messageId: "grandchild-after-wait",
-            text: "Still nested.",
-          },
-        },
-      }),
-    );
+    expect(events.at(-1)).toMatchObject({
+      type: "timeline",
+      item: {
+        callId: "spawn-child-root",
+        detail: { type: "sub_agent", log: expect.stringContaining("Still nested.") },
+      },
+    });
   });
 
   test("never treats an unmapped foreign terminal as the root terminal", async () => {
@@ -4821,7 +4791,7 @@ describe("Codex app-server provider", () => {
     expect(events).toHaveLength(eventCountAfterSpawn);
   });
 
-  test("keeps child context compaction on the child timeline", async () => {
+  test("keeps child context compaction inside the child card", async () => {
     const session = createSession();
     const events: AgentStreamEvent[] = [];
     session.subscribe((event) => events.push(event));
@@ -4854,70 +4824,10 @@ describe("Codex app-server provider", () => {
         (item) => item.type === "tool_call" && item.callId === "spawn-child-compaction",
       ),
     ).toBe(true);
-    expect(
-      events.flatMap((event) =>
-        event.type === "provider_subagent" && event.event.type === "timeline" ? [event.event] : [],
-      ),
-    ).toEqual([
-      {
-        type: "timeline",
-        id: "child-thread-compaction",
-        item: { type: "compaction", status: "loading" },
-      },
-      {
-        type: "timeline",
-        id: "child-thread-compaction",
-        item: { type: "compaction", status: "completed" },
-      },
-    ]);
-  });
-
-  test("settles a child compaction once when the item completion is missing or duplicated", async () => {
-    const session = createSession();
-    const events: AgentStreamEvent[] = [];
-    session.subscribe((event) => events.push(event));
-
-    for (const child of ["compacted-child", "turn-ended-child"]) {
-      await asInternals(session).handleNotification("item/completed", {
-        threadId: "test-thread",
-        item: {
-          type: "subAgentActivity",
-          id: `spawn-${child}`,
-          kind: "started",
-          agentThreadId: child,
-          agentPath: `/root/${child}`,
-        },
-      });
-      await asInternals(session).handleNotification("item/started", {
-        threadId: child,
-        item: { type: "contextCompaction", id: `${child}-compaction` },
-      });
-    }
-    await asInternals(session).handleNotification("thread/compacted", {
-      threadId: "compacted-child",
+    expect(timelineItems.at(-1)).toMatchObject({
+      type: "tool_call",
+      detail: { type: "sub_agent", log: "[Compacted]" },
     });
-    await asInternals(session).handleNotification("item/completed", {
-      threadId: "compacted-child",
-      item: { type: "contextCompaction", id: "compacted-child-compaction" },
-    });
-    await asInternals(session).handleNotification("turn/completed", {
-      threadId: "turn-ended-child",
-      turn: { status: "completed" },
-    });
-
-    const compactions = events.flatMap((event) =>
-      event.type === "provider_subagent" && event.event.type === "timeline"
-        ? [
-            `${event.event.id} ${event.event.item.type === "compaction" ? event.event.item.status : ""}`,
-          ]
-        : [],
-    );
-    expect(compactions).toEqual([
-      "compacted-child loading",
-      "turn-ended-child loading",
-      "compacted-child completed",
-      "turn-ended-child completed",
-    ]);
   });
 
   test("keeps the parent sub-agent running when a child command fails during the child turn", async () => {
@@ -4952,7 +4862,7 @@ describe("Codex app-server provider", () => {
       },
     });
 
-    expect(events.findLast((event) => event.type === "timeline")?.item).toMatchObject({
+    expect(events.at(-1)?.item).toMatchObject({
       type: "tool_call",
       callId: "call-sub-agent-child-command-failure",
       name: "Sub-agent",
@@ -5247,7 +5157,7 @@ describe("Codex app-server provider", () => {
     );
     expect(liveToolCalls.at(-1)).toMatchObject({
       status: "running",
-      detail: { type: "sub_agent", log: "" },
+      detail: { type: "sub_agent", log: "[Assistant] More findings after resume." },
     });
 
     liveEvents.length = 0;
@@ -5260,12 +5170,12 @@ describe("Codex app-server provider", () => {
       itemId: "legacy-child-message-after-resume",
       delta: "Legacy findings after resume.",
     });
-    expect(liveEvents.findLast((event) => event.type === "timeline")).toMatchObject({
+    expect(liveEvents.at(-1)).toMatchObject({
       type: "timeline",
       item: {
         callId: "legacy-spawn-history",
         status: "running",
-        detail: { type: "sub_agent", log: "" },
+        detail: { type: "sub_agent", log: "[Assistant] Legacy findings after resume." },
       },
     });
   });

packages/server/src/server/agent/providers/codex-app-server-agent.ts

@@ -49,10 +49,10 @@ import { Dirent } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { isDeepStrictEqual } from "node:util";
 import { z } from "zod";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 import { composeSystemPromptParts } from "../system-prompt.js";
+import { curateAgentActivity } from "../activity-curator.js";
 import { CodexAsyncQuestions, codexAsyncQuestionToTimeline } from "./codex/async-questions.js";
 import {
   mapCodexToolCallEnvelope,
@@ -3384,6 +3384,8 @@ interface CodexSubAgentCallState {
   activityItemIds: Set<string>;
   pendingCommandOutputDeltas: Map<string, string[]>;
   pendingFileChangeOutputDeltas: Map<string, string[]>;
+  childItemOrder: string[];
+  childItems: Map<string, AgentTimelineItem>;
   childThreadIds: Set<string>;
 }
 
@@ -3485,9 +3487,6 @@ export class CodexAppServerAgentSession implements AgentSession {
   private compactionTriggerByItemId = new Map<string, "auto" | "manual">();
   private pendingRootCompactionItemIds = new Set<string>();
   private pendingAnonymousRootCompactions = 0;
-  // Child threads with a compaction shown as loading. Some Codex builds settle it only through
-  // `thread/compacted` or the end of the child's turn.
-  private pendingChildCompactionThreadIds = new Set<string>();
   // Codex can report one completed compaction through both channels:
   // `thread/compacted` and a completed `contextCompaction` item.
   private unpairedCompactionNotificationCompletions = 0;
@@ -5517,9 +5516,6 @@ export class CodexAppServerAgentSession implements AgentSession {
       case "patch_apply_completed":
         this.handlePatchApplyCompletedNotification(parsed, callId);
         return;
-      case "context_compacted":
-        this.settleChildCompaction(parsed.threadId);
-        return;
       default:
         // Aggregate child telemetry is redundant and must not leak into the
         // root timeline. Concrete legacy tools are projected above for Codex
@@ -5696,10 +5692,20 @@ export class CodexAppServerAgentSession implements AgentSession {
         activityItemIds: new Set<string>(),
         pendingCommandOutputDeltas: new Map<string, string[]>(),
         pendingFileChangeOutputDeltas: new Map<string, string[]>(),
+        childItemOrder: [],
+        childItems: new Map<string, AgentTimelineItem>(),
         childThreadIds: new Set<string>(),
       } satisfies CodexSubAgentCallState);
 
-    state.toolCall = timelineItem;
+    state.toolCall = {
+      ...timelineItem,
+      detail: {
+        ...timelineItem.detail,
+        log:
+          timelineItem.detail.log ||
+          (state.toolCall.detail.type === "sub_agent" ? state.toolCall.detail.log : ""),
+      },
+    };
     state.parentCallId ??= parentCallId;
     state.parentSubagentId ??= parentSubagentId;
     const activity = readCodexSubAgentActivity(rawItem);
@@ -5752,17 +5758,25 @@ export class CodexAppServerAgentSession implements AgentSession {
     const activityToolCall = mapCodexToolCallFromThreadItem(rawItem, {
       cwd: this.config.cwd ?? null,
     });
-    const subAgentType =
-      activityToolCall?.detail.type === "sub_agent"
-        ? activityToolCall.detail.subAgentType
-        : undefined;
+    if (
+      activityToolCall?.detail.type === "sub_agent" &&
+      state.toolCall.detail.type === "sub_agent"
+    ) {
+      state.toolCall = {
+        ...state.toolCall,
+        detail: {
+          ...state.toolCall.detail,
+          subAgentType: activityToolCall.detail.subAgentType,
+        },
+      };
+    }
     let nextStatus: ToolCallTimelineItem["status"] | undefined = "running";
     if (activity.kind === "interrupted") {
       nextStatus = "canceled";
     } else if (isTerminalSubAgentStatus(state.toolCall.status)) {
       nextStatus = undefined;
     }
-    this.emitSubAgentActivityUpdate(callId, nextStatus, { subAgentType });
+    this.emitSubAgentActivityUpdate(callId, nextStatus);
     return true;
   }
 
@@ -5803,13 +5817,7 @@ export class CodexAppServerAgentSession implements AgentSession {
   ): boolean {
     if (
       childSubAgentCallId &&
-      parsed.threadId &&
-      this.handleSubAgentContextCompactionItem(
-        childSubAgentCallId,
-        parsed.threadId,
-        parsed.item,
-        "completed",
-      )
+      this.handleSubAgentContextCompactionItem(childSubAgentCallId, parsed.item, "completed")
     ) {
       return true;
     }
@@ -5819,6 +5827,17 @@ export class CodexAppServerAgentSession implements AgentSession {
     );
   }
 
+  private upsertSubAgentChildItem(callId: string, itemId: string, item: AgentTimelineItem): void {
+    const state = this.subAgentCallsByCallId.get(callId);
+    if (!state) {
+      return;
+    }
+    if (!state.childItems.has(itemId)) {
+      state.childItemOrder.push(itemId);
+    }
+    state.childItems.set(itemId, item);
+  }
+
   private emitCodexToolTimelineItem(
     timelineItem: ToolCallTimelineItem,
     subAgentCallId: string | null,
@@ -5828,6 +5847,7 @@ export class CodexAppServerAgentSession implements AgentSession {
       this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: timelineItem });
       return;
     }
+    this.upsertSubAgentChildItem(subAgentCallId, timelineItem.callId, timelineItem);
     const state = this.subAgentCallsByCallId.get(subAgentCallId);
     if (state) {
       const targetThreadIds = childThreadId ? [childThreadId] : state.childThreadIds;
@@ -5841,15 +5861,26 @@ export class CodexAppServerAgentSession implements AgentSession {
     );
   }
 
+  private getSubAgentChildTimeline(state: CodexSubAgentCallState): AgentTimelineItem[] {
+    return state.childItemOrder
+      .map((itemId) => state.childItems.get(itemId))
+      .filter((item): item is AgentTimelineItem => Boolean(item));
+  }
+
   private emitSubAgentActivityUpdate(
     callId: string,
     status?: ToolCallTimelineItem["status"],
-    options?: { reopen?: boolean; subAgentType?: string },
+    options?: { reopen?: boolean },
   ): void {
     const state = this.subAgentCallsByCallId.get(callId);
     if (!state || state.toolCall.detail.type !== "sub_agent") {
       return;
     }
+    const childTimeline = this.getSubAgentChildTimeline(state);
+    const log =
+      childTimeline.length > 0
+        ? curateAgentActivity(childTimeline, { labelAssistantMessages: true })
+        : "";
     let resolvedStatus = status ?? state.toolCall.status;
     if (
       status === "running" &&
@@ -5858,12 +5889,16 @@ export class CodexAppServerAgentSession implements AgentSession {
     ) {
       resolvedStatus = state.toolCall.status;
     }
-    const baseToolCall = options?.subAgentType
-      ? {
-          ...state.toolCall,
-          detail: { ...state.toolCall.detail, subAgentType: options.subAgentType },
-        }
-      : state.toolCall;
+    for (const childThreadId of state.childThreadIds) {
+      this.emitProviderSubagentUpsert(childThreadId, state, resolvedStatus);
+    }
+    const baseToolCall = {
+      ...state.toolCall,
+      detail: {
+        ...state.toolCall.detail,
+        log,
+      },
+    };
     const nextToolCall: ToolCallTimelineItem =
       resolvedStatus === "failed"
         ? {
@@ -5876,14 +5911,10 @@ export class CodexAppServerAgentSession implements AgentSession {
             status: resolvedStatus,
             error: null,
           };
-    // The card is a launch marker: the child's activity streams to its own timeline, so the card
-    // is re-sent only when its status or label changes.
-    const cardChanged = !isDeepStrictEqual(nextToolCall, state.toolCall);
     state.toolCall = nextToolCall;
-    for (const childThreadId of state.childThreadIds) {
-      this.emitProviderSubagentUpsert(childThreadId, state, resolvedStatus);
-    }
-    if (!cardChanged || (state.parentCallId && state.parentCallId !== callId)) {
+    if (state.parentCallId && state.parentCallId !== callId) {
+      this.upsertSubAgentChildItem(state.parentCallId, state.callId, nextToolCall);
+      this.emitSubAgentActivityUpdate(state.parentCallId);
       return;
     }
     this.emitEvent({ type: "timeline", provider: CODEX_PROVIDER, item: nextToolCall });
@@ -5991,6 +6022,7 @@ export class CodexAppServerAgentSession implements AgentSession {
   ): void {
     this.applyBufferedDeltaTextToTimelineItem(timelineItem, itemId);
     if (itemId) {
+      this.upsertSubAgentChildItem(callId, itemId, timelineItem);
       this.pendingAgentMessages.delete(itemId);
       this.pendingReasoning.delete(itemId);
       this.pendingCommandOutputDeltas.delete(itemId);
@@ -6001,29 +6033,19 @@ export class CodexAppServerAgentSession implements AgentSession {
 
   private handleSubAgentContextCompactionItem(
     callId: string,
-    childThreadId: string,
     item: { id?: string; type?: string; [key: string]: unknown },
     status: "loading" | "completed",
   ): boolean {
     if (!this.isContextCompactionItem(item)) {
       return false;
     }
-    if (status === "loading") {
-      this.pendingChildCompactionThreadIds.add(childThreadId);
-      this.emitProviderSubagentTimeline(childThreadId, { type: "compaction", status });
-    } else {
-      this.settleChildCompaction(childThreadId);
+    if (item.id) {
+      this.upsertSubAgentChildItem(callId, item.id, { type: "compaction", status });
     }
     this.emitSubAgentActivityUpdate(callId);
     return true;
   }
 
-  private settleChildCompaction(childThreadId: string): void {
-    if (this.pendingChildCompactionThreadIds.delete(childThreadId)) {
-      this.emitProviderSubagentTimeline(childThreadId, { type: "compaction", status: "completed" });
-    }
-  }
-
   private shouldSkipCompletedThreadItem(
     timelineItem: AgentTimelineItem,
     normalizedItemType: string | undefined,
@@ -6054,6 +6076,11 @@ export class CodexAppServerAgentSession implements AgentSession {
             text: parsed.delta,
           });
         }
+        this.upsertSubAgentChildItem(subAgentCallId, parsed.itemId, {
+          type: "assistant_message",
+          messageId: parsed.itemId,
+          text,
+        });
         this.emitSubAgentActivityUpdate(subAgentCallId, "running");
         return;
       }
@@ -6087,6 +6114,10 @@ export class CodexAppServerAgentSession implements AgentSession {
             text: parsed.delta,
           });
         }
+        this.upsertSubAgentChildItem(subAgentCallId, parsed.itemId, {
+          type: "reasoning",
+          text: prev.join(""),
+        });
         this.emitSubAgentActivityUpdate(subAgentCallId, "running");
         return;
       }
@@ -6154,7 +6185,6 @@ export class CodexAppServerAgentSession implements AgentSession {
   ): void {
     const subAgentCallId = this.getSubAgentCallIdForThread(parsed.threadId);
     if (subAgentCallId) {
-      if (parsed.threadId) this.settleChildCompaction(parsed.threadId);
       let status: ToolCallTimelineItem["status"] = "completed";
       if (parsed.status === "failed") {
         status = "failed";
@@ -6741,13 +6771,7 @@ export class CodexAppServerAgentSession implements AgentSession {
     const childSubAgentCallId = this.getSubAgentCallIdForThread(parsed.threadId);
     if (
       childSubAgentCallId &&
-      parsed.threadId &&
-      this.handleSubAgentContextCompactionItem(
-        childSubAgentCallId,
-        parsed.threadId,
-        parsed.item,
-        "loading",
-      )
+      this.handleSubAgentContextCompactionItem(childSubAgentCallId, parsed.item, "loading")
     ) {
       return;
     }
@@ -6778,6 +6802,9 @@ export class CodexAppServerAgentSession implements AgentSession {
     });
     if (childSubAgentCallId) {
       this.emitStartedProviderSubagentItem(parsed.threadId, timelineItem);
+      if (parsed.item.id) {
+        this.upsertSubAgentChildItem(childSubAgentCallId, parsed.item.id, timelineItem);
+      }
       this.emitSubAgentActivityUpdate(childSubAgentCallId, "running");
       await this.replayPendingSubAgentNotifications(registeredChildThreadIds);
       return;
@@ -6831,6 +6858,9 @@ export class CodexAppServerAgentSession implements AgentSession {
       if (parsed.threadId) {
         this.emitProviderSubagentTimeline(parsed.threadId, timelineItem);
       }
+      if (itemId) {
+        this.upsertSubAgentChildItem(childSubAgentCallId, itemId, timelineItem);
+      }
       this.emitSubAgentActivityUpdate(childSubAgentCallId, "running");
       return;
     }

packages/server/src/server/agent/providers/codex/tool-call-mapper.ts

@@ -950,7 +950,6 @@ function mapCollabAgentToolCallItem(
     type: "sub_agent",
     subAgentType: "Sub-agent",
     ...(item.prompt ? { description: item.prompt } : {}),
-    // COMPAT(subagent-log): remove after 2027-04-30.
     log: "",
     actions: [],
   };
@@ -1007,7 +1006,6 @@ function mapSubAgentActivityItem(
       type: "sub_agent",
       subAgentType: nativeName,
       description,
-      // COMPAT(subagent-log): remove after 2027-04-30.
       log: "",
       actions: [],
     },

packages/server/src/server/agent/providers/omp/agent.ts

@@ -69,7 +69,7 @@ import {
   type OmpRuntimeOptions,
 } from "./provider-config.js";
 export { formatOmpVersionSupport, resolveOmpDiagnosticPaths } from "./provider-config.js";
-import { OmpSubagentCardTracker } from "./subagent-card-tracker.js";
+import { OmpSubagentCardTracker, type OmpSubagentCardScheduler } from "./subagent-card-tracker.js";
 import { ompSkillPromptUserText, shouldDisplayOmpCustomMessage } from "./custom-message.js";
 import { getUserMessageText } from "./message-history.js";
 import { mapOmpSystemNoticeToNotification } from "./system-notice.js";
@@ -130,6 +130,7 @@ export interface OmpAgentClientOptions {
   logger: Logger;
   runtimeSettings?: ProviderRuntimeSettings;
   runtime?: OmpRuntime;
+  subagentCardScheduler?: OmpSubagentCardScheduler;
   providerIdleScheduler?: OmpProviderIdleScheduler;
   noTurnScheduler?: OmpNoTurnScheduler;
   usagePollScheduler?: OmpUsagePollScheduler;
@@ -204,6 +205,7 @@ interface OmpAgentSessionOptions {
   initialState: OmpSessionState;
   currentModeId?: string | null;
   logger: Logger;
+  subagentCardScheduler?: OmpSubagentCardScheduler;
   providerIdleScheduler?: OmpProviderIdleScheduler;
   noTurnScheduler?: OmpNoTurnScheduler;
   usagePollScheduler?: OmpUsagePollScheduler;
@@ -771,7 +773,9 @@ export class OmpAgentSession implements AgentSession {
         this.logger.debug({ err: error }, "OMP context usage poll failed");
       },
     });
-    this.subagentCardTracker = new OmpSubagentCardTracker();
+    this.subagentCardTracker = new OmpSubagentCardTracker({
+      scheduler: options.subagentCardScheduler,
+    });
     this.lastKnownThinkingOptionId =
       normalizeOmpThinkingOption(options.config.thinkingOptionId) ??
       this.state.thinkingLevel ??
@@ -2151,7 +2155,8 @@ export class OmpAgentSession implements AgentSession {
     return mapOmpToolDetail(toolCall, result, {
       toolCallId,
       bridgedTool: this.hostTools?.bridge?.tool(toolCall.toolName),
-      mapSubagentDetail: (detail) => this.subagentCardTracker.detailFor(toolCallId, detail),
+      mapSubagentDetail: (detail) =>
+        this.subagentCardTracker.detailFor(toolCallId, detail) ?? detail,
     });
   }
 
@@ -2241,6 +2246,7 @@ export class OmpAgentClient implements AgentClient {
 
   private readonly logger: Logger;
   private readonly runtimeSettings?: ProviderRuntimeSettings;
+  private readonly subagentCardScheduler?: OmpSubagentCardScheduler;
   private readonly providerIdleScheduler?: OmpProviderIdleScheduler;
   private readonly noTurnScheduler?: OmpNoTurnScheduler;
   private readonly usagePollScheduler?: OmpUsagePollScheduler;
@@ -2259,6 +2265,7 @@ export class OmpAgentClient implements AgentClient {
     );
     this.logger = options.logger;
     this.runtimeSettings = runtimeSettings;
+    this.subagentCardScheduler = options.subagentCardScheduler;
     this.providerIdleScheduler = options.providerIdleScheduler;
     this.noTurnScheduler = options.noTurnScheduler;
     this.usagePollScheduler = options.usagePollScheduler;
@@ -2342,6 +2349,7 @@ export class OmpAgentClient implements AgentClient {
         initialState,
         currentModeId: launchMode.modeId,
         logger: this.logger,
+        subagentCardScheduler: this.subagentCardScheduler,
         providerIdleScheduler: this.providerIdleScheduler,
         noTurnScheduler: this.noTurnScheduler,
         usagePollScheduler: this.usagePollScheduler,
@@ -2413,6 +2421,7 @@ export class OmpAgentClient implements AgentClient {
         initialState,
         currentModeId: launchMode.modeId,
         logger: this.logger,
+        subagentCardScheduler: this.subagentCardScheduler,
         providerIdleScheduler: this.providerIdleScheduler,
         noTurnScheduler: this.noTurnScheduler,
         usagePollScheduler: this.usagePollScheduler,

packages/server/src/server/agent/providers/omp/history-mapper.test.ts

@@ -637,7 +637,7 @@ describe("OMP history mapper", () => {
             subAgentType: "explore",
             description: "Inspect files",
             childSessionId: "/tmp/omp-task/Explore.jsonl",
-            log: "",
+            log: "done\ntranscript: /tmp/omp-task/Explore.jsonl",
           },
           error: null,
         },

packages/server/src/server/agent/providers/omp/subagent-card-tracker.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "vitest";
 
-import { OmpSubagentCardTracker } from "./subagent-card-tracker.js";
+import { OmpSubagentCardTracker, type OmpSubagentCardScheduler } from "./subagent-card-tracker.js";
 import type { OmpSubagentLifecyclePayload, OmpSubagentProgressPayload } from "./rpc-types.js";
 
 const PARENT_TOOL_CALL_ID = "task-1";
@@ -59,84 +59,184 @@ const PROGRESS: OmpSubagentProgressPayload[] = [
   },
 ];
 
+class ManualScheduler implements OmpSubagentCardScheduler {
+  private currentMs = 0;
+  private nextId = 1;
+  private readonly timers = new Map<number, { dueMs: number; callback: () => void }>();
+
+  now(): number {
+    return this.currentMs;
+  }
+
+  setTimeout(callback: () => void, delayMs: number) {
+    const id = this.nextId;
+    this.nextId += 1;
+    this.timers.set(id, { dueMs: this.currentMs + delayMs, callback });
+    return { token: id };
+  }
+
+  clearTimeout(timer: { token: unknown }): void {
+    if (typeof timer.token === "number") {
+      this.timers.delete(timer.token);
+    }
+  }
+
+  advance(ms: number): void {
+    this.currentMs += ms;
+    const dueTimers = [...this.timers.entries()]
+      .filter(([, timer]) => timer.dueMs <= this.currentMs)
+      .sort((left, right) => left[1].dueMs - right[1].dueMs);
+    for (const [id, timer] of dueTimers) {
+      if (this.timers.delete(id)) {
+        timer.callback();
+      }
+    }
+  }
+}
+
 describe("OmpSubagentCardTracker", () => {
-  test("keeps the card a launch marker while the child runs", () => {
+  test("folds lifecycle and progress into one throttled sub-agent detail", () => {
+    const scheduler = new ManualScheduler();
     const emitted: string[] = [];
-    const emit = (toolCallId: string) => {
-      emitted.push(toolCallId);
-      return true;
-    };
-    const tracker = new OmpSubagentCardTracker();
-    tracker.handleLifecycle(LIFECYCLE, emit);
+    const tracker = new OmpSubagentCardTracker({
+      scheduler,
+      emitToolCall: (toolCallId) => {
+        emitted.push(toolCallId);
+        return true;
+      },
+    });
+    tracker.handleLifecycle(LIFECYCLE);
     for (const payload of PROGRESS) {
-      tracker.handleProgress(payload, emit);
+      tracker.handleProgress(payload);
     }
 
     expect(emitted).toEqual([PARENT_TOOL_CALL_ID]);
-    expect(
-      tracker.detailFor(PARENT_TOOL_CALL_ID, {
-        type: "sub_agent",
-        subAgentType: "task",
-        description: "Task arg description wins",
-        log: "",
-      }),
-    ).toEqual({
+    const detailBeforeTrailing = tracker.detailFor(PARENT_TOOL_CALL_ID, {
+      type: "sub_agent",
+      subAgentType: "task",
+      description: "Task arg description wins",
+      log: "",
+    });
+    expect(detailBeforeTrailing).toEqual({
       type: "sub_agent",
       subAgentType: "task",
       description: "Task arg description wins",
       childSessionId: SESSION_FILE,
-      log: "",
+      log: [
+        "EchoSubagent started",
+        "[bash] echo subagent-hi",
+        "[yield]",
+        "EchoSubagent completed",
+      ].join("\n"),
     });
-  });
 
-  test("re-emits the card when a later event names the child", () => {
-    const emitted: string[] = [];
-    const emit = (toolCallId: string) => {
-      emitted.push(toolCallId);
-      return true;
-    };
-    const tracker = new OmpSubagentCardTracker();
-    tracker.handleLifecycle({ ...LIFECYCLE, description: undefined, sessionFile: undefined }, emit);
-    tracker.handleProgress(PROGRESS[0], emit);
+    scheduler.advance(500);
 
     expect(emitted).toEqual([PARENT_TOOL_CALL_ID, PARENT_TOOL_CALL_ID]);
-    expect(tracker.detailFor(PARENT_TOOL_CALL_ID, { type: "sub_agent", log: "" })).toEqual({
-      type: "sub_agent",
-      childSessionId: SESSION_FILE,
-      log: "",
+  });
+
+  test("aggregates batch progress streams into one index-prefixed log", () => {
+    const scheduler = new ManualScheduler();
+    const emitted: string[] = [];
+    const tracker = new OmpSubagentCardTracker({
+      scheduler,
+      emitToolCall: (toolCallId) => {
+        emitted.push(toolCallId);
+        return true;
+      },
     });
 
-    tracker.delete(PARENT_TOOL_CALL_ID);
-    expect(tracker.detailFor(PARENT_TOOL_CALL_ID, { type: "sub_agent", log: "" })).toEqual({
+    tracker.handleLifecycle({
+      id: "Explore",
+      agent: "task",
+      description: "Inspect files",
+      status: "started",
+      sessionFile: "/tmp/one.jsonl",
+      parentToolCallId: "task.batch-1",
+      index: 0,
+    });
+    scheduler.advance(600);
+    tracker.handleProgress({
+      index: 5,
+      agent: "task",
+      task: "Run tests",
+      parentToolCallId: "task.batch-1",
+      progress: {
+        id: "Test",
+        status: "running",
+        description: "Run tests",
+        recentTools: [{ tool: "bash", args: "npm test", endMs: 10 }],
+      },
+      sessionFile: "/tmp/two.jsonl",
+    });
+
+    expect(emitted).toEqual(["task.batch-1", "task.batch-1"]);
+    expect(
+      tracker.detailFor("task.batch-1", {
+        type: "sub_agent",
+        subAgentType: "batch",
+        actions: [],
+        log: "",
+      }),
+    ).toEqual({
       type: "sub_agent",
-      log: "",
+      subAgentType: "batch",
+      description: "Inspect files",
+      childSessionId: "/tmp/one.jsonl",
+      log: "[1/6] Explore started\n[6/6] [bash] npm test",
+      actions: [],
     });
   });
-  test("leaves the card alone when a later child of the same task starts", () => {
-    const emitted: string[] = [];
-    const emit = (toolCallId: string) => {
-      emitted.push(toolCallId);
-      return true;
-    };
-    const tracker = new OmpSubagentCardTracker();
-    tracker.handleLifecycle(LIFECYCLE, emit);
-    tracker.handleLifecycle(
-      {
-        ...LIFECYCLE,
-        id: "Second",
-        index: 1,
-        description: "Second child",
-        sessionFile: "/s.jsonl",
-      },
-      emit,
-    );
 
-    expect(emitted).toEqual([PARENT_TOOL_CALL_ID]);
-    expect(tracker.detailFor(PARENT_TOOL_CALL_ID, { type: "sub_agent", log: "" })).toEqual({
-      type: "sub_agent",
-      description: "Run echo in subagent",
-      childSessionId: SESSION_FILE,
-      log: "",
+  test("keeps dirty trailing state available for final detail and cancels it on cleanup", () => {
+    const scheduler = new ManualScheduler();
+    const emitted: string[] = [];
+    const tracker = new OmpSubagentCardTracker({
+      scheduler,
+      emitToolCall: (toolCallId) => {
+        emitted.push(toolCallId);
+        return true;
+      },
     });
+
+    tracker.handleLifecycle({
+      id: "Explore",
+      agent: "task",
+      description: "Inspect files",
+      status: "started",
+      parentToolCallId: "task-1",
+      index: 0,
+    });
+    scheduler.advance(100);
+    tracker.handleProgress({
+      index: 0,
+      agent: "task",
+      task: "Inspect files",
+      parentToolCallId: "task-1",
+      progress: {
+        id: "Explore",
+        status: "running",
+        recentOutput: ["found target file"],
+      },
+    });
+
+    expect(emitted).toEqual(["task-1"]);
+    expect(
+      tracker.detailFor("task-1", {
+        type: "sub_agent",
+        log: "",
+      }).log,
+    ).toBe("Explore started\nfound target file");
+
+    tracker.delete("task-1");
+    scheduler.advance(500);
+
+    expect(emitted).toEqual(["task-1"]);
+    expect(
+      tracker.detailFor("task-1", {
+        type: "sub_agent",
+        log: "static",
+      }).log,
+    ).toBe("static");
   });
 });

packages/server/src/server/agent/providers/omp/subagent-card-tracker.ts

@@ -1,106 +1,361 @@
 import type { ToolCallDetail } from "../../agent-sdk-types.js";
 import type { OmpSubagentLifecyclePayload, OmpSubagentProgressPayload } from "./rpc-types.js";
 
-interface OmpSubagentCardChild {
+export interface OmpSubagentCardTimer {
+  readonly token: unknown;
+}
+
+export interface OmpSubagentCardScheduler {
+  now(): number;
+  setTimeout(callback: () => void, delayMs: number): OmpSubagentCardTimer;
+  clearTimeout(timer: OmpSubagentCardTimer): void;
+}
+
+export interface OmpSubagentCardTrackerOptions {
+  scheduler?: OmpSubagentCardScheduler;
+  emitToolCall?: (toolCallId: string) => boolean;
+}
+
+interface OmpSubagentLogLine {
+  key: string;
+  text: string;
+}
+
+interface OmpSubagentCardItem {
   index: number;
   description?: string;
+  agent?: string;
+  status?: "pending" | "running" | "completed" | "failed" | "aborted";
   childSessionId?: string;
+  lines: OmpSubagentLogLine[];
+  lineKeys: Set<string>;
+}
+
+interface OmpSubagentCardState {
+  items: Map<number, OmpSubagentCardItem>;
+  emitToolCall: (toolCallId: string) => boolean;
+  lastEmitMs: number | null;
+  trailingTimer: OmpSubagentCardTimer | null;
+  dirty: boolean;
+}
+
+const MAX_LOG_LINES_PER_ITEM = 200;
+const MAX_LOG_LINE_CHARS = 240;
+const THROTTLE_INTERVAL_MS = 500;
+
+export function createOmpSubagentCardScheduler(): OmpSubagentCardScheduler {
+  return {
+    now: () => Date.now(),
+    setTimeout: (callback, delayMs) => ({ token: setTimeout(callback, delayMs) }),
+    clearTimeout: (timer) => {
+      clearTimeout(timer.token as ReturnType<typeof setTimeout>);
+    },
+  };
 }
 
-/**
- * Fills a task card's description and child session from OMP's sub-agent events. The card is a
- * launch marker that names the task's first child; the children's activity belongs to their own
- * timelines.
- */
 export class OmpSubagentCardTracker {
-  private readonly firstChildren = new Map<string, OmpSubagentCardChild>();
+  private readonly scheduler: OmpSubagentCardScheduler;
+  private readonly emitToolCall: (toolCallId: string) => boolean;
+  private readonly states = new Map<string, OmpSubagentCardState>();
+
+  constructor(options: OmpSubagentCardTrackerOptions) {
+    this.scheduler = options.scheduler ?? createOmpSubagentCardScheduler();
+    this.emitToolCall = options.emitToolCall ?? (() => false);
+  }
 
   handleLifecycle(
     payload: OmpSubagentLifecyclePayload,
-    emitToolCall: (toolCallId: string) => boolean,
+    emitToolCall: (toolCallId: string) => boolean = this.emitToolCall,
   ): void {
-    this.update(
-      payload.parentToolCallId,
-      {
-        index: payload.index,
-        description: payload.description,
-        childSessionId: payload.sessionFile,
-      },
-      emitToolCall,
+    const parentToolCallId = readTrimmedString(payload.parentToolCallId);
+    if (!parentToolCallId) {
+      return;
+    }
+    this.stateFor(parentToolCallId).emitToolCall = emitToolCall;
+    const item = this.upsertItem(parentToolCallId, {
+      index: payload.index,
+      agent: payload.agent,
+      description: payload.description,
+      status: payload.status === "started" ? "running" : payload.status,
+      childSessionId: payload.sessionFile,
+    });
+    this.appendLine(
+      item,
+      `lifecycle:${payload.status}:${payload.id}`,
+      `${payload.id} ${payload.status}`,
     );
+    this.requestEmit(parentToolCallId);
   }
 
   handleProgress(
     payload: OmpSubagentProgressPayload,
-    emitToolCall: (toolCallId: string) => boolean,
+    emitToolCall: (toolCallId: string) => boolean = this.emitToolCall,
   ): void {
-    this.update(
-      payload.parentToolCallId,
-      {
-        index: payload.index,
-        description: payload.progress.description,
-        childSessionId: payload.sessionFile,
-      },
-      emitToolCall,
-    );
+    const parentToolCallId = readTrimmedString(payload.parentToolCallId);
+    if (!parentToolCallId) {
+      return;
+    }
+    this.stateFor(parentToolCallId).emitToolCall = emitToolCall;
+    const item = this.upsertItem(parentToolCallId, {
+      index: payload.index,
+      agent: payload.agent,
+      description: payload.progress.description,
+      status: payload.progress.status,
+      childSessionId: payload.sessionFile,
+    });
+
+    const currentToolLine = summarizeTool(readRecord(payload.progress.currentTool));
+    if (currentToolLine) {
+      this.appendLine(item, `current:${currentToolLine.key}`, currentToolLine.text);
+    }
+
+    for (const tool of readRecordArray(payload.progress.recentTools)) {
+      const line = summarizeTool(tool);
+      if (line) {
+        this.appendLine(item, `tool:${line.key}`, line.text);
+      }
+    }
+
+    for (const output of readOutputLines(payload.progress.recentOutput)) {
+      this.appendLine(item, `output:${output}`, output);
+    }
+
+    if (payload.progress.status !== "running") {
+      this.appendLine(
+        item,
+        `status:${payload.progress.status}:${payload.progress.id}`,
+        `${payload.progress.id} ${payload.progress.status}`,
+      );
+    }
+
+    this.requestEmit(parentToolCallId);
   }
 
   detailFor(toolCallId: string, baseDetail: ToolCallDetail): ToolCallDetail {
     if (baseDetail.type !== "sub_agent") {
       return baseDetail;
     }
-    const first = this.firstChildren.get(toolCallId);
-    if (!first) {
+    const state = this.states.get(toolCallId);
+    if (!state) {
       return baseDetail;
     }
-    const description = baseDetail.description ?? first.description;
-    const childSessionId = first.childSessionId ?? baseDetail.childSessionId;
-    return {
-      ...baseDetail,
-      ...(description ? { description } : {}),
-      ...(childSessionId ? { childSessionId } : {}),
+    const items = [...state.items.values()].sort((left, right) => left.index - right.index);
+    const firstItem = items[0];
+    if (!firstItem) {
+      return baseDetail;
+    }
+
+    const detail: ToolCallDetail = {
+      type: "sub_agent",
+      ...(baseDetail.subAgentType ? { subAgentType: baseDetail.subAgentType } : {}),
+      ...((baseDetail.description ?? firstItem.description)
+        ? { description: baseDetail.description ?? firstItem.description }
+        : {}),
+      ...((firstItem.childSessionId ?? baseDetail.childSessionId)
+        ? { childSessionId: firstItem.childSessionId ?? baseDetail.childSessionId }
+        : {}),
+      log: buildLog(items, baseDetail.log),
     };
+    return baseDetail.actions ? { ...detail, actions: baseDetail.actions } : detail;
+  }
+
+  flush(toolCallId: string): void {
+    const state = this.states.get(toolCallId);
+    if (!state || !state.dirty) {
+      return;
+    }
+    this.emitNow(toolCallId, state);
   }
 
   delete(toolCallId: string): void {
-    this.firstChildren.delete(toolCallId);
+    const state = this.states.get(toolCallId);
+    if (state?.trailingTimer) {
+      this.scheduler.clearTimeout(state.trailingTimer);
+    }
+    this.states.delete(toolCallId);
   }
 
   clear(): void {
-    this.firstChildren.clear();
+    for (const toolCallId of this.states.keys()) {
+      this.delete(toolCallId);
+    }
   }
 
-  private update(
-    parentToolCallId: string | undefined,
-    input: { index: number; description?: string; childSessionId?: string },
-    emitToolCall: (toolCallId: string) => boolean,
-  ): void {
-    const toolCallId = readTrimmedString(parentToolCallId);
-    if (!toolCallId) {
-      return;
+  private upsertItem(
+    parentToolCallId: string,
+    input: {
+      index: number;
+      agent?: string;
+      status?: "pending" | "running" | "completed" | "failed" | "aborted";
+      description?: string;
+      childSessionId?: string;
+    },
+  ): OmpSubagentCardItem {
+    const state = this.stateFor(parentToolCallId);
+    const existing = state.items.get(input.index);
+    if (existing) {
+      existing.agent = readTrimmedString(input.agent) ?? existing.agent;
+      existing.status = input.status ?? existing.status;
+      existing.description = readTrimmedString(input.description) ?? existing.description;
+      existing.childSessionId = readTrimmedString(input.childSessionId) ?? existing.childSessionId;
+      return existing;
     }
-    const first = this.firstChildren.get(toolCallId);
-    if (first && input.index > first.index) {
-      return;
-    }
-    const existing = first?.index === input.index ? first : undefined;
-    const next: OmpSubagentCardChild = {
+
+    const item: OmpSubagentCardItem = {
       index: input.index,
-      description: readTrimmedString(input.description) ?? existing?.description,
-      childSessionId: readTrimmedString(input.childSessionId) ?? existing?.childSessionId,
+      lines: [],
+      lineKeys: new Set<string>(),
+      ...(readTrimmedString(input.agent) ? { agent: readTrimmedString(input.agent) } : {}),
+      ...(input.status ? { status: input.status } : {}),
+      ...(readTrimmedString(input.description)
+        ? { description: readTrimmedString(input.description) }
+        : {}),
+      ...(readTrimmedString(input.childSessionId)
+        ? { childSessionId: readTrimmedString(input.childSessionId) }
+        : {}),
     };
-    if (
-      existing &&
-      existing.description === next.description &&
-      existing.childSessionId === next.childSessionId
-    ) {
+    state.items.set(input.index, item);
+    return item;
+  }
+
+  private stateFor(parentToolCallId: string): OmpSubagentCardState {
+    const existing = this.states.get(parentToolCallId);
+    if (existing) {
+      return existing;
+    }
+    const state: OmpSubagentCardState = {
+      items: new Map(),
+      emitToolCall: this.emitToolCall,
+      lastEmitMs: null,
+      trailingTimer: null,
+      dirty: false,
+    };
+    this.states.set(parentToolCallId, state);
+    return state;
+  }
+
+  private appendLine(item: OmpSubagentCardItem, key: string, text: string): void {
+    const normalizedText = normalizeLine(text);
+    if (!normalizedText || item.lineKeys.has(key)) {
       return;
     }
-    this.firstChildren.set(toolCallId, next);
-    emitToolCall(toolCallId);
+    item.lines.push({ key, text: normalizedText });
+    item.lineKeys.add(key);
+    while (item.lines.length > MAX_LOG_LINES_PER_ITEM) {
+      const removed = item.lines.shift();
+      if (removed) {
+        item.lineKeys.delete(removed.key);
+      }
+    }
   }
+
+  private requestEmit(toolCallId: string): void {
+    const state = this.stateFor(toolCallId);
+    const now = this.scheduler.now();
+    const elapsedMs = state.lastEmitMs === null ? THROTTLE_INTERVAL_MS : now - state.lastEmitMs;
+    if (elapsedMs >= THROTTLE_INTERVAL_MS) {
+      this.emitNow(toolCallId, state);
+      return;
+    }
+
+    state.dirty = true;
+    if (state.trailingTimer) {
+      return;
+    }
+    state.trailingTimer = this.scheduler.setTimeout(() => {
+      state.trailingTimer = null;
+      if (state.dirty) {
+        this.emitNow(toolCallId, state);
+      }
+    }, THROTTLE_INTERVAL_MS - elapsedMs);
+  }
+
+  private emitNow(toolCallId: string, state: OmpSubagentCardState): void {
+    if (state.trailingTimer) {
+      this.scheduler.clearTimeout(state.trailingTimer);
+      state.trailingTimer = null;
+    }
+    state.dirty = false;
+    state.lastEmitMs = this.scheduler.now();
+    state.emitToolCall(toolCallId);
+  }
+}
+
+function buildLog(items: OmpSubagentCardItem[], fallback: string): string {
+  const itemCount = Math.max(...items.map((item) => item.index)) + 1;
+  const lines = items.flatMap((item) => {
+    const prefix = itemCount > 1 ? `[${item.index + 1}/${itemCount}] ` : "";
+    return item.lines.map((line) => `${prefix}${line.text}`);
+  });
+  return lines.length > 0 ? lines.join("\n") : fallback;
+}
+
+function summarizeTool(tool: Record<string, unknown> | null): OmpSubagentLogLine | null {
+  if (!tool) {
+    return null;
+  }
+  const toolName = readTrimmedString(tool.tool) ?? readTrimmedString(tool.name);
+  if (!toolName) {
+    return null;
+  }
+  const args = readTrimmedString(tool.args) ?? summarizeUnknown(tool.input);
+  const endMs = typeof tool.endMs === "number" ? `:${tool.endMs}` : "";
+  return {
+    key: `${toolName}:${args ?? ""}${endMs}`,
+    text: args ? `[${toolName}] ${args}` : `[${toolName}]`,
+  };
+}
+
+function readOutputLines(value: unknown): string[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((item) => {
+    const text =
+      readTrimmedString(item) ??
+      (isRecord(item)
+        ? (readTrimmedString(item.text) ??
+          readTrimmedString(item.output) ??
+          readTrimmedString(item.content))
+        : undefined);
+    return text ? [text] : [];
+  });
+}
+
+function readRecord(value: unknown): Record<string, unknown> | null {
+  return isRecord(value) ? value : null;
+}
+
+function readRecordArray(value: unknown): Record<string, unknown>[] {
+  return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+
+function summarizeUnknown(value: unknown): string | undefined {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+  if (typeof value === "string") {
+    return readTrimmedString(value);
+  }
+  const json = JSON.stringify(value);
+  return typeof json === "string" ? normalizeLine(json) : undefined;
+}
+
+function normalizeLine(value: string): string | undefined {
+  const normalized = value.trim().replace(/\s+/g, " ");
+  if (!normalized) {
+    return undefined;
+  }
+  if (normalized.length <= MAX_LOG_LINE_CHARS) {
+    return normalized;
+  }
+  return `${normalized.slice(0, MAX_LOG_LINE_CHARS)}...`;
 }
 
 function readTrimmedString(value: unknown): string | undefined {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

packages/server/src/server/agent/providers/omp/tool-call-mapper.test.ts

@@ -85,7 +85,7 @@ describe("OMP tool call mapper", () => {
     expect(mapOmpToolDetail(parseToolArgs("todo", { op: "view" }), null)).toBeNull();
   });
 
-  test("takes the child session from the task transcript path", () => {
+  test("uses task result text and transcript path as the best static replay detail", () => {
     expect(
       mapOmpToolDetail(
         parseToolArgs("task", {
@@ -106,7 +106,7 @@ describe("OMP tool call mapper", () => {
       subAgentType: "explore",
       description: "Inspect the target files",
       childSessionId: "/tmp/omp-task-static/Explore.jsonl",
-      log: "",
+      log: "done\ntranscript: /tmp/omp-task-static/Explore.jsonl",
     });
   });
 

packages/server/src/server/agent/providers/omp/tool-call-mapper.ts

@@ -179,6 +179,7 @@ const OPAQUE_TEXT_TOOLS = new Set([
 function mapOmpTaskDetail(args: unknown, result: OmpToolResult): ToolCallDetail {
   const argRecord = isRecord(args) ? args : {};
   const firstTask = Array.isArray(argRecord.tasks) ? argRecord.tasks.find(isRecord) : undefined;
+  const resultText = extractTextFromToolResult(result);
   const childSessionId = readChildSessionId(result);
   return {
     type: "sub_agent",
@@ -199,8 +200,7 @@ function mapOmpTaskDetail(args: unknown, result: OmpToolResult): ToolCallDetail
       argRecord.assignment,
     ),
     ...(childSessionId ? { childSessionId } : {}),
-    // COMPAT(subagent-log): remove after 2027-04-30.
-    log: "",
+    log: resultText?.trim() ?? "",
   };
 }
 

packages/server/src/server/agent/providers/opencode-agent.ts

@@ -4846,6 +4846,15 @@ class OpenCodeAgentSession implements AgentSession {
             ...item,
             status: "failed",
             error,
+            detail:
+              item.detail.type === "sub_agent"
+                ? {
+                    ...item.detail,
+                    log: [item.detail.log, error.message]
+                      .filter((entry) => entry.trim().length > 0)
+                      .join("\n"),
+                  }
+                : item.detail,
           },
         },
         turnId,

packages/server/src/server/agent/providers/opencode/tool-call-detail-parser.ts

@@ -153,6 +153,21 @@ const OpencodeGrepOutputSchema = z
   ])
   .nullable();
 
+function formatLogEntry(value: unknown): string | undefined {
+  const outputText = readOutputText(value);
+  if (outputText) {
+    return outputText;
+  }
+  if (value === null || value === undefined) {
+    return undefined;
+  }
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+
 function extractOpenCodeTaskSessionId(value: unknown): string | undefined {
   const text = readOutputText(value);
   if (text) {
@@ -180,6 +195,7 @@ function extractOpenCodeTaskSessionId(value: unknown): string | undefined {
 function deriveOpencodeTaskDetail(
   input: unknown,
   output: unknown,
+  error: unknown,
   metadata: Record<string, unknown> | undefined,
 ): ToolCallDetail | null {
   if (!isRecord(input)) {
@@ -192,6 +208,7 @@ function deriveOpencodeTaskDetail(
     return null;
   }
 
+  const log = [formatLogEntry(output), formatLogEntry(error)].filter((entry) => entry).join("\n");
   const childSessionId =
     normalizeSubAgentText(metadata?.sessionId) ?? extractOpenCodeTaskSessionId(output);
   return {
@@ -199,8 +216,7 @@ function deriveOpencodeTaskDetail(
     ...(subAgentType ? { subAgentType } : {}),
     ...(description ? { description } : {}),
     ...(childSessionId ? { childSessionId } : {}),
-    // COMPAT(subagent-log): remove after 2027-04-30.
-    log: "",
+    log,
     actions: [],
   };
 }
@@ -357,10 +373,11 @@ export function deriveOpencodeToolDetail(
   toolName: string,
   input: unknown,
   output: unknown,
+  error: unknown = null,
   metadata?: Record<string, unknown>,
 ): ToolCallDetail {
   if (toolName.trim().toLowerCase() === "task") {
-    const taskDetail = deriveOpencodeTaskDetail(input, output, metadata);
+    const taskDetail = deriveOpencodeTaskDetail(input, output, error, metadata);
     if (taskDetail) {
       return taskDetail;
     }

packages/server/src/server/agent/providers/opencode/tool-call-mapper.test.ts

@@ -460,7 +460,7 @@ describe("opencode tool-call mapper", () => {
     });
   });
 
-  it("maps completed task calls to sub_agent detail", () => {
+  it("maps completed task calls with final output log to sub_agent detail", () => {
     const item = expectMapped(
       mapOpencodeToolCall({
         toolName: "task",
@@ -480,7 +480,7 @@ describe("opencode tool-call mapper", () => {
       type: "sub_agent",
       subAgentType: "explore",
       description: "Explore agent-tools codebase",
-      log: "",
+      log: "Found the CLI entrypoint and provider registry.",
       actions: [],
     });
   });
@@ -505,12 +505,12 @@ describe("opencode tool-call mapper", () => {
       subAgentType: "explore",
       description: "Explore current directory",
       childSessionId: "ses_2268db431ffe299vL1bbot8R7Z",
-      log: "",
+      log: '<task id="ses_2268db431ffe299vL1bbot8R7Z">done</task>',
       actions: [],
     });
   });
 
-  it("maps aborted task calls to sub_agent detail", () => {
+  it("maps aborted task calls with preserved error log to sub_agent detail", () => {
     const item = expectMapped(
       mapOpencodeToolCall({
         toolName: "task",
@@ -531,7 +531,7 @@ describe("opencode tool-call mapper", () => {
       type: "sub_agent",
       subAgentType: "explore",
       description: "Explore agent-tools codebase",
-      log: "",
+      log: "Tool execution aborted",
       actions: [],
     });
   });

packages/server/src/server/agent/providers/opencode/tool-call-mapper.ts

@@ -43,7 +43,7 @@ export function mapOpencodeToolCall(params: OpencodeToolCallParams): ToolCallTim
   const error = raw.error ?? null;
   const rawStatus = typeof raw.status === "string" ? raw.status : undefined;
   const status = normalizeToolCallStatus(rawStatus, error, output);
-  const detail = deriveOpencodeToolDetail(name, input, output, raw.metadata);
+  const detail = deriveOpencodeToolDetail(name, input, output, error, raw.metadata);
 
   if (status === "failed") {
     return {

packages/server/src/server/agent/providers/pi/extensions/edxeth-pi-subagents/index.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { extractTextFromToolResult } from "../../tool-call-mapper.js";
 import type { PiChildSessionFile, PiExtension } from "../contract.js";
 import type { ProviderSubagentInputEvent } from "../../../../provider-subagents/store.js";
 
@@ -98,8 +99,7 @@ export const edxethPiSubagents: PiExtension = {
           detail: {
             type: "sub_agent",
             description,
-            // COMPAT(subagent-log): remove after 2027-04-30.
-            log: "",
+            log: extractTextFromToolResult(call.result)?.trim() ?? "",
           },
           subagents,
           childSessions,

packages/server/src/server/agent/providers/pi/extensions/gotgenes-pi-subagents/index.test.ts

@@ -130,18 +130,6 @@ describe("@gotgenes/pi-subagents adapter", () => {
         .filter((event) => event.event.type === "upsert")
         .map((event) => (event.event.type === "upsert" ? event.event.status : null)),
     ).toEqual(["running", "completed"]);
-    expect(
-      events.flatMap((event) => (event.event.type === "timeline" ? [event.event] : [])),
-    ).toEqual([
-      {
-        type: "timeline",
-        id: "call_502323",
-        item: {
-          type: "assistant_message",
-          text: "Agent completed in 4.7s (1 tool uses, 9.0k token).\nAgent ID: 848583f5-6749-4a1\n\nThe workspace is empty.",
-        },
-      },
-    ]);
   });
   test("correlates a background notification and result collection", async () => {
     const source = readSubagentFixture(new URL("./fixtures/background.json", import.meta.url));

packages/server/src/server/agent/providers/pi/extensions/gotgenes-pi-subagents/index.ts

@@ -64,8 +64,7 @@ export const gotgenesPiSubagents: PiExtension = {
         type: "sub_agent" as const,
         subAgentType: title,
         description,
-        // COMPAT(subagent-log): remove after 2027-04-30.
-        log: "",
+        log: extractTextFromToolResult(call.result)?.trim() ?? "",
       };
       if (call.status === "running")
         return {
@@ -93,10 +92,6 @@ export const gotgenesPiSubagents: PiExtension = {
         outputFileFromToolResult(call.result) ?? pendingFilesByAgent.get(details.data.agentId);
       pendingFilesByAgent.delete(details.data.agentId);
       const childSessions = childSession(call.callId, file);
-      const childStatus = status(details.data.status);
-      // Without a session file, as on replay, the child's answer is the tool result.
-      const answer =
-        !file && childStatus !== "running" ? extractTextFromToolResult(call.result)?.trim() : "";
       return {
         detail,
         subagents: [
@@ -106,17 +101,8 @@ export const gotgenesPiSubagents: PiExtension = {
             title,
             description,
             toolCallId: call.callId,
-            status: childStatus,
+            status: status(details.data.status),
           },
-          ...(answer
-            ? [
-                {
-                  type: "timeline" as const,
-                  id: call.callId,
-                  item: { type: "assistant_message" as const, text: answer },
-                },
-              ]
-            : []),
         ],
         childSessions,
       };
@@ -132,8 +118,7 @@ export const gotgenesPiSubagents: PiExtension = {
       const detail = {
         type: "sub_agent" as const,
         description: details.success ? details.data.description : undefined,
-        // COMPAT(subagent-log): remove after 2027-04-30.
-        log: "",
+        log: extractTextFromToolResult(call.result)?.trim() ?? "",
       };
       if (call.status === "running" || !details.success) return { detail };
       const file = details.data.transcriptPath;

packages/server/src/server/agent/providers/pi/extensions/index.test.ts

@@ -210,7 +210,7 @@ describe("Pi extension host", () => {
           type: "sub_agent",
           subAgentType: "scout",
           description: "Inspect files",
-          log: "",
+          log: "Found two files",
         },
       }),
     );

packages/server/src/server/agent/providers/pi/extensions/pi-subagents/index.test.ts

@@ -137,7 +137,7 @@ describe("pi-subagents adapter", () => {
       type: "sub_agent",
       subAgentType: "reviewer",
       description: "Review the Pi mapper change",
-      log: "",
+      log: "The mapper change preserves provider status.",
     });
   });
 

packages/server/src/server/agent/providers/pi/extensions/pi-subagents/index.ts

@@ -131,8 +131,7 @@ export const piSubagents: PiExtension = {
         type: "sub_agent" as const,
         subAgentType: args.data.agent,
         description: args.data.task,
-        // COMPAT(subagent-log): remove after 2027-04-30.
-        log: "",
+        log: extractTextFromToolResult(call.result)?.trim() ?? "",
       };
       const base = {
         type: "upsert" as const,

packages/server/src/server/agent/providers/pi/extensions/subagent-fixture-test.ts

@@ -54,6 +54,8 @@ export async function verifySubagentFixture(
   try {
     await session.startTurn("Delegate work");
     for (const event of fixture.events) pi.latestSession().emit(event);
+    const immediate = live.filter((event) => event.type === "provider_subagent");
+    expect(immediate.some((event) => event.event.type === "timeline")).toBe(false);
     pi.latestSession().finishTurn();
     const replay: AgentStreamEvent[] = [];
     for await (const event of streamPiHistory("pi", fixture.messages)) replay.push(event);

packages/server/src/server/agent/providers/pi/extensions/tintinweb-pi-subagents/index.test.ts

@@ -36,17 +36,12 @@ describe("@tintinweb/pi-subagents adapter", () => {
     });
     expect(mapping?.subagents).toEqual([
       expect.objectContaining({ id: "call-1", status: "completed" }),
-      {
-        type: "timeline",
-        id: "call-1",
-        item: { type: "assistant_message", text: "Wrapped up (turn limit)" },
-      },
     ]);
     expect(mapping?.detail).toEqual({
       type: "sub_agent",
       subAgentType: "Explore",
       description: "Inspect",
-      log: "",
+      log: "Wrapped up (turn limit)",
     });
   });
   test("maps captured foreground lifecycle live and on replay", async () => {
@@ -58,18 +53,6 @@ describe("@tintinweb/pi-subagents adapter", () => {
         .filter((event) => event.event.type === "upsert")
         .map((event) => (event.event.type === "upsert" ? event.event.status : null)),
     ).toEqual(["running", "completed"]);
-    expect(
-      events.flatMap((event) => (event.event.type === "timeline" ? [event.event] : [])),
-    ).toEqual([
-      {
-        type: "timeline",
-        id: "call_458926",
-        item: {
-          type: "assistant_message",
-          text: "Agent completed in 6.6s (1 tool uses, 18.8k token).\n\nThe workspace directory `/tmp/paseo-pi-extension-phase3/workspace` is empty (no files or hidden dotfiles).",
-        },
-      },
-    ]);
   });
   test("uses a structured notification to complete a background child", async () => {
     const source = readSubagentFixture(new URL("./fixtures/background.json", import.meta.url));
@@ -164,7 +147,7 @@ describe("@tintinweb/pi-subagents adapter", () => {
       expect(mapping?.detail).toEqual({
         type: "sub_agent",
         description: undefined,
-        log: "",
+        log: "Wrapped up (turn limit)",
       });
     },
   );

packages/server/src/server/agent/providers/pi/extensions/tintinweb-pi-subagents/index.ts

@@ -57,8 +57,7 @@ export const tintinwebPiSubagents: PiExtension = {
         type: "sub_agent" as const,
         subAgentType: title,
         description,
-        // COMPAT(subagent-log): remove after 2027-04-30.
-        log: "",
+        log: extractTextFromToolResult(call.result)?.trim() ?? "",
       };
       if (call.status === "running")
         return {
@@ -85,10 +84,6 @@ export const tintinwebPiSubagents: PiExtension = {
       const file = outputFileFromToolResult(call.result);
       const childSessions = file && !readSessions.has(file) ? [{ id: call.callId, file }] : [];
       if (file) readSessions.add(file);
-      const childStatus = status(details.data.status);
-      // A foreground child has no session file; its answer is the tool result.
-      const answer =
-        !file && childStatus !== "running" ? extractTextFromToolResult(call.result)?.trim() : "";
       return {
         detail,
         subagents: [
@@ -98,17 +93,8 @@ export const tintinwebPiSubagents: PiExtension = {
             title,
             description,
             toolCallId: call.callId,
-            status: childStatus,
+            status: status(details.data.status),
           },
-          ...(answer
-            ? [
-                {
-                  type: "timeline" as const,
-                  id: call.callId,
-                  item: { type: "assistant_message" as const, text: answer },
-                },
-              ]
-            : []),
         ],
         childSessions,
       };
@@ -124,8 +110,7 @@ export const tintinwebPiSubagents: PiExtension = {
       const detail = {
         type: "sub_agent" as const,
         description: details.success ? details.data.description : undefined,
-        // COMPAT(subagent-log): remove after 2027-04-30.
-        log: "",
+        log: extractTextFromToolResult(call.result)?.trim() ?? "",
       };
       if (call.status === "running" || !details.success) return { detail };
       return {

packages/server/src/server/daemon-e2e/background-subagent-action-log.real.e2e.test.ts

@@ -1,3 +1,6 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
@@ -7,7 +10,7 @@ import { ClaudeAgentClient } from "../agent/providers/claude/agent.js";
 import { createTestPaseoDaemon } from "../test-utils/paseo-daemon.js";
 import { DaemonClient } from "../test-utils/daemon-client.js";
 
-test("background children keep their actions after the parent finishes (#6253)", async () => {
+test("background cards retain child actions after the parent finishes (#6253)", async () => {
   const cwd = mkdtempSync(path.join(tmpdir(), "paseo-background-card-"));
   const logger = pino({ level: "silent" });
   const daemon = await createTestPaseoDaemon({
@@ -59,6 +62,22 @@ test("background children keep their actions after the parent finishes (#6253)",
       limit: 0,
       projection: "projected",
     });
+    const { stdout } = await promisify(execFile)(
+      process.execPath,
+      [
+        "--conditions=source",
+        "--import",
+        "tsx",
+        fileURLToPath(new URL("../../../../cli/src/index.ts", import.meta.url)),
+        "--host",
+        `127.0.0.1:${daemon.port}`,
+        "logs",
+        agent.id,
+      ],
+      { env: { ...process.env, PASEO_HOME: daemon.paseoHome }, timeout: 30_000 },
+    );
+    expect(stdout).toContain("[Bash] ls -1");
+    expect(stdout).toContain("[Bash] pwd");
     expect(
       atFinish.entries.filter(
         (row) => row.item.type === "tool_call" && row.item.detail?.type === "sub_agent",
@@ -75,6 +94,9 @@ test("background children keep their actions after the parent finishes (#6253)",
         ),
       ).toBe(true);
     }
+    for (const card of cards) {
+      expect(card.detail?.type === "sub_agent" ? card.detail.log : "").toContain("[Bash]");
+    }
   } finally {
     await client.close();
     await daemon.close();

packages/server/src/server/daemon-e2e/oversized-timeline.e2e.test.ts

@@ -0,0 +1,46 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { expect, test } from "vitest";
+import { createDaemonTestContext } from "../test-utils/index.js";
+
+// #2220: a timeline page is one WebSocket message, so a few huge entries used to close the socket.
+test.each([40, 0])(
+  "fetching image-heavy history with limit %i keeps the direct connection usable",
+  async (limit) => {
+    const ctx = await createDaemonTestContext();
+    const cwd = mkdtempSync(path.join(tmpdir(), "oversized-timeline-"));
+    try {
+      const agent = await ctx.client.createAgent({ provider: "codex", cwd });
+      const imageUrl = `data:image/jpeg;base64,${"A".repeat(14 * 1024 * 1024)}`;
+      for (let index = 0; index < 5; index += 1) {
+        await ctx.daemon.daemon.agentManager.appendTimelineItem(agent.id, {
+          type: "tool_call",
+          callId: `screenshot-${index}`,
+          name: "node_repl.js",
+          status: "completed",
+          error: null,
+          detail: {
+            type: "unknown",
+            input: { index },
+            output: { _meta: { "codex/toolSurface": { screenshot: { url: imageUrl } } } },
+          },
+        });
+      }
+
+      const page = await ctx.client.fetchAgentTimeline(agent.id, { direction: "tail", limit });
+      const screenshots = page.entries.filter((entry) => entry.item.type === "tool_call");
+      expect(screenshots).toHaveLength(5);
+      for (const entry of screenshots) {
+        expect(Buffer.byteLength(JSON.stringify(entry.item))).toBeLessThanOrEqual(64 * 1024);
+      }
+
+      const next = await ctx.client.fetchAgentTimeline(agent.id, { direction: "tail", limit: 1 });
+      expect(next.entries).toHaveLength(1);
+    } finally {
+      await ctx.cleanup();
+      rmSync(cwd, { recursive: true, force: true });
+    }
+  },
+  60_000,
+);