@ian-pascoe/pi-minimal-subagents 0.2.2 → 0.3.0

package/src/minimal-subagents-extension.ts

@@ -39,6 +39,7 @@ import {
   findDeliveryEvidence,
   PiAgentSessionFactory,
   type PiAgentSessionFactoryOptions,
+  unavailableAgent,
 } from "./minimal-subagents-sessions.js";
 import { shutdownMinimalSubagentsSession } from "./minimal-subagents-shutdown.js";
 import { createCoordinatorToolDefinitions } from "./minimal-subagents-tools.js";
@@ -53,6 +54,7 @@ import type {
   CoordinatorNotification,
   ForkSnapshot,
   PersistedAgent,
+  PersistedSessionIdentity,
   RegistrySnapshot,
   RootConversationEndpoint,
 } from "./minimal-subagents-types.js";
@@ -75,7 +77,6 @@ function rootCallerSnapshot(pi: ExtensionAPI, context: ExtensionContext): Caller
     thinkingLevel: context.thinkingLevel ?? pi.getThinkingLevel(),
     ordinaryTools: activeTools,
     capabilityCeiling: availableTools,
-    availableTools,
     spawnEntryId: context.sessionManager.getLeafId() ?? "root",
   };
 }
@@ -99,6 +100,7 @@ function createRootConversationEndpoint(
         },
       );
     },
+    isIdle: () => context.isIdle(),
     hasDeliveryEvidence: (sourceAgentId, sourceTurnId, deliveryId) =>
       findDeliveryEvidence(
         context.sessionManager.getBranch(),
@@ -182,57 +184,84 @@ function orderForkAgentsParentFirst(agents: readonly PersistedAgent[]): Persiste
 }
 
 function unavailableForkAgent(agent: PersistedAgent, error: string): PersistedAgent {
-  return {
-    ...structuredClone(agent),
-    session_file: undefined,
-    session_id: undefined,
-    session_leaf_id: undefined,
-    clone_error: error,
-    active_turn_id: undefined,
-    active_turn_started_at: undefined,
-    availability: "unavailable",
-    missing_dependencies: [error],
-    unavailable_reason: error,
-  };
+  return unavailableAgent(agent, error);
 }
 
-async function cloneSelectedForkSessions(
-  sessionFactory: AgentSessionFactory,
-  snapshot: RegistrySnapshot,
-  sourceRootSessionFile: string,
-  sourceRootSessionId: string,
+/** One per-agent fork rebind step returning the destination session identity. */
+type ForkAgentRebind = (agent: PersistedAgent) => Promise<PersistedSessionIdentity>;
+
+interface ForkRebindOptions {
+  /** Require an existing clone session before rebinding (ownership pass only). */
+  readonly requiresCloneSession: boolean;
+  /** Message for agents skipped because an ancestor's rebind failed. */
+  readonly skippedMessage: (agent: PersistedAgent, failedAncestor: string) => string;
+  /** Human label used in failure notifications. */
+  readonly notifyLabel: string;
+}
+
+/** Walk fork agents parent-first, rebind each session, and quarantine failed subtrees. */
+async function rebindForkAgents(
+  snapshotAgents: readonly PersistedAgent[],
+  rebind: ForkAgentRebind,
+  options: ForkRebindOptions,
   context: ExtensionContext,
-): Promise<ForkSnapshot> {
+): Promise<PersistedAgent[]> {
   const agents: PersistedAgent[] = [];
   const failedSubtrees = new Set<string>();
-  for (const agent of orderForkAgentsParentFirst(snapshot.agents)) {
+  for (const agent of orderForkAgentsParentFirst(snapshotAgents)) {
     const failedAncestor = [...failedSubtrees].find(
       (agentId) => agent.agent_id === agentId || agent.agent_id.startsWith(`${agentId}.`),
     );
-    if (failedAncestor) {
-      agents.push(unavailableForkAgent(agent, `Ancestor clone failed: ${failedAncestor}`));
+    const missingCloneSession =
+      options.requiresCloneSession && (!agent.session_file || !agent.session_id);
+    if (failedAncestor !== undefined || missingCloneSession) {
+      const message =
+        failedAncestor !== undefined
+          ? options.skippedMessage(agent, failedAncestor)
+          : (agent.clone_error ?? `Ancestor ownership failed: ${agent.agent_id}`);
+      agents.push(unavailableForkAgent(agent, message));
       continue;
     }
     try {
-      const clone = await sessionFactory.cloneForkSourceSession(agent, sourceRootSessionId);
-      if (!clone.sessionLeafId) {
+      const identity = await rebind(agent);
+      if (!identity.sessionLeafId) {
         throw new Error(
           `Minimal subagents fork recovery: no selected session leaf for ${agent.agent_id}`,
         );
       }
       agents.push({
         ...structuredClone(agent),
-        session_file: clone.sessionFile,
-        session_id: clone.sessionId,
-        session_leaf_id: clone.sessionLeafId,
+        session_file: identity.sessionFile,
+        session_id: identity.sessionId,
+        session_leaf_id: identity.sessionLeafId,
       });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       failedSubtrees.add(agent.agent_id);
       agents.push(unavailableForkAgent(agent, message));
-      context.ui.notify(`Fork recovery clone failed for ${agent.agent_id}: ${message}`, "error");
+      context.ui.notify(`${options.notifyLabel} for ${agent.agent_id}: ${message}`, "error");
     }
   }
+  return agents;
+}
+
+async function cloneSelectedForkSessions(
+  sessionFactory: AgentSessionFactory,
+  snapshot: RegistrySnapshot,
+  sourceRootSessionFile: string,
+  sourceRootSessionId: string,
+  context: ExtensionContext,
+): Promise<ForkSnapshot> {
+  const agents = await rebindForkAgents(
+    snapshot.agents,
+    (agent) => sessionFactory.cloneForkSourceSession(agent, sourceRootSessionId),
+    {
+      requiresCloneSession: false,
+      skippedMessage: (_agent, failedAncestor) => `Ancestor clone failed: ${failedAncestor}`,
+      notifyLabel: "Fork recovery clone failed",
+    },
+    context,
+  );
   return {
     ...structuredClone(snapshot),
     source_root_session_file: sourceRootSessionFile,
@@ -246,44 +275,16 @@ async function bindForkSnapshotToDestination(
   snapshot: ForkSnapshot,
   context: ExtensionContext,
 ): Promise<ForkSnapshot> {
-  const agents: PersistedAgent[] = [];
-  const failedSubtrees = new Set<string>();
-  for (const agent of orderForkAgentsParentFirst(snapshot.agents)) {
-    const failedAncestor = [...failedSubtrees].find(
-      (agentId) => agent.agent_id === agentId || agent.agent_id.startsWith(`${agentId}.`),
-    );
-    if (failedAncestor || !agent.session_file || !agent.session_id) {
-      agents.push(
-        unavailableForkAgent(
-          agent,
-          agent.clone_error ?? `Ancestor ownership failed: ${failedAncestor ?? agent.agent_id}`,
-        ),
-      );
-      continue;
-    }
-    try {
-      const owned = await sessionFactory.adoptForkSessionOwnership(
-        agent,
-        snapshot.source_root_session_id,
-      );
-      if (!owned.sessionLeafId) {
-        throw new Error(
-          `Minimal subagents fork ownership: no selected session leaf for ${agent.agent_id}`,
-        );
-      }
-      agents.push({
-        ...structuredClone(agent),
-        session_file: owned.sessionFile,
-        session_id: owned.sessionId,
-        session_leaf_id: owned.sessionLeafId,
-      });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      failedSubtrees.add(agent.agent_id);
-      agents.push(unavailableForkAgent(agent, message));
-      context.ui.notify(`Fork ownership failed for ${agent.agent_id}: ${message}`, "error");
-    }
-  }
+  const agents = await rebindForkAgents(
+    snapshot.agents,
+    (agent) => sessionFactory.adoptForkSessionOwnership(agent, snapshot.source_root_session_id),
+    {
+      requiresCloneSession: true,
+      skippedMessage: () => "Ancestor ownership failed",
+      notifyLabel: "Fork ownership failed",
+    },
+    context,
+  );
   return { ...structuredClone(snapshot), agents };
 }
 

package/src/minimal-subagents-fork-lifecycle.ts

@@ -1,6 +1,5 @@
-import { existsSync, realpathSync } from "node:fs";
-import { resolve } from "node:path";
 import type { ForkSnapshot } from "./minimal-subagents-types.js";
+import { canonicalPath } from "./minimal-subagents-sessions.js";
 
 declare global {
   // eslint-disable-next-line no-var -- A process-global handoff must be visible to replacement extension instances.
@@ -12,11 +11,6 @@ function forkSnapshotStore(): Map<string, ForkSnapshot> {
   return globalThis.minimalSubagentsForkSnapshots;
 }
 
-function canonicalSessionFile(sessionFile: string): string {
-  const absolutePath = resolve(sessionFile);
-  return existsSync(absolutePath) ? realpathSync(absolutePath) : absolutePath;
-}
-
 /** Prove a process-loss fork destination was derived from the expected canonical source file. */
 export function isForkDestinationForSource(
   destinationHeader: { parentSession?: string } | null,
@@ -24,14 +18,13 @@ export function isForkDestinationForSource(
 ): boolean {
   return (
     destinationHeader?.parentSession !== undefined &&
-    canonicalSessionFile(destinationHeader.parentSession) ===
-      canonicalSessionFile(previousSessionFile)
+    canonicalPath(destinationHeader.parentSession) === canonicalPath(previousSessionFile)
   );
 }
 
 /** Retain a complete pre-fork hierarchy across Pi extension-instance replacement. */
 export function rememberForkSnapshot(snapshot: ForkSnapshot): void {
-  const canonicalSourceFile = canonicalSessionFile(snapshot.source_root_session_file);
+  const canonicalSourceFile = canonicalPath(snapshot.source_root_session_file);
   const retained = structuredClone(snapshot);
   retained.source_root_session_file = canonicalSourceFile;
   forkSnapshotStore().set(canonicalSourceFile, retained);
@@ -39,7 +32,7 @@ export function rememberForkSnapshot(snapshot: ForkSnapshot): void {
 
 /** Consume the pre-fork hierarchy once when the destination root session starts. */
 export function takeForkSnapshot(previousSessionFile: string): ForkSnapshot | undefined {
-  const key = canonicalSessionFile(previousSessionFile);
+  const key = canonicalPath(previousSessionFile);
   const snapshot = forkSnapshotStore().get(key);
   if (snapshot) forkSnapshotStore().delete(key);
   return snapshot ? structuredClone(snapshot) : undefined;

package/src/minimal-subagents-registry-wire.ts

@@ -102,7 +102,6 @@ export const RegistryAgentWireSchema = Type.Object({
   missing_dependencies: Type.Array(NonEmptyStringSchema),
   unavailable_reason: Type.Optional(NonEmptyStringSchema),
   recent_messages: Type.Array(RegistryRecentMessageWireSchema),
-  deleted: Type.Optional(Type.Boolean()),
 });
 
 /** Parses one terminal Delivery Ledger item without applying ownership semantics. */

package/src/minimal-subagents-registry.ts

@@ -399,7 +399,6 @@ function parseRegistryAgent(value: RegistryAgentWire, version: 1 | 2): Persisted
     agent.latest_result = cloneRegistryTurnResult(value.latest_result);
   }
   if (value.unavailable_reason !== undefined) agent.unavailable_reason = value.unavailable_reason;
-  if (value.deleted !== undefined) agent.deleted = value.deleted;
   return agent;
 }
 
@@ -620,12 +619,6 @@ function validateRegistrySnapshot(
       "tombstone agent ID is not canonical",
     );
   }
-  if (agents.some((agent) => agent.deleted === true)) {
-    return invalidRegistrySnapshot(
-      "invalid-agent-hierarchy",
-      "live snapshot agents cannot be deleted",
-    );
-  }
   const agentIds = new Set(agents.map((agent) => agent.agent_id));
   if (tombstones.some((agentId) => agentIds.has(agentId))) {
     return invalidRegistrySnapshot(
@@ -1245,8 +1238,7 @@ export function replayRegistryEntries(
         if (
           event.agent.active_turn_id ||
           event.agent.latest_result ||
-          event.agent.recent_messages.length > 0 ||
-          event.agent.deleted
+          event.agent.recent_messages.length > 0
         ) {
           reportDiagnostic(
             diagnostics,

package/src/minimal-subagents-render-contract.ts

@@ -5,15 +5,9 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "typebox";
 import { Value } from "typebox/value";
+import { COORDINATOR_TOOL_NAMES } from "./minimal-subagents-capabilities.js";
 
-/** Names of the six coordinator tools with custom transcript renderers. */
-export type CoordinatorToolName =
-  | "subagent"
-  | "agent_message"
-  | "subagent_wait"
-  | "subagent_status"
-  | "subagent_cancel"
-  | "subagent_delete";
+export type CoordinatorToolName = (typeof COORDINATOR_TOOL_NAMES)[number];
 
 const RenderUsageSchema = Type.Object({
   input: Type.Number(),
@@ -55,6 +49,11 @@ const RenderRecentMessageSchema = Type.Object({
   source_agent_id: Type.Optional(Type.String()),
   content: Type.Optional(Type.String()),
 });
+const RenderRecentActivitySchema = Type.Object({
+  label: Type.String(),
+  content: Type.String(),
+  truncated: Type.Boolean(),
+});
 
 /** Structurally parsed hierarchy status used only by transcript presentation. */
 export const RenderStatusAgentSchema = Type.Object({
@@ -80,6 +79,7 @@ export const RenderStatusAgentSchema = Type.Object({
   capability_ceiling: Type.Optional(Type.Array(Type.String())),
   spawn_entry_id: Type.Optional(Type.String()),
   recent_messages: Type.Optional(Type.Array(RenderRecentMessageSchema)),
+  recent_activity: Type.Optional(Type.Array(RenderRecentActivitySchema)),
   latest_result: Type.Optional(RenderTurnResultSchema),
   missing_dependencies: Type.Optional(Type.Array(Type.String())),
   unavailable_reason: Type.Optional(Type.String()),
@@ -148,6 +148,13 @@ const WaitTurnDetailsSchema = Type.Object({
   usage: Type.Optional(RenderUsageSchema),
   messages: Type.Optional(Type.Array(WaitMessageDetailsSchema)),
 });
+const WaitTimeoutDetailsSchema = Type.Object({
+  event: Type.Literal("timeout"),
+  agent_id: Type.String(),
+  turn_id: Type.String(),
+  timeout_ms: Type.Number(),
+  agent: RenderStatusAgentSchema,
+});
 const StatusDetailsSchema = Type.Union([
   Type.Object({
     parent_id: Type.Optional(Type.String()),
@@ -165,7 +172,6 @@ const DeleteDetailsSchema = Type.Object({
   agent_id: Type.String(),
   recursive: Type.Boolean(),
   deleted_agent_ids: Type.Array(Type.String()),
-  tombstoned_agent_ids: Type.Array(Type.String()),
   trashed_session_files: Type.Array(Type.String()),
   failures: Type.Array(
     Type.Object({
@@ -179,7 +185,11 @@ const MessageRenderDetailsSchema = Type.Union([
   CurrentMessageDetailsSchema,
   LegacyMessageDetailsSchema,
 ]);
-const WaitRenderDetailsSchema = Type.Union([WaitMessageDetailsSchema, WaitTurnDetailsSchema]);
+const WaitRenderDetailsSchema = Type.Union([
+  WaitMessageDetailsSchema,
+  WaitTurnDetailsSchema,
+  WaitTimeoutDetailsSchema,
+]);
 
 export type SpawnCallArguments = Static<typeof SpawnCallArgumentsSchema>;
 export type MessageCallArguments = Static<typeof MessageCallArgumentsSchema>;

package/src/minimal-subagents-rendering.ts

@@ -62,7 +62,8 @@ type SubagentPresentationStatus =
   | "delivered"
   | "delivered-via-wait"
   | "queued"
-  | "message";
+  | "message"
+  | "timed out";
 
 type SubagentStatusPresentation = { readonly symbol: string; readonly color: ThemeColor };
 
@@ -79,6 +80,7 @@ const SUBAGENT_STATUS_PRESENTATION = {
   "delivered-via-wait": { symbol: "→", color: "accent" },
   queued: { symbol: "↗", color: "accent" },
   message: { symbol: "→", color: "accent" },
+  "timed out": { symbol: "!", color: "warning" },
 } satisfies { readonly [Status in SubagentPresentationStatus]: SubagentStatusPresentation };
 
 function coordinatorMessageText(content: RenderableCoordinatorMessage["content"]): string {
@@ -96,11 +98,21 @@ function toolResultText(result: AgentToolResult<unknown>): string {
   return text?.type === "text" ? text.text : "";
 }
 
+/** Shared unavailable → running → latest-turn → idle status ladder for one subagent. */
+export function subagentStatusLadder(agent: {
+  readonly availability?: string;
+  readonly state?: string;
+  readonly latest_turn?: { readonly status?: string };
+}): string {
+  if (agent.availability === "unavailable") return "unavailable";
+  if (agent.state === "running") return "running";
+  return agent.latest_turn?.status ?? "idle";
+}
+
 function subagentStatusPresentation(status: string): SubagentStatusPresentation {
-  for (const [knownStatus, presentation] of Object.entries(SUBAGENT_STATUS_PRESENTATION)) {
-    if (knownStatus === status) return presentation;
-  }
-  return SUBAGENT_STATUS_PRESENTATION.idle;
+  // SAFETY: unknown statuses fall back to the idle presentation below.
+  const known = status as keyof typeof SUBAGENT_STATUS_PRESENTATION;
+  return SUBAGENT_STATUS_PRESENTATION[known] ?? SUBAGENT_STATUS_PRESENTATION.idle;
 }
 
 /** Render the shared semantic symbol and color for one subagent status. */
@@ -338,10 +350,19 @@ function renderWaitResult(
     ? "waiting"
     : details.event === "message"
       ? "message"
-      : details.status;
-  const duration = formatSubagentDuration(details.elapsed_ms);
-  const tokens = formatSubagentTokenCount(details.usage?.totalTokens);
-  const drainedMessageCount = details.event === "message" ? 0 : (details.messages?.length ?? 0);
+      : details.event === "timeout"
+        ? "timed out"
+        : details.status;
+  const duration = formatSubagentDuration(
+    details.event === "timeout" ? details.timeout_ms : details.elapsed_ms,
+  );
+  const tokens = formatSubagentTokenCount(
+    details.event === "timeout" ? undefined : details.usage?.totalTokens,
+  );
+  const drainedMessageCount =
+    details.event === "message" || details.event === "timeout"
+      ? 0
+      : (details.messages?.length ?? 0);
   const metrics = [
     duration,
     tokens ? `${tokens} tokens` : undefined,
@@ -359,6 +380,15 @@ function renderWaitResult(
     container.addChild(renderLabelValue(theme, "Message ID", details.message_id));
     return container;
   }
+  if (details.event === "timeout") {
+    appendComponentSection(
+      container,
+      theme,
+      "Child status",
+      renderDetailedStatusAgent(details.agent, options, theme),
+    );
+    return container;
+  }
   if (details.messages && details.messages.length > 0) {
     appendTextSection(
       container,
@@ -402,9 +432,7 @@ function countDirectStatusAgents(agents: readonly RenderStatusAgent[]): DirectSt
 }
 
 function statusAgentPresentation(agent: RenderStatusAgent): string {
-  if (agent.availability === "unavailable") return "unavailable";
-  if (agent.state === "running") return "running";
-  return agent.latest_turn?.status ?? "idle";
+  return subagentStatusLadder(agent);
 }
 
 function renderDirectStatusRows(
@@ -484,6 +512,20 @@ function renderDetailedStatusAgent(
   if (agent.unavailable_reason) {
     appendTextSection(container, theme, "Unavailable reason", agent.unavailable_reason);
   }
+  const recentActivity = agent.recent_activity ?? [];
+  if (recentActivity.length > 0) {
+    appendTextSection(
+      container,
+      theme,
+      "Recent activity",
+      recentActivity
+        .map(
+          (activity) =>
+            `${activity.label}${activity.truncated ? " (truncated)" : ""}\n${activity.content}`,
+        )
+        .join("\n\n"),
+    );
+  }
   const recentMessages = agent.recent_messages ?? [];
   if (recentMessages.length > 0) {
     appendTextSection(
@@ -577,7 +619,7 @@ function renderDeleteResult(
   const status = details.failures.length > 0 ? "failed" : "completed";
   const metrics = [
     `${details.deleted_agent_ids.length} agents deleted`,
-    `${details.tombstoned_agent_ids.length} tombstoned`,
+    `${details.deleted_agent_ids.length} tombstones`,
     details.failures.length > 0 ? `${details.failures.length} failed` : undefined,
   ].filter((metric): metric is string => metric !== undefined);
   const summary = renderSubagentSummary(theme, status, details.agent_id, metrics);
@@ -594,12 +636,6 @@ function renderDeleteResult(
     "Deleted agents",
     details.deleted_agent_ids.join("\n") || "(none)",
   );
-  appendTextSection(
-    container,
-    theme,
-    "Tombstones",
-    details.tombstoned_agent_ids.join("\n") || "(none)",
-  );
   appendTextSection(
     container,
     theme,

package/src/minimal-subagents-sessions.ts

@@ -131,11 +131,35 @@ export function buildDepthBoundSubagentPrompt(
   });
 }
 
-function canonicalPath(path: string): string {
+/** Canonicalize one path, resolving symlinks only when the target exists. */
+export function canonicalPath(path: string): string {
   const absolutePath = resolve(path);
   return existsSync(absolutePath) ? realpathSync(absolutePath) : absolutePath;
 }
 
+/** Build the shared unavailable-agent projection used by fork recovery and ownership binding. */
+export function unavailableAgent(
+  agent: PersistedAgent,
+  error: string,
+  latestActivityAt?: string,
+): PersistedAgent {
+  // SAFETY: the spread preserves every required PersistedAgent field; only optional session fields are cleared.
+  const unavailable = {
+    ...structuredClone(agent),
+    session_file: undefined,
+    session_id: undefined,
+    session_leaf_id: undefined,
+    clone_error: error,
+    active_turn_id: undefined,
+    active_turn_started_at: undefined,
+    availability: "unavailable",
+    missing_dependencies: [error],
+    unavailable_reason: error,
+  } as PersistedAgent;
+  if (latestActivityAt !== undefined) unavailable.latest_activity_at = latestActivityAt;
+  return unavailable;
+}
+
 function appendImportedMessage(sessionManager: SessionManager, message: AgentMessage): void {
   if (message.role === "compactionSummary") {
     sessionManager.appendCustomMessageEntry(
@@ -439,54 +463,40 @@ function assistantText(message: AgentMessage | undefined): string {
     .join("\n");
 }
 
-/** Collects finalized turn messages without relying on mutable post-compaction session state. */
-export class ChildTurnOutcomeCollector {
-  private readonly messages: AgentMessage[] = [];
-  private readonly unsubscribe: () => void;
-
-  constructor(session: Pick<AgentSession, "subscribe">) {
-    this.unsubscribe = session.subscribe((event: AgentSessionEvent) => {
-      if (event.type === "message_end") this.messages.push(event.message);
-    });
+/** Collect finalized turn messages and reduce them to one runtime outcome. */
+function collectChildTurnOutcome(
+  messages: readonly AgentMessage[],
+  aborted: boolean,
+): RuntimeTurnOutcome {
+  const finalAssistant = [...messages].reverse().find((message) => message.role === "assistant");
+  if (!finalAssistant || finalAssistant.role !== "assistant") {
+    return {
+      status: aborted ? "cancelled" : "failed",
+      output: "",
+      error: "No terminal assistant response",
+    };
   }
-
-  dispose(): void {
-    this.unsubscribe();
+  if (finalAssistant.stopReason === "aborted") {
+    return {
+      status: "cancelled",
+      output: assistantText(finalAssistant),
+      error: finalAssistant.errorMessage,
+      usage: sumUsage(messages),
+    };
   }
-
-  toOutcome(aborted: boolean): RuntimeTurnOutcome {
-    const finalAssistant = [...this.messages]
-      .reverse()
-      .find((message) => message.role === "assistant");
-    if (!finalAssistant || finalAssistant.role !== "assistant") {
-      return {
-        status: aborted ? "cancelled" : "failed",
-        output: "",
-        error: "No terminal assistant response",
-      };
-    }
-    if (finalAssistant.stopReason === "aborted") {
-      return {
-        status: "cancelled",
-        output: assistantText(finalAssistant),
-        error: finalAssistant.errorMessage,
-        usage: sumUsage(this.messages),
-      };
-    }
-    if (finalAssistant.stopReason === "error") {
-      return {
-        status: "failed",
-        output: assistantText(finalAssistant),
-        error: finalAssistant.errorMessage ?? "Provider request failed",
-        usage: sumUsage(this.messages),
-      };
-    }
+  if (finalAssistant.stopReason === "error") {
     return {
-      status: "completed",
+      status: "failed",
       output: assistantText(finalAssistant),
-      usage: sumUsage(this.messages),
+      error: finalAssistant.errorMessage ?? "Provider request failed",
+      usage: sumUsage(messages),
     };
   }
+  return {
+    status: "completed",
+    output: assistantText(finalAssistant),
+    usage: sumUsage(messages),
+  };
 }
 
 /** Run one child operation while retaining its finalized outcome across compaction. */
@@ -495,10 +505,13 @@ export async function captureChildTurnOutcome(
   operation: () => Promise<void>,
   isAborted: () => boolean,
 ): Promise<RuntimeTurnOutcome> {
-  const collector = new ChildTurnOutcomeCollector(session);
+  const messages: AgentMessage[] = [];
+  const unsubscribe = session.subscribe((event: AgentSessionEvent) => {
+    if (event.type === "message_end") messages.push(event.message);
+  });
   try {
     await operation();
-    return collector.toOutcome(isAborted());
+    return collectChildTurnOutcome(messages, isAborted());
   } catch (error) {
     return {
       status: isAborted() ? "cancelled" : "failed",
@@ -506,7 +519,7 @@ export async function captureChildTurnOutcome(
       error: error instanceof Error ? error.message : String(error),
     };
   } finally {
-    collector.dispose();
+    unsubscribe();
   }
 }
 
@@ -520,6 +533,8 @@ class PiChildAgentRuntime implements ChildAgentRuntime {
     private readonly modelById: ReadonlyMap<string, Model<any>>,
     onSessionActivity?: () => void,
   ) {
+    // Keep this child-only; AgentSession.setSteeringMode would overwrite the user's global setting.
+    session.agent.steeringMode = "all";
     this.unsubscribe = session.subscribe((event) => {
       if (event.type !== "entry_appended") return;
       if (
@@ -598,6 +613,11 @@ class PiChildAgentRuntime implements ChildAgentRuntime {
     return snapshotCommittedContext(this.session.messages, this.session.isStreaming);
   }
 
+  snapshotActivityMessages(): AgentMessage[] {
+    const streamingMessage = this.session.state.streamingMessage;
+    return [...this.session.messages, ...(streamingMessage ? [streamingMessage] : [])];
+  }
+
   hasDeliveryEvidence(sourceAgentId: string, sourceTurnId: string, deliveryId?: string): boolean {
     return findDeliveryEvidence(
       this.session.sessionManager.getBranch(),

package/src/minimal-subagents-tools.ts

@@ -202,7 +202,7 @@ export function createCoordinatorToolDefinitions(
     name: "subagent_wait",
     label: "Subagent Wait",
     description:
-      "Wait for one direct child's oldest observable turn, or select an exact retained turn_id. An active child may first return event=message; later unconsumed items still fall back automatically. An already settled turn returns event=turn once with queued messages in messages. Timeout never cancels the child.",
+      "Wait for one direct child's oldest observable turn, or select an exact retained turn_id. An active child may first return event=message; later unconsumed items still fall back automatically. An already settled turn returns event=turn once with queued messages in messages. Timeout returns event=timeout with detailed child status and never cancels the child.",
     promptSnippet: "Wait for one direct child's exact turn",
     parameters: options.schemas.subagent_wait,
     async execute(_toolCallId, parameters, signal, onUpdate) {
@@ -248,7 +248,7 @@ export function createCoordinatorToolDefinitions(
     name: "subagent_status",
     label: "Subagent Status",
     description:
-      "List direct children when agent_id is omitted, or inspect one direct child's launch contract, result, usage, and dependencies.",
+      "List direct children when agent_id is omitted, or inspect one direct child's launch contract, result, usage, dependencies, and bounded recent activity including message text and reasoning.",
     promptSnippet: "Inspect direct child state",
     parameters: options.schemas.subagent_status,
     async execute(_toolCallId, parameters) {