@poncho-ai/harness 0.52.2 → 0.55.0

package/src/compaction.ts

@@ -26,6 +26,20 @@ const SUMMARIZATION_PROMPT = `Summarize the following conversation into a struct
 Be concise but preserve all information needed to continue the task.
 Omit any section that has no relevant content.`;
 
+/**
+ * Extra instruction appended when the first compacted message is itself a
+ * prior compaction summary. The model must treat that block as the existing
+ * working state and produce an updated, merged version rather than
+ * re-summarizing the (already lossy) summary from scratch.
+ */
+const CUMULATIVE_SUMMARY_PROMPT = `The FIRST message below (tagged [prior-summary]) is an existing working-state summary produced by an earlier compaction. Treat it as the authoritative prior working state: MERGE AND UPDATE it with the newer messages that follow it, carrying forward all still-relevant detail. Do NOT discard or re-compress information from the prior summary just because it is older — only drop it if the newer messages explicitly supersede it.`;
+
+/** Max chars of a subagent result text kept verbatim in the ledger digest. */
+const SUBAGENT_DIGEST_CHARS = 500;
+
+/** Heading used for the verbatim, model-proof subagent ledger block. */
+const SUBAGENT_LEDGER_HEADING = "## Subagents";
+
 export const resolveCompactionConfig = (
   explicit?: Partial<CompactionConfig>,
 ): CompactionConfig => {
@@ -78,11 +92,48 @@ export const estimateTotalTokens = (
   return tokens;
 };
 
+/**
+ * Whether an assistant message carries serialized tool_calls. Assistant
+ * tool-call turns serialize their content as a JSON string of the shape
+ * `{"text":...,"tool_calls":[...]}` (see the harness run loop). A plain-text
+ * assistant message returns false.
+ */
+const assistantHasToolCalls = (msg: Message): boolean => {
+  if (msg.role !== "assistant") return false;
+  if (typeof msg.content !== "string") return false;
+  if (!msg.content.includes('"tool_calls"')) return false;
+  try {
+    const parsed = JSON.parse(msg.content) as { tool_calls?: unknown };
+    return Array.isArray(parsed.tool_calls) && parsed.tool_calls.length > 0;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Whether splitting at `idx` would orphan a tool-call relationship on the
+ * COMPACTED side — i.e. the last compacted message (`messages[idx-1]`) is an
+ * assistant message with tool_calls whose answering `role:"tool"` result
+ * lives on the PRESERVED side (`messages[idx]`). Folding only the assistant
+ * call into the summary strands the tool_calls with no matching result.
+ */
+const splitOrphansToolCalls = (messages: Message[], idx: number): boolean => {
+  if (idx <= 0 || idx >= messages.length) return false;
+  const lastCompacted = messages[idx - 1]!;
+  return assistantHasToolCalls(lastCompacted);
+};
+
 /**
  * Find the safe split index so that everything before it can be compacted
  * and everything from it onward is preserved. The split always lands just
  * before a `user` message to avoid breaking assistant+tool pairs.
  *
+ * Defensive guard: even at a `user` boundary, refuse a split whose compacted
+ * side would END on an assistant message with unanswered tool_calls (its
+ * `tool` result having moved to the preserved side). Such a split would
+ * orphan the tool_calls inside the summary boundary. When that happens we
+ * walk earlier to the next safe `user` boundary.
+ *
  * Returns -1 if no valid split point is found.
  */
 export const findSafeSplitPoint = (
@@ -92,16 +143,17 @@ export const findSafeSplitPoint = (
   const candidateIdx = messages.length - keepRecentMessages;
   if (candidateIdx < MIN_COMPACTABLE_MESSAGES) return -1;
 
-  // Walk backwards from candidate to find a user message boundary
+  // Walk backwards from candidate to find a user message boundary that does
+  // not orphan a tool-call relationship on the compacted side.
   for (let i = candidateIdx; i >= MIN_COMPACTABLE_MESSAGES; i--) {
-    if (messages[i]!.role === "user") {
+    if (messages[i]!.role === "user" && !splitOrphansToolCalls(messages, i)) {
       return i;
     }
   }
 
-  // Walk forwards from candidate as fallback
+  // Walk forwards from candidate as fallback.
   for (let i = candidateIdx + 1; i < messages.length - 1; i++) {
-    if (messages[i]!.role === "user") {
+    if (messages[i]!.role === "user" && !splitOrphansToolCalls(messages, i)) {
       if (i < MIN_COMPACTABLE_MESSAGES) return -1;
       return i;
     }
@@ -110,25 +162,46 @@ export const findSafeSplitPoint = (
   return -1;
 };
 
+/**
+ * Whether a message is itself a prior compaction summary.
+ */
+const isCompactionSummary = (msg: Message): boolean =>
+  msg.metadata?.isCompactionSummary === true;
+
 /**
  * Build the summarization messages for the generateText call.
+ *
+ * Cumulative behavior: when the FIRST compacted message is itself a prior
+ * compaction summary, it is passed in FULL (not truncated to
+ * SUMMARIZATION_MESSAGE_TRUNCATION_CHARS) and tagged `[prior-summary]`, and
+ * the prompt instructs the model to merge-and-update rather than
+ * re-summarize. All other messages keep the 1200-char truncation.
  */
 const buildSummarizationMessages = (
   messagesToCompact: Message[],
   instructions?: string,
 ): Array<{ role: "user"; content: string }> => {
+  const hasPriorSummary =
+    messagesToCompact.length > 0 && isCompactionSummary(messagesToCompact[0]!);
+
   const conversationLines: string[] = [];
-  for (const msg of messagesToCompact) {
+  for (let i = 0; i < messagesToCompact.length; i++) {
+    const msg = messagesToCompact[i]!;
     const text = getTextContent(msg);
-    const truncated = text.length > SUMMARIZATION_MESSAGE_TRUNCATION_CHARS
-      ? text.slice(0, SUMMARIZATION_MESSAGE_TRUNCATION_CHARS) + "\n...[truncated]"
-      : text;
-    conversationLines.push(`[${msg.role}]: ${truncated}`);
+    const isPrior = i === 0 && hasPriorSummary;
+    // The prior summary is the working state we must not lose — pass it whole.
+    const rendered =
+      isPrior || text.length <= SUMMARIZATION_MESSAGE_TRUNCATION_CHARS
+        ? text
+        : text.slice(0, SUMMARIZATION_MESSAGE_TRUNCATION_CHARS) +
+          "\n...[truncated]";
+    const tag = isPrior ? "prior-summary" : msg.role;
+    conversationLines.push(`[${tag}]: ${rendered}`);
   }
 
-  const prompt = instructions
-    ? `${SUMMARIZATION_PROMPT}\n\nAdditional focus: ${instructions}`
-    : SUMMARIZATION_PROMPT;
+  let prompt = SUMMARIZATION_PROMPT;
+  if (hasPriorSummary) prompt = `${prompt}\n\n${CUMULATIVE_SUMMARY_PROMPT}`;
+  if (instructions) prompt = `${prompt}\n\nAdditional focus: ${instructions}`;
 
   return [
     {
@@ -138,6 +211,121 @@ const buildSummarizationMessages = (
   ];
 };
 
+interface SubagentLedgerEntry {
+  subagentId: string;
+  task: string;
+  status: string;
+  digest: string;
+}
+
+/** Match the header line of an injected subagent callback message. */
+const SUBAGENT_RESULT_HEADER =
+  /^\[Subagent Result\] Subagent "([^"]*)" \(([^)]*)\) (\S+):/;
+
+/**
+ * Parse the metadata + text of a subagent-callback user message into a ledger
+ * entry. Returns null when the message is not a subagent callback.
+ */
+const parseSubagentCallback = (msg: Message): SubagentLedgerEntry | null => {
+  if (msg.role !== "user") return null;
+  const meta = (msg.metadata ?? {}) as Record<string, unknown>;
+  const text = getTextContent(msg);
+  const hasMetaFlag =
+    meta._subagentCallback === true || meta.subagentCallback === true;
+  const hasTextMarker = text.startsWith("[Subagent Result]");
+  if (!hasMetaFlag && !hasTextMarker) return null;
+
+  // Prefer structured metadata, fall back to parsing the header line.
+  const headerMatch = text.match(SUBAGENT_RESULT_HEADER);
+  const subagentId =
+    typeof meta.subagentId === "string" && meta.subagentId
+      ? meta.subagentId
+      : headerMatch?.[2] ?? "";
+  if (!subagentId) return null;
+  const task =
+    typeof meta.task === "string" && meta.task
+      ? meta.task
+      : headerMatch?.[1] ?? "";
+  const status = headerMatch?.[3] ?? "completed";
+
+  // Digest = the body after the header line (the result text), capped.
+  const bodyStart = text.indexOf("\n\n");
+  const body = bodyStart >= 0 ? text.slice(bodyStart + 2) : text;
+  const digest =
+    body.length > SUBAGENT_DIGEST_CHARS
+      ? body.slice(0, SUBAGENT_DIGEST_CHARS) + "…"
+      : body;
+
+  return { subagentId, task, status, digest };
+};
+
+/**
+ * Parse a prior `## Subagents` ledger block out of an existing compaction
+ * summary's content so it can be carried forward cumulatively. The block is
+ * rendered by `renderSubagentLedger`, so we parse that same shape.
+ */
+const parsePriorLedger = (summaryText: string): SubagentLedgerEntry[] => {
+  const headingIdx = summaryText.indexOf(SUBAGENT_LEDGER_HEADING);
+  if (headingIdx < 0) return [];
+  const block = summaryText.slice(headingIdx + SUBAGENT_LEDGER_HEADING.length);
+  const entries: SubagentLedgerEntry[] = [];
+  // Each entry: a bullet line "- **<task>** (<id>) — <status>" then a digest
+  // line. We tolerate missing digest lines.
+  const entryRe =
+    /^- \*\*(.*?)\*\* \((.+?)\) — (\S+)\n {2}(.*)$/gm;
+  let m: RegExpExecArray | null;
+  while ((m = entryRe.exec(block)) !== null) {
+    entries.push({
+      task: m[1]!,
+      subagentId: m[2]!,
+      status: m[3]!,
+      digest: m[4]!,
+    });
+  }
+  return entries;
+};
+
+/**
+ * Scan the messages being compacted for subagent-callback records and any
+ * prior ledger embedded in a compaction summary, returning a combined,
+ * deduped (by subagentId, last-write-wins) list in first-seen order.
+ */
+const collectSubagentLedger = (
+  messagesToCompact: Message[],
+): SubagentLedgerEntry[] => {
+  const byId = new Map<string, SubagentLedgerEntry>();
+  const order: string[] = [];
+  const upsert = (entry: SubagentLedgerEntry) => {
+    if (!byId.has(entry.subagentId)) order.push(entry.subagentId);
+    byId.set(entry.subagentId, entry);
+  };
+
+  for (const msg of messagesToCompact) {
+    if (isCompactionSummary(msg)) {
+      for (const prior of parsePriorLedger(getTextContent(msg))) upsert(prior);
+      continue;
+    }
+    const entry = parseSubagentCallback(msg);
+    if (entry) upsert(entry);
+  }
+
+  return order.map((id) => byId.get(id)!);
+};
+
+/**
+ * Render the subagent ledger as a verbatim markdown block appended to the
+ * summary AFTER the LLM text, so the model can never paraphrase it away.
+ * Returns "" when there are no subagents.
+ */
+const renderSubagentLedger = (entries: SubagentLedgerEntry[]): string => {
+  if (entries.length === 0) return "";
+  const lines = entries.map(
+    (e) =>
+      `- **${e.task}** (${e.subagentId}) — ${e.status}\n  ${e.digest.replace(/\n/g, " ")}`,
+  );
+  return `${SUBAGENT_LEDGER_HEADING}\n${lines.join("\n")}`;
+};
+
 /**
  * Build the continuation message that replaces compacted messages.
  */
@@ -217,7 +405,12 @@ export const compactMessages = async (
       };
     }
 
-    const continuationMessage = buildContinuationMessage(summary);
+    // Append the subagent ledger AFTER the LLM summary, verbatim, so the
+    // model's paraphrasing can never drop or truncate subagent results.
+    const ledger = renderSubagentLedger(collectSubagentLedger(toCompact));
+    const summaryWithLedger = ledger ? `${summary}\n\n${ledger}` : summary;
+
+    const continuationMessage = buildContinuationMessage(summaryWithLedger);
     const compactedMessages = [continuationMessage, ...toPreserve];
 
     return {

package/src/harness.ts

@@ -3344,7 +3344,7 @@ Code is wrapped in an async IIFE — use \`return\` to return a value to the too
           return;
         }
         const runtimeToolName = exposedToolNames.get(call.name) ?? call.name;
-        yield pushEvent({ type: "tool:started", tool: runtimeToolName, input: call.input });
+        yield pushEvent({ type: "tool:started", tool: runtimeToolName, toolCallId: call.id, input: call.input });
         if (this.requiresApprovalForToolCall(runtimeToolName, call.input)) {
           approvalNeeded.push({
             approvalId: `approval_${randomUUID()}`,
@@ -3563,6 +3563,7 @@ Code is wrapped in an async IIFE — use \`return\` to return a value to the too
           yield pushEvent({
             type: "tool:error",
             tool: result.tool,
+            toolCallId: result.callId,
             error: result.error,
             recoverable: true,
           });
@@ -3604,6 +3605,7 @@ Code is wrapped in an async IIFE — use \`return\` to return a value to the too
           yield pushEvent({
             type: "tool:completed",
             tool: result.tool,
+            toolCallId: result.callId,
             input: callInputMap.get(result.callId),
             output: result.output,
             duration: now() - batchStart,

package/src/orchestrator/orchestrator.ts

@@ -693,12 +693,15 @@ export class AgentOrchestrator {
       result: { status: "completed", response: responseText, steps: 0, tokens: { input: 0, output: 0, cached: 0 }, duration: 0 },
       timestamp: Date.now(),
     };
-    await this.conversationStore.appendSubagentResult(conv.parentConversationId, pendingResult);
+    await this.appendSubagentResultReliable(conv.parentConversationId, pendingResult);
 
     await this.eventSink(conv.parentConversationId, {
       type: "subagent:completed",
       subagentId,
       conversationId: subagentId,
+      task: conv.subagentMeta?.task ?? conv.title,
+      parentToolCallId: conv.subagentMeta?.parentToolCallId,
+      resultText: responseText,
     });
 
     await this.triggerParentCallback(conv.parentConversationId);
@@ -796,10 +799,14 @@ export class AgentOrchestrator {
     let latestRunId = "";
     let runResult: { status: "completed" | "error" | "cancelled"; response?: string; steps: number; duration: number; continuation?: boolean; continuationMessages?: Message[] } | undefined;
     let runError: { code?: string; message?: string } | undefined;
+    // The spawning tool call's id — echoed onto subagent:* events so the
+    // client can attach subagent state to that tool's pill.
+    let parentToolCallId: string | undefined;
 
     try {
       const conversation = await this.conversationStore.getWithArchive(childConversationId);
       if (!conversation) throw new Error("Subagent conversation not found");
+      parentToolCallId = conversation.subagentMeta?.parentToolCallId;
 
       if (conversation.subagentMeta?.status === "stopped") return;
 
@@ -1054,6 +1061,9 @@ export class AgentOrchestrator {
         type: "subagent:completed",
         subagentId: childConversationId,
         conversationId: childConversationId,
+        task,
+        parentToolCallId,
+        resultText: subagentResponse,
       });
 
       this.triggerParentCallback(parentConversationId).catch(err =>
@@ -1090,6 +1100,8 @@ export class AgentOrchestrator {
         subagentId: childConversationId,
         conversationId: childConversationId,
         error: errMsg,
+        task,
+        parentToolCallId,
       });
 
       this.triggerParentCallback(parentConversationId).catch(err2 =>
@@ -1476,6 +1488,9 @@ export class AgentOrchestrator {
         type: "subagent:completed",
         subagentId: conversationId,
         conversationId,
+        task,
+        parentToolCallId: conversation.subagentMeta?.parentToolCallId,
+        resultText: subagentResponse,
       });
 
       if (parentConv) {
@@ -1520,6 +1535,8 @@ export class AgentOrchestrator {
         type: "subagent:completed",
         subagentId: conversationId,
         conversationId,
+        task,
+        parentToolCallId: conversation.subagentMeta?.parentToolCallId,
       });
 
       if (parentConv) {
@@ -1553,7 +1570,7 @@ export class AgentOrchestrator {
           opts.tenantId ?? null,
           {
             parentConversationId: opts.parentConversationId,
-            subagentMeta: { task: opts.task, status: "running", suppressTelemetry: opts.suppressTelemetry },
+            subagentMeta: { task: opts.task, status: "running", suppressTelemetry: opts.suppressTelemetry, parentToolCallId: opts.parentToolCallId },
             messages: [{ role: "user", content: opts.task }],
           },
         );
@@ -1568,6 +1585,7 @@ export class AgentOrchestrator {
           subagentId: conversation.conversationId,
           conversationId: conversation.conversationId,
           task: opts.task,
+          parentToolCallId: opts.parentToolCallId,
         });
 
         if (this.isServerless) {

package/src/state.ts

@@ -79,6 +79,9 @@ export interface Conversation {
      *  subagent's runs emit no telemetry (e.g. spawned from an incognito
      *  turn). Read by the orchestrator's runSubagent / continuation. */
     suppressTelemetry?: boolean;
+    /** The parent's `spawn_subagent` tool call id — echoed onto subagent:*
+     *  events so a client can attach subagent state to that tool's pill. */
+    parentToolCallId?: string;
   };
   channelMeta?: {
     platform: string;

package/src/storage/entries.ts

@@ -0,0 +1,204 @@
+import type { Message } from "@poncho-ai/sdk";
+import type { PendingSubagentResult } from "../state.js";
+
+/**
+ * Append-only conversation entries (Phase 3 substrate).
+ *
+ * The eventual replacement for the mutable per-conversation JSON blob: a
+ * conversation becomes an ordered, append-only list of entries, and the
+ * mutable-blob clobber race (two writers serializing a stale whole-blob
+ * snapshot over each other — the root cause behind lost subagent results)
+ * stops being expressible.
+ *
+ * This module is intentionally PURE: it defines the entry shapes and the
+ * functions that rebuild a conversation's LLM context / display transcript
+ * / pending-subagent-results from an entry list. No storage engine, no DB,
+ * no wiring into the live run loop yet — so it deploys nothing and is
+ * fully unit-testable. The engine implementations (append/read on
+ * postgres/sqlite/memory) and the write-site conversions come in later PRs
+ * once this rebuild logic is proven.
+ *
+ * Ordering: every entry carries a monotonic per-conversation `seq`. Entries
+ * are assumed sorted by `seq` ascending when passed to the rebuild fns.
+ */
+
+interface BaseEntry {
+  /** Stable cross-reference id (uuid). */
+  id: string;
+  /** Monotonic per-conversation order. */
+  seq: number;
+  createdAt: number;
+}
+
+/** A user-role display message (incl. typed subagent-callback messages). */
+export interface UserMessageEntry extends BaseEntry {
+  type: "user_message";
+  message: Message;
+  turnId: string;
+  /** Hidden from the display transcript (e.g. a framed job prompt, an
+   *  onboarding seed, or an injected subagent-result message). Still part
+   *  of the record; just not rendered as a chat bubble. */
+  hidden?: boolean;
+}
+
+/** The final assistant bubble for a completed/cancelled/errored turn. */
+export interface AssistantMessageEntry extends BaseEntry {
+  type: "assistant_message";
+  message: Message;
+  turnId: string;
+  runId: string;
+}
+
+/** A post-hoc edit to an already-emitted assistant message — replaces the
+ *  orchestrator/resume "mutate the last assistant message in place" writes
+ *  with an append. Applied at rebuild time. */
+export interface AssistantAmendmentEntry extends BaseEntry {
+  type: "assistant_amendment";
+  targetEntryId: string;
+  appendText?: string;
+}
+
+/** One LLM-transcript message (the model-visible form). Appended from the
+ *  run loop per step — never diffed from an array. */
+export interface HarnessMessageEntry extends BaseEntry {
+  type: "harness_message";
+  message: Message;
+  turnId: string;
+}
+
+/** Compaction overlay: nothing is deleted. At rebuild, the LLM context is
+ *  the latest compaction's `summaryMessage` followed by the harness
+ *  messages from `firstKeptSeq` onward. */
+export interface CompactionEntry extends BaseEntry {
+  type: "compaction";
+  summaryMessage: Message;
+  firstKeptSeq: number;
+  tokensBefore?: number;
+  tokensAfter?: number;
+}
+
+/** A finished subagent's result arriving for the parent. Pending = a
+ *  subagent_result whose seq is not listed in any later callback_started. */
+export interface SubagentResultEntry extends BaseEntry {
+  type: "subagent_result";
+  result: PendingSubagentResult;
+}
+
+/** Marks which subagent_result entries a callback turn consumed (by seq).
+ *  Consumption is an append, never a delete. */
+export interface CallbackStartedEntry extends BaseEntry {
+  type: "callback_started";
+  consumedSeqs: number[];
+}
+
+export type ConversationEntry =
+  | UserMessageEntry
+  | AssistantMessageEntry
+  | AssistantAmendmentEntry
+  | HarnessMessageEntry
+  | CompactionEntry
+  | SubagentResultEntry
+  | CallbackStartedEntry;
+
+/**
+ * Rebuild the LLM-visible message context from the entry log.
+ *
+ * If a compaction overlay exists, the context is its summary message
+ * followed by every harness message with seq >= firstKeptSeq (a later
+ * compaction's firstKeptSeq can point at an earlier summary that was
+ * itself appended as a harness message, so layered compactions just work).
+ * With no compaction, it's every harness message in order.
+ */
+export function buildLlmContext(entries: ConversationEntry[]): Message[] {
+  let latestCompaction: CompactionEntry | undefined;
+  for (const e of entries) {
+    if (e.type === "compaction" && (!latestCompaction || e.seq > latestCompaction.seq)) {
+      latestCompaction = e;
+    }
+  }
+
+  const harnessMsgs = entries.filter(
+    (e): e is HarnessMessageEntry => e.type === "harness_message",
+  );
+
+  if (latestCompaction) {
+    const kept = harnessMsgs
+      .filter((e) => e.seq >= latestCompaction!.firstKeptSeq)
+      .map((e) => e.message);
+    return [latestCompaction.summaryMessage, ...kept];
+  }
+  return harnessMsgs.map((e) => e.message);
+}
+
+export interface DisplaySnapshot {
+  messages: Message[];
+  /** Total display messages available (for pagination UIs). */
+  totalMessages: number;
+  /** seq of the first message returned (a `beforeSeq` pagination cursor). */
+  headSeq: number | null;
+}
+
+/**
+ * Rebuild the display transcript (the user-visible chat) from the entry
+ * log, returning the trailing `tailN` messages. Amendments are folded into
+ * their target assistant message; hidden user messages are dropped.
+ */
+export function buildDisplaySnapshot(
+  entries: ConversationEntry[],
+  tailN: number,
+): DisplaySnapshot {
+  const amendmentsByTarget = new Map<string, AssistantAmendmentEntry[]>();
+  for (const e of entries) {
+    if (e.type === "assistant_amendment") {
+      const list = amendmentsByTarget.get(e.targetEntryId) ?? [];
+      list.push(e);
+      amendmentsByTarget.set(e.targetEntryId, list);
+    }
+  }
+
+  const built: { seq: number; message: Message }[] = [];
+  for (const e of entries) {
+    if (e.type === "user_message") {
+      if (e.hidden) continue;
+      built.push({ seq: e.seq, message: e.message });
+    } else if (e.type === "assistant_message") {
+      let content = typeof e.message.content === "string" ? e.message.content : "";
+      const amendments = amendmentsByTarget.get(e.id);
+      if (amendments) {
+        for (const a of amendments.sort((x, y) => x.seq - y.seq)) {
+          if (a.appendText) content += a.appendText;
+        }
+      }
+      built.push({ seq: e.seq, message: { ...e.message, content } });
+    }
+  }
+
+  const total = built.length;
+  const tail = tailN >= total ? built : built.slice(total - tailN);
+  return {
+    messages: tail.map((b) => b.message),
+    totalMessages: total,
+    headSeq: tail.length > 0 ? tail[0]!.seq : null,
+  };
+}
+
+/**
+ * Subagent results that have arrived but not yet been consumed by a
+ * callback turn — the append-only replacement for the mutable
+ * `pendingSubagentResults` array. A result is pending unless a later
+ * callback_started lists its seq in `consumedSeqs`.
+ */
+export function getPendingSubagentResults(
+  entries: ConversationEntry[],
+): PendingSubagentResult[] {
+  const consumed = new Set<number>();
+  for (const e of entries) {
+    if (e.type === "callback_started") {
+      for (const s of e.consumedSeqs) consumed.add(s);
+    }
+  }
+  return entries
+    .filter((e): e is SubagentResultEntry => e.type === "subagent_result")
+    .filter((e) => !consumed.has(e.seq))
+    .map((e) => e.result);
+}

package/src/subagent-manager.ts

@@ -40,6 +40,10 @@ export interface SubagentManager {
     /** Inherit the parent run's telemetry choice — when true, the subagent
      *  run (and its re-runs) emit no telemetry. */
     suppressTelemetry?: boolean;
+    /** The id of the `spawn_subagent` tool call that produced this subagent,
+     *  so its events can carry `parentToolCallId` and a client can attach
+     *  subagent state to the spawning tool's pill. */
+    parentToolCallId?: string;
   }): Promise<SubagentSpawnResult>;
 
   sendMessage(subagentId: string, message: string): Promise<SubagentSpawnResult>;

package/src/subagent-tools.ts

@@ -46,6 +46,7 @@ export const createSubagentTools = (
         ownerId,
         tenantId: context.tenantId,
         suppressTelemetry: context.suppressTelemetry,
+        parentToolCallId: context.toolCallId,
       });
       return { subagentId, status: "running" };
     },

package/src/tool-dispatcher.ts

@@ -62,7 +62,10 @@ export class ToolDispatcher {
     }
 
     try {
-      const output = await definition.handler(call.input, context);
+      // Per-call context: stamp the current tool call's id so handlers that
+      // spawn further work (spawn_subagent) can record `parentToolCallId`.
+      // A fresh object — `context` is shared across a batch, don't mutate it.
+      const output = await definition.handler(call.input, { ...context, toolCallId: call.id });
       if (context.abortSignal?.aborted) {
         return {
           callId: call.id,