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

package/README.md

@@ -141,22 +141,24 @@ the complete read-only discovery bundle.
 `agent_message` reports whether a message was delivered through an active
 parent wait, queued for the recipient, or failed. `subagent_wait` can return an
 intermediate Wait Event containing a Coordination Message before the child turn
-settles; call it again for the terminal turn result. Pass optional `turn_id` to
-address an older retained turn exactly. Without it, waits select the oldest
-observable claimed or pending turn before the active/latest turn. A caller may
-have only one outstanding wait for the same source turn; a concurrent duplicate
-is rejected instead of competing for one Wait Event.
+settles. That event claims only its message, so later unconsumed messages and the
+terminal result retain automatic fallback. If the turn has already settled, one
+wait returns its terminal result with queued messages in `messages`. Pass
+optional `turn_id` to address an older retained turn exactly. Without it, waits
+select the oldest observable claimed or pending turn before the active/latest
+turn. A caller may have only one outstanding wait for the same source turn; a
+concurrent duplicate is rejected instead of competing for one Wait Event.
 
 The persisted Delivery Ledger records Coordination Messages, terminal results,
 globally increasing sequence, and wait ownership before delivery. Existing
 items retain their sequence; gaps from skipped malformed records are valid.
-Claims can name only active, latest, or retained turns. Once a wait returns an
-intermediate message, that wait path owns the rest of the source turn across
-reloads, forks, and newer turns. Automatic fallback retains its ordered queue
-reservation, treats idle notifications as advisory, and rechecks actual
-recipient idleness before injecting a message. Destination-session Delivery
-Evidence settles and compacts ledger items, preventing duplicate delivery and
-unbounded checkpoint growth. The pure Delivery Ledger state machine retains at
+Claims can name only active, latest, or retained turns. Wait-returned messages
+retain individual delivery evidence; terminal wait ownership remains durable
+across reloads, forks, and newer turns. Automatic fallback retains its ordered
+queue reservation and sends every unclaimed Coordination Message and terminal
+result as a Pi steer, including while the recipient is active. Destination-session
+Delivery Evidence settles and compacts ledger items, preventing duplicate delivery
+and unbounded checkpoint growth. The pure Delivery Ledger state machine retains at
 most 20 pending wait-only terminal results per source agent; Coordination
 Messages are not removed by that terminal-retention limit. Delivered messages
 include stable delivery, source-agent, and source-turn identities in persisted

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ian-pascoe/pi-minimal-subagents",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "private": false,
   "description": "Persistent nested subagents with bounded delegation for Pi",
   "keywords": [

package/src/minimal-subagents-capabilities.ts

@@ -36,18 +36,7 @@ export function buildEligibleModelIds(input: {
   const source = scopeConfigured
     ? input.scopedModels.map((entry) => entry.model)
     : input.availableModels;
-  const seen = new Set<string>();
-  const result: string[] = [];
-
-  for (const model of source) {
-    const canonicalId = `${model.provider}/${model.id}`;
-    if (!seen.has(canonicalId)) {
-      seen.add(canonicalId);
-      result.push(canonicalId);
-    }
-  }
-
-  return result;
+  return [...new Set(source.map(({ provider, id }) => `${provider}/${id}`))];
 }
 
 /** Supplies inherited tools, the ancestor ceiling, and runtime availability for exact tool resolution. */

package/src/minimal-subagents-config.ts

@@ -51,8 +51,8 @@ interface MinimalSubagentsSettingsDocument {
 }
 
 interface MinimalSubagentsConfigInput {
-  globalSettings: MinimalSubagentsSettingsDocument;
-  projectSettings: MinimalSubagentsSettingsDocument;
+  globalSettings: MinimalSubagentsSettingsDocumentInput;
+  projectSettings: MinimalSubagentsSettingsDocumentInput;
   eligibleModelIds: readonly string[];
 }
 
@@ -126,19 +126,8 @@ function parseModelRolesWireValue(value: JsonValue): ModelRolesWireValue {
   };
 }
 
-function parsePiSettingsDocument(
-  settings: MinimalSubagentsSettingsDocumentInput,
-): MinimalSubagentsSettingsDocument {
-  if (!Value.Check(SettingsDocumentSchema, settings)) return {};
-  const parsed: MinimalSubagentsSettingsDocument = {};
-  if (settings.minimalSubagents !== undefined) {
-    parsed.minimalSubagents = settings.minimalSubagents;
-  }
-  return parsed;
-}
-
 function readMinimalSubagentsSettings(
-  settings: MinimalSubagentsSettingsDocument,
+  settings: MinimalSubagentsSettingsDocumentInput,
   scope: SettingsScope,
   warnings: string[],
 ): ParsedMinimalSubagentsSettings {
@@ -359,8 +348,8 @@ export function resolveMinimalSubagentsSettings(
   eligibleModelIds: readonly string[],
 ): ResolvedMinimalSubagentsConfig {
   return resolveMinimalSubagentsConfig({
-    globalSettings: parsePiSettingsDocument(settings.getGlobalSettings()),
-    projectSettings: parsePiSettingsDocument(settings.getProjectSettings()),
+    globalSettings: settings.getGlobalSettings(),
+    projectSettings: settings.getProjectSettings(),
     eligibleModelIds,
   });
 }

package/src/minimal-subagents-coordinator.ts

@@ -1,5 +1,4 @@
 import { randomUUID } from "node:crypto";
-import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import { assembleImportedContext, contextContainsImages } from "./minimal-subagents-context.js";
 import {
   canAgentContractSpawn,
@@ -54,6 +53,7 @@ import type {
   StatusResult,
   TurnId,
   TurnResult,
+  WaitMessageResult,
   WaitResult,
 } from "./minimal-subagents-types.js";
 
@@ -86,11 +86,6 @@ interface PendingParentMessage {
   cancelGrace?: () => void;
 }
 
-interface CancelableWait {
-  promise: Promise<void>;
-  cancel: () => void;
-}
-
 function agentDeliveryKey(agentId: string, turnId: string): string {
   return `${agentId}\u0000${turnId}`;
 }
@@ -110,8 +105,9 @@ function terminalTurnResult(
   };
 }
 
-function terminalWaitResult(result: TurnResult): WaitResult {
-  return { event: "turn", ...structuredClone(result) };
+function terminalWaitResult(result: TurnResult, messages: WaitMessageResult[] = []): WaitResult {
+  const terminal = { event: "turn" as const, ...structuredClone(result) };
+  return messages.length === 0 ? terminal : { ...terminal, messages: structuredClone(messages) };
 }
 
 /** One root-owned coordinator for persistent nested Pi child sessions. */
@@ -119,18 +115,15 @@ export class MinimalSubagentsCoordinator {
   private readonly agents = new Map<string, PersistedAgent>();
   private readonly runtimes = new Map<string, ChildAgentRuntime>();
   private readonly runtimeInitializations = new Map<string, Promise<ChildAgentRuntime>>();
-  private readonly importedMessages = new Map<string, AgentMessage[]>();
   private readonly tombstones = new Set<string>();
   private readonly pendingAgentIds = new Set<string>();
   private deliveryLedger: DeliveryLedger = createDeliveryLedger();
   private readonly waiters = new Map<string, Set<TurnWaiter>>();
   private readonly pendingParentMessages = new Map<string, PendingParentMessage[]>();
   private readonly recipientQueues = new Map<string, Promise<unknown>>();
-  private readonly recipientIdleWaiters = new Map<string, Set<() => void>>();
   private readonly automaticDeliveryKeys = new Set<string>();
   private readonly automaticCoordinationDeliveryIds = new Set<string>();
   private readonly waitHandedDeliveryIds = new Set<string>();
-  private readonly automaticDeliveryClaimWaiters = new Map<string, Set<() => void>>();
   private readonly backgroundOperations = new Set<Promise<void>>();
   private acceptingOperations = true;
   private lifecycleEpoch = 0;
@@ -252,7 +245,6 @@ export class MinimalSubagentsCoordinator {
     agent.session_id = identity.sessionId;
     agent.session_leaf_id = identity.sessionLeafId;
     this.agents.set(agentId, agent);
-    this.importedMessages.set(agentId, imported.messages);
     this.dependencies.registry.append(
       createRegistryEvent(this.dependencies.registry.rootSessionId, "agent-created", { agent }),
     );
@@ -366,15 +358,16 @@ export class MinimalSubagentsCoordinator {
         new Error(`Minimal subagents duplicate wait: ${callerId} is already waiting for ${turnId}`),
       );
     }
-    const pendingMessage = this.claimPendingParentMessage(callerId, agentId, turnId);
-    if (pendingMessage) return Promise.resolve(pendingMessage);
     const retainedResult =
       findTerminalDelivery(this.deliveryLedger, agentId, turnId)?.result ??
       (agent.latest_result?.turn_id === turnId ? agent.latest_result : undefined);
     if (retainedResult) {
+      const messages = this.drainPendingParentMessages(callerId, agentId, turnId);
       this.claimTerminalDelivery(callerId, retainedResult);
-      return Promise.resolve(terminalWaitResult(retainedResult));
+      return Promise.resolve(terminalWaitResult(retainedResult, messages));
     }
+    const pendingMessage = this.claimPendingParentMessage(callerId, agentId, turnId);
+    if (pendingMessage) return Promise.resolve(pendingMessage);
     if (agent.active_turn_id !== turnId) {
       return Promise.reject(
         new Error(`Minimal subagents wait: turn ${turnId} is no longer retained for ${agentId}`),
@@ -505,7 +498,6 @@ export class MinimalSubagentsCoordinator {
           result.trashed_session_files.push(agent.session_file);
         }
         this.agents.delete(agent.agent_id);
-        this.importedMessages.delete(agent.agent_id);
         this.pruneDeliveryStateForDeletedAgent(agent.agent_id);
         this.pruneRecentMessageProjectionsForDeletedAgent(agent.agent_id);
         this.tombstones.add(agent.agent_id);
@@ -520,10 +512,7 @@ export class MinimalSubagentsCoordinator {
         failedAncestors.add(agent.agent_id);
         if (runtime && agent.session_file) {
           try {
-            this.runtimes.set(
-              agent.agent_id,
-              await this.dependencies.sessions.restoreRuntime(agent),
-            );
+            this.runtimes.set(agent.agent_id, await this.dependencies.sessions.openRuntime(agent));
           } catch (restoreError) {
             agent.availability = "unavailable";
             agent.unavailable_reason = `Deletion recovery failed: ${
@@ -550,7 +539,6 @@ export class MinimalSubagentsCoordinator {
     this.agents.clear();
     this.deliveryLedger = createDeliveryLedger();
     this.pendingParentMessages.clear();
-    this.releaseAllRecipientIdleWaiters();
     this.recipientQueues.clear();
     this.backgroundOperations.clear();
     await Promise.allSettled(
@@ -559,19 +547,16 @@ export class MinimalSubagentsCoordinator {
     for (const runtime of abandonedRuntimes) runtime.dispose();
     this.runtimes.clear();
     this.runtimeInitializations.clear();
-    this.importedMessages.clear();
     this.pendingAgentIds.clear();
     this.tombstones.clear();
     this.deliveryLedger = createDeliveryLedger();
     this.waiters.clear();
     this.pendingParentMessages.clear();
     this.waitHandedDeliveryIds.clear();
-    this.releaseAllRecipientIdleWaiters();
     this.recipientQueues.clear();
     this.backgroundOperations.clear();
     this.automaticDeliveryKeys.clear();
     this.automaticCoordinationDeliveryIds.clear();
-    this.automaticDeliveryClaimWaiters.clear();
     this.deliveryLedger = createDeliveryLedger({
       deliveries: snapshot.deliveries,
       coordination_deliveries: snapshot.coordination_deliveries,
@@ -623,7 +608,7 @@ export class MinimalSubagentsCoordinator {
           });
           continue;
         }
-        const runtime = await this.dependencies.sessions.restoreRuntime(agent);
+        const runtime = await this.dependencies.sessions.openRuntime(agent);
         if (restoreEpoch !== this.lifecycleEpoch) {
           runtime.dispose();
           return;
@@ -728,13 +713,6 @@ export class MinimalSubagentsCoordinator {
     await Promise.allSettled(scheduled);
   }
 
-  /** Release ordered automatic deliveries after one recipient conversation becomes idle. */
-  markRecipientIdle(agentId: string): void {
-    const waiters = this.recipientIdleWaiters.get(agentId);
-    this.recipientIdleWaiters.delete(agentId);
-    for (const resolve of waiters ?? []) resolve();
-  }
-
   /** Clone complete child leaves for root fork ownership without ever sharing source session paths. */
   async prepareFork(sourceRootSessionFile: string): Promise<ForkSnapshot> {
     const activeRootChildren = this.childrenOf("root");
@@ -793,7 +771,6 @@ export class MinimalSubagentsCoordinator {
   shutdown(): Promise<void> {
     if (this.shutdownPromise) return this.shutdownPromise;
     this.acceptingOperations = false;
-    this.releaseAllRecipientIdleWaiters();
     this.shutdownPromise = this.finishShutdown();
     return this.shutdownPromise;
   }
@@ -902,19 +879,14 @@ export class MinimalSubagentsCoordinator {
         new Error(agent.clone_error ?? `No persistent session exists for ${agent.agent_id}`),
       );
     }
-    const importedMessages = this.importedMessages.get(agent.agent_id);
-    const initialization = (
-      importedMessages
-        ? this.dependencies.sessions.createRuntime({ agent, importedMessages })
-        : this.dependencies.sessions.restoreRuntime(agent)
-    )
+    const initialization = this.dependencies.sessions
+      .openRuntime(agent)
       .then((runtime) => {
         if (this.agents.get(agent.agent_id) !== agent) {
           runtime.dispose();
           throw new Error(`Minimal subagents runtime replaced while opening ${agent.agent_id}`);
         }
         this.runtimes.set(agent.agent_id, runtime);
-        this.importedMessages.delete(agent.agent_id);
         return runtime;
       })
       .finally(() => {
@@ -1012,7 +984,6 @@ export class MinimalSubagentsCoordinator {
       });
     }
     if (result.status !== "completed") this.removeSettledEmptyTurnClaim(agent.agent_id, turnId);
-    this.markRecipientIdle(agent.agent_id);
   }
 
   private async deliverAutomaticResult(
@@ -1037,15 +1008,6 @@ export class MinimalSubagentsCoordinator {
           this.settleDelivery(delivery);
           return;
         }
-        while (!this.isRecipientIdle(delivery.destination_agent_id)) {
-          const idleWait = this.createRecipientIdleWait(delivery.destination_agent_id);
-          const claimWait = this.createAutomaticDeliveryClaimWait(deliveryKey);
-          await Promise.race([idleWait.promise, claimWait.promise]);
-          idleWait.cancel();
-          claimWait.cancel();
-          if (!this.acceptingOperations || this.shouldStopAutomaticTerminalDelivery(delivery))
-            return;
-        }
         if (!this.acceptingOperations || this.shouldStopAutomaticTerminalDelivery(delivery)) return;
         if (this.hasDeliveryEvidence(delivery)) {
           this.settleDelivery(delivery);
@@ -1064,11 +1026,8 @@ export class MinimalSubagentsCoordinator {
             usage: result.usage,
           },
         };
-        await this.deliverToRecipient(
-          delivery.destination_agent_id,
-          message,
-          () => this.isTerminalDeliveryCurrent(delivery),
-          true,
+        await this.deliverToRecipient(delivery.destination_agent_id, message, () =>
+          this.isTerminalDeliveryCurrent(delivery),
         );
       });
     } catch (error) {
@@ -1276,7 +1235,6 @@ export class MinimalSubagentsCoordinator {
     targetId: string,
     message: CoordinatorMessage,
     isCurrentDelivery: () => boolean = () => true,
-    requireIdleRecipient = false,
   ): Promise<void> {
     if (!isCurrentDelivery()) {
       throw new Error("Minimal subagents delivery abandoned after session branch change");
@@ -1294,9 +1252,6 @@ export class MinimalSubagentsCoordinator {
       throw new Error("Minimal subagents delivery abandoned after session branch change");
     }
     const visibleMessage = addCoordinatorMessageEnvelope(message);
-    if (requireIdleRecipient && (target.active_turn_id || runtime.isRunning)) {
-      throw new Error(`Minimal subagents automatic delivery recipient became active: ${targetId}`);
-    }
     if (target.active_turn_id || runtime.isRunning) {
       await runtime.queueCoordinatorMessage(visibleMessage);
       return;
@@ -1380,8 +1335,6 @@ export class MinimalSubagentsCoordinator {
   private applyDeliveryLedgerTransition(transition: DeliveryLedgerTransition): void {
     this.deliveryLedger = transition.ledger;
     for (const delivery of transition.prunedTerminalDeliveries) {
-      const key = agentDeliveryKey(delivery.source_agent_id, delivery.source_turn_id);
-      this.releaseAutomaticDeliveryClaimWaiters(key);
       this.dependencies.registry.append(
         createRegistryEvent(this.dependencies.registry.rootSessionId, "delivery-pruned", {
           source_agent_id: delivery.source_agent_id,
@@ -1517,16 +1470,8 @@ export class MinimalSubagentsCoordinator {
   }
 
   private pruneDeliveryStateForDeletedAgent(agentId: string): void {
-    const previousTerminalDeliveries = this.deliveryLedger.terminalDeliveries;
     const previousCoordinationDeliveries = this.deliveryLedger.coordinationDeliveries;
     this.deliveryLedger = pruneDeliveryLedgerAgents(this.deliveryLedger, [agentId]).ledger;
-    for (const delivery of previousTerminalDeliveries) {
-      if (!this.isTerminalDeliveryCurrent(delivery)) {
-        this.releaseAutomaticDeliveryClaimWaiters(
-          agentDeliveryKey(delivery.source_agent_id, delivery.source_turn_id),
-        );
-      }
-    }
     for (const delivery of previousCoordinationDeliveries) {
       if (!this.isCoordinationDeliveryCurrent(delivery)) {
         this.waitHandedDeliveryIds.delete(delivery.delivery_id);
@@ -1686,7 +1631,6 @@ export class MinimalSubagentsCoordinator {
       (candidate) => candidate.callerId === destinationAgentId,
     );
     if (!waiter) return false;
-    this.claimDeliveryTurn(message.details.source_agent_id, message.details.source_turn_id);
     this.deliveryLedger = setCoordinationDeliveryPath(
       this.deliveryLedger,
       delivery.delivery_id,
@@ -1711,7 +1655,7 @@ export class MinimalSubagentsCoordinator {
     callerId: string,
     sourceAgentId: string,
     sourceTurnId: string,
-  ): WaitResult | undefined {
+  ): WaitMessageResult | undefined {
     const key = agentDeliveryKey(sourceAgentId, sourceTurnId);
     const pendingMessages = this.pendingParentMessages.get(key);
     const index = pendingMessages?.findIndex(
@@ -1728,7 +1672,6 @@ export class MinimalSubagentsCoordinator {
         )
         .sort((left, right) => left.sequence - right.sequence)[0];
       if (!retained) return undefined;
-      this.claimDeliveryTurn(sourceAgentId, sourceTurnId);
       this.deliveryLedger = setCoordinationDeliveryPath(
         this.deliveryLedger,
         retained.delivery_id,
@@ -1748,7 +1691,6 @@ export class MinimalSubagentsCoordinator {
     }
     const pending = pendingMessages[index];
     if (!pending) return undefined;
-    this.claimDeliveryTurn(sourceAgentId, sourceTurnId);
     const delivery = findCoordinationDelivery(this.deliveryLedger, pending.deliveryId);
     if (delivery) {
       this.deliveryLedger = setCoordinationDeliveryPath(
@@ -1760,10 +1702,6 @@ export class MinimalSubagentsCoordinator {
       if (currentDelivery) this.persistCoordinationDeliveryState(currentDelivery);
       this.waitHandedDeliveryIds.add(delivery.delivery_id);
     }
-    const sourceResult = this.agents.get(sourceAgentId)?.latest_result;
-    if (sourceResult?.turn_id === sourceTurnId) {
-      this.setTerminalDeliveryPathToWait(callerId, sourceResult);
-    }
     pending.claimed = true;
     pending.cancelGrace?.();
     pending.releaseClaim();
@@ -1779,6 +1717,20 @@ export class MinimalSubagentsCoordinator {
     };
   }
 
+  private drainPendingParentMessages(
+    callerId: string,
+    sourceAgentId: string,
+    sourceTurnId: string,
+  ): WaitMessageResult[] {
+    const messages: WaitMessageResult[] = [];
+    let message = this.claimPendingParentMessage(callerId, sourceAgentId, sourceTurnId);
+    while (message) {
+      messages.push(message);
+      message = this.claimPendingParentMessage(callerId, sourceAgentId, sourceTurnId);
+    }
+    return messages;
+  }
+
   private queuePendingParentMessage(
     targetId: string,
     message: CoordinatorMessage,
@@ -1791,10 +1743,7 @@ export class MinimalSubagentsCoordinator {
         message.details.source_agent_id,
         message.details.source_turn_id,
       );
-    let releaseClaim!: () => void;
-    const claimPromise = new Promise<void>((resolve) => {
-      releaseClaim = resolve;
-    });
+    const { promise: claimPromise, resolve: releaseClaim } = Promise.withResolvers<void>();
     const pending: PendingParentMessage = {
       deliveryId: delivery.delivery_id,
       message,
@@ -1837,20 +1786,11 @@ export class MinimalSubagentsCoordinator {
       pending.cancelGrace?.();
       pending.cancelGrace = undefined;
       if (!this.acceptingOperations || pending.claimed || turnClaimed()) return;
-      while (!this.isRecipientIdle(targetId)) {
-        const idleWait = this.createRecipientIdleWait(targetId);
-        await Promise.race([pending.claimPromise, idleWait.promise]);
-        idleWait.cancel();
-        if (!this.acceptingOperations || pending.claimed || turnClaimed()) return;
-      }
       if (!this.acceptingOperations || pending.claimed || turnClaimed()) return;
       this.removePendingParentMessage(key, pending);
       this.waitHandedDeliveryIds.add(delivery.delivery_id);
-      await this.deliverToRecipient(
-        targetId,
-        message,
-        () => this.isCoordinationDeliveryCurrent(delivery),
-        true,
+      await this.deliverToRecipient(targetId, message, () =>
+        this.isCoordinationDeliveryCurrent(delivery),
       );
     });
     void operation.catch((cause) => {
@@ -1890,14 +1830,12 @@ export class MinimalSubagentsCoordinator {
   }
 
   private setTerminalDeliveryPathToWait(callerId: string, result: TurnResult): void {
-    const key = agentDeliveryKey(result.agent_id, result.turn_id);
     const delivery = findTerminalDelivery(this.deliveryLedger, result.agent_id, result.turn_id);
     if (!delivery || delivery.destination_agent_id !== callerId || delivery.path === "wait") return;
     this.applyDeliveryLedgerTransition(
       setTerminalDeliveryPath(this.deliveryLedger, result.agent_id, result.turn_id, "wait"),
     );
     const retained = findTerminalDelivery(this.deliveryLedger, result.agent_id, result.turn_id);
-    this.releaseAutomaticDeliveryClaimWaiters(key);
     if (!retained) return;
     this.dependencies.registry.append(
       createRegistryEvent(this.dependencies.registry.rootSessionId, "delivery-pending", {
@@ -1906,63 +1844,6 @@ export class MinimalSubagentsCoordinator {
     );
   }
 
-  private isRecipientIdle(agentId: string): boolean {
-    if (agentId === "root") return this.dependencies.root.isIdle();
-    const agent = this.agents.get(agentId);
-    if (!agent || agent.active_turn_id) return false;
-    return !this.runtimes.get(agentId)?.isRunning;
-  }
-
-  private createRecipientIdleWait(agentId: string): CancelableWait {
-    let release!: () => void;
-    const promise = new Promise<void>((resolve) => {
-      release = resolve;
-    });
-    const waiters = this.recipientIdleWaiters.get(agentId) ?? new Set();
-    waiters.add(release);
-    this.recipientIdleWaiters.set(agentId, waiters);
-    return {
-      promise,
-      cancel: () => {
-        const currentWaiters = this.recipientIdleWaiters.get(agentId);
-        currentWaiters?.delete(release);
-        if (currentWaiters?.size === 0) this.recipientIdleWaiters.delete(agentId);
-      },
-    };
-  }
-
-  private createAutomaticDeliveryClaimWait(deliveryKey: string): CancelableWait {
-    let release!: () => void;
-    const promise = new Promise<void>((resolve) => {
-      release = resolve;
-    });
-    const waiters = this.automaticDeliveryClaimWaiters.get(deliveryKey) ?? new Set();
-    waiters.add(release);
-    this.automaticDeliveryClaimWaiters.set(deliveryKey, waiters);
-    return {
-      promise,
-      cancel: () => {
-        const currentWaiters = this.automaticDeliveryClaimWaiters.get(deliveryKey);
-        currentWaiters?.delete(release);
-        if (currentWaiters?.size === 0) this.automaticDeliveryClaimWaiters.delete(deliveryKey);
-      },
-    };
-  }
-
-  private releaseAutomaticDeliveryClaimWaiters(deliveryKey: string): void {
-    const waiters = this.automaticDeliveryClaimWaiters.get(deliveryKey);
-    this.automaticDeliveryClaimWaiters.delete(deliveryKey);
-    for (const resolve of waiters ?? []) resolve();
-  }
-
-  private releaseAllRecipientIdleWaiters(): void {
-    const allWaiters = [...this.recipientIdleWaiters.values()];
-    this.recipientIdleWaiters.clear();
-    for (const waiters of allWaiters) {
-      for (const resolve of waiters) resolve();
-    }
-  }
-
   private async cancelDuringShutdown(agentId: string): Promise<void> {
     const target = this.agents.get(agentId);
     if (!target) return;

package/src/minimal-subagents-delivery-ledger.ts

@@ -58,23 +58,13 @@ function deliveryTurnKey(sourceAgentId: string, sourceTurnId: string): string {
   return `${sourceAgentId}\u0000${sourceTurnId}`;
 }
 
-function cloneTerminalDelivery(delivery: PersistedDelivery): PersistedDelivery {
-  return structuredClone(delivery);
-}
-
-function cloneCoordinationDelivery(
-  delivery: PersistedCoordinationDelivery,
-): PersistedCoordinationDelivery {
-  return structuredClone(delivery);
-}
-
 function createTransition(
   ledger: DeliveryLedger,
   prunedTerminalDeliveries: readonly PersistedDelivery[] = [],
 ): DeliveryLedgerTransition {
   return {
     ledger,
-    prunedTerminalDeliveries: prunedTerminalDeliveries.map(cloneTerminalDelivery),
+    prunedTerminalDeliveries: prunedTerminalDeliveries.map((delivery) => structuredClone(delivery)),
   };
 }
 
@@ -134,7 +124,7 @@ export function createDeliveryLedger(
 ): DeliveryLedger {
   const coordinationDeliveries = (snapshot.coordination_deliveries ?? [])
     .filter((delivery) => !delivery.settled)
-    .map(cloneCoordinationDelivery);
+    .map((delivery) => structuredClone(delivery));
   let nextSequence = Math.max(
     1,
     snapshot.next_delivery_sequence ?? 1,
@@ -146,7 +136,7 @@ export function createDeliveryLedger(
   const terminalDeliveries = (snapshot.deliveries ?? [])
     .filter((delivery) => !delivery.settled)
     .map((delivery) => {
-      const restored = cloneTerminalDelivery(delivery);
+      const restored = structuredClone(delivery);
       if (restored.sequence === undefined) restored.sequence = nextSequence++;
       return restored;
     });
@@ -161,8 +151,10 @@ export function createDeliveryLedger(
 /** Serialize pending Delivery Ledger state without exposing mutable internal references. */
 export function deliveryLedgerSnapshot(ledger: DeliveryLedger): DeliveryLedgerSnapshot {
   return {
-    deliveries: ledger.terminalDeliveries.map(cloneTerminalDelivery),
-    coordination_deliveries: ledger.coordinationDeliveries.map(cloneCoordinationDelivery),
+    deliveries: ledger.terminalDeliveries.map((delivery) => structuredClone(delivery)),
+    coordination_deliveries: ledger.coordinationDeliveries.map((delivery) =>
+      structuredClone(delivery),
+    ),
     wait_claimed_turns: [...ledger.waitClaimedTurns],
     next_delivery_sequence: ledger.nextSequence,
   };
@@ -194,7 +186,7 @@ export function addTerminalDelivery(
     ],
     nextSequence: ledger.nextSequence + 1,
   });
-  return { ...transition, delivery: cloneTerminalDelivery(delivery) };
+  return { ...transition, delivery: structuredClone(delivery) };
 }
 
 /** Replay or update one already-sequenced terminal delivery. */
@@ -202,7 +194,7 @@ export function upsertTerminalDelivery(
   ledger: DeliveryLedger,
   delivery: PersistedDelivery,
 ): DeliveryLedgerTransition {
-  const restored = cloneTerminalDelivery(delivery);
+  const restored = structuredClone(delivery);
   const existing = ledger.terminalDeliveries.find(
     (current) =>
       deliveryTurnKey(current.source_agent_id, current.source_turn_id) ===
@@ -251,7 +243,7 @@ export function addCoordinationDelivery(
       ],
       nextSequence: ledger.nextSequence + 1,
     },
-    delivery: cloneCoordinationDelivery(delivery),
+    delivery: structuredClone(delivery),
     prunedTerminalDeliveries: [],
   };
 }
@@ -267,7 +259,7 @@ export function upsertCoordinationDelivery(
       ...ledger.coordinationDeliveries.filter(
         (current) => current.delivery_id !== delivery.delivery_id,
       ),
-      cloneCoordinationDelivery(delivery),
+      structuredClone(delivery),
     ],
     nextSequence: Math.max(ledger.nextSequence, delivery.sequence + 1),
   });
@@ -505,7 +497,7 @@ export function findTerminalDelivery(
   const delivery = ledger.terminalDeliveries.find(
     (candidate) => deliveryTurnKey(candidate.source_agent_id, candidate.source_turn_id) === key,
   );
-  return delivery ? cloneTerminalDelivery(delivery) : undefined;
+  return delivery ? structuredClone(delivery) : undefined;
 }
 
 /** Return one pending Coordination Message by stable delivery identity. */
@@ -516,7 +508,7 @@ export function findCoordinationDelivery(
   const delivery = ledger.coordinationDeliveries.find(
     (candidate) => candidate.delivery_id === deliveryId,
   );
-  return delivery ? cloneCoordinationDelivery(delivery) : undefined;
+  return delivery ? structuredClone(delivery) : undefined;
 }
 
 /** Report whether one source turn currently has a durable wait claim. */

package/src/minimal-subagents-extension.ts

@@ -5,7 +5,6 @@ import {
   getAgentDir,
   SessionManager,
   SettingsManager,
-  type AgentSettledEvent,
   type ExtensionAPI,
   type ExtensionContext,
   type ExtensionFactory,
@@ -107,7 +106,6 @@ function createRootConversationEndpoint(
         sourceTurnId,
         deliveryId,
       ),
-    isIdle: () => context.isIdle(),
   };
 }
 
@@ -331,7 +329,6 @@ export class MinimalSubagentsLifecycleController {
     this.pi.on("session_before_fork", (event, context) => this.prepareSessionFork(event, context));
     this.pi.on("session_tree", (event, context) => this.restoreSessionTree(event, context));
     this.pi.on("message_end", (event, context) => this.reconcileMessageDelivery(event, context));
-    this.pi.on("agent_settled", (event, context) => this.releaseSettledRecipient(event, context));
     this.pi.on("session_shutdown", (event, context) => this.shutdownSession(event, context));
   }
 
@@ -554,12 +551,6 @@ export class MinimalSubagentsLifecycleController {
     }
   }
 
-  private releaseSettledRecipient(_event: AgentSettledEvent, context: ExtensionContext): void {
-    if (!this.coordinator) return;
-    if (context.isIdle()) this.coordinator.markRecipientIdle("root");
-    this.uiController?.refresh();
-  }
-
   private async shutdownSession(
     event: SessionShutdownEvent,
     context: ExtensionContext,

package/src/minimal-subagents-registry.ts

@@ -740,12 +740,6 @@ function validateRegistrySnapshot(
     }
     const identityError = validateDeliveryIdentity(delivery, version);
     if (identityError) return invalidRegistrySnapshot("invalid-delivery-identity", identityError);
-    if (!isOwnedTurnId(delivery.source_agent_id, delivery.source_turn_id)) {
-      return invalidRegistrySnapshot(
-        "invalid-delivery-identity",
-        "terminal source_turn_id must belong to source_agent_id",
-      );
-    }
     const source = agentsById.get(delivery.source_agent_id);
     if (!source) {
       return invalidRegistrySnapshot(
@@ -763,17 +757,6 @@ function validateRegistrySnapshot(
   for (const delivery of coordinationDeliveries) {
     const identityError = validateCoordinationIdentity(delivery);
     if (identityError) return invalidRegistrySnapshot("invalid-delivery-identity", identityError);
-    if (
-      !isOwnedTurnId(
-        delivery.message.details.source_agent_id,
-        delivery.message.details.source_turn_id,
-      )
-    ) {
-      return invalidRegistrySnapshot(
-        "invalid-delivery-identity",
-        "Coordination Message source_turn_id must belong to source_agent_id",
-      );
-    }
     if (
       !areAdjacentAgents(
         delivery.message.details.source_agent_id,
@@ -1228,13 +1211,7 @@ export function replayRegistryEntries(
     }
   });
 
-  let checkpointIndex = -1;
-  for (let index = parsedEvents.length - 1; index >= 0; index--) {
-    if (parsedEvents[index]?.event.event === "checkpoint") {
-      checkpointIndex = index;
-      break;
-    }
-  }
+  const checkpointIndex = parsedEvents.findLastIndex(({ event }) => event.event === "checkpoint");
   const checkpointEvent = checkpointIndex >= 0 ? parsedEvents[checkpointIndex]?.event : undefined;
   const checkpoint = checkpointEvent?.event === "checkpoint" ? checkpointEvent.snapshot : undefined;
   const agents = new Map(

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

@@ -3,7 +3,7 @@ import type {
   MessageRenderer,
   ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
-import { Type, type Static, type TSchema } from "typebox";
+import { Type, type Static } from "typebox";
 import { Value } from "typebox/value";
 
 /** Names of the six coordinator tools with custom transcript renderers. */
@@ -107,16 +107,6 @@ const ManagementCallArgumentsSchema = Type.Object({
   recursive: Type.Optional(Type.Boolean()),
 });
 
-/** Tool-call contracts keep each coordinator name correlated with its own arguments. */
-export const coordinatorToolCallSchemas = {
-  subagent: SpawnCallArgumentsSchema,
-  agent_message: MessageCallArgumentsSchema,
-  subagent_wait: WaitCallArgumentsSchema,
-  subagent_status: StatusCallArgumentsSchema,
-  subagent_cancel: ManagementCallArgumentsSchema,
-  subagent_delete: ManagementCallArgumentsSchema,
-} as const satisfies { readonly [Name in CoordinatorToolName]: TSchema };
-
 const SpawnDetailsSchema = Type.Object({
   agent_id: Type.String(),
   turn_id: Type.String(),
@@ -142,6 +132,7 @@ const WaitMessageDetailsSchema = Type.Object({
   agent_id: Type.String(),
   turn_id: Type.String(),
   message_id: Type.String(),
+  delivery_id: Type.Optional(Type.String()),
   message: Type.String(),
   elapsed_ms: Type.Optional(Type.Number()),
   usage: Type.Optional(RenderUsageSchema),
@@ -155,6 +146,7 @@ const WaitTurnDetailsSchema = Type.Object({
   error: Type.Optional(Type.String()),
   elapsed_ms: Type.Optional(Type.Number()),
   usage: Type.Optional(RenderUsageSchema),
+  messages: Type.Optional(Type.Array(WaitMessageDetailsSchema)),
 });
 const StatusDetailsSchema = Type.Union([
   Type.Object({
@@ -183,15 +175,11 @@ const DeleteDetailsSchema = Type.Object({
   ),
 });
 
-/** Result-detail contracts keep current and tolerated legacy transcript shapes explicit. */
-export const coordinatorToolResultSchemas = {
-  subagent: SpawnDetailsSchema,
-  agent_message: Type.Union([CurrentMessageDetailsSchema, LegacyMessageDetailsSchema]),
-  subagent_wait: Type.Union([WaitMessageDetailsSchema, WaitTurnDetailsSchema]),
-  subagent_status: StatusDetailsSchema,
-  subagent_cancel: CancelDetailsSchema,
-  subagent_delete: DeleteDetailsSchema,
-} as const satisfies { readonly [Name in CoordinatorToolName]: TSchema };
+const MessageRenderDetailsSchema = Type.Union([
+  CurrentMessageDetailsSchema,
+  LegacyMessageDetailsSchema,
+]);
+const WaitRenderDetailsSchema = Type.Union([WaitMessageDetailsSchema, WaitTurnDetailsSchema]);
 
 export type SpawnCallArguments = Static<typeof SpawnCallArgumentsSchema>;
 export type MessageCallArguments = Static<typeof MessageCallArgumentsSchema>;
@@ -199,12 +187,8 @@ export type WaitCallArguments = Static<typeof WaitCallArgumentsSchema>;
 export type StatusCallArguments = Static<typeof StatusCallArgumentsSchema>;
 export type ManagementCallArguments = Static<typeof ManagementCallArgumentsSchema>;
 export type SpawnRenderDetails = Static<typeof SpawnDetailsSchema>;
-export type MessageRenderDetails = Static<
-  typeof CurrentMessageDetailsSchema | typeof LegacyMessageDetailsSchema
->;
-export type WaitRenderDetails = Static<
-  typeof WaitMessageDetailsSchema | typeof WaitTurnDetailsSchema
->;
+export type MessageRenderDetails = Static<typeof MessageRenderDetailsSchema>;
+export type WaitRenderDetails = Static<typeof WaitRenderDetailsSchema>;
 export type StatusRenderDetails = Static<typeof StatusDetailsSchema>;
 export type CancelRenderDetails = Static<typeof CancelDetailsSchema>;
 export type DeleteRenderDetails = Static<typeof DeleteDetailsSchema>;
@@ -263,13 +247,9 @@ export function parseCoordinatorToolResult(
     case "subagent":
       return Value.Check(SpawnDetailsSchema, details) ? { toolName, details } : undefined;
     case "agent_message":
-      return Value.Check(coordinatorToolResultSchemas.agent_message, details)
-        ? { toolName, details }
-        : undefined;
+      return Value.Check(MessageRenderDetailsSchema, details) ? { toolName, details } : undefined;
     case "subagent_wait":
-      return Value.Check(coordinatorToolResultSchemas.subagent_wait, details)
-        ? { toolName, details }
-        : undefined;
+      return Value.Check(WaitRenderDetailsSchema, details) ? { toolName, details } : undefined;
     case "subagent_status":
       return Value.Check(StatusDetailsSchema, details) ? { toolName, details } : undefined;
     case "subagent_cancel":

package/src/minimal-subagents-rendering.ts

@@ -34,7 +34,6 @@ import {
   type RenderStatusAgent,
   type SpawnCallArguments,
   type SpawnRenderDetails,
-  type StatusCallArguments,
   type StatusRenderDetails,
   type WaitCallArguments,
   type WaitRenderDetails,
@@ -259,59 +258,6 @@ function renderManagementToolCall(
   );
 }
 
-type CoordinatorToolCallRenderers = {
-  readonly subagent: (args: SpawnCallArguments, theme: MinimalSubagentsRenderTheme) => Component;
-  readonly agent_message: (
-    args: MessageCallArguments,
-    theme: MinimalSubagentsRenderTheme,
-  ) => Component;
-  readonly subagent_wait: (
-    args: WaitCallArguments,
-    theme: MinimalSubagentsRenderTheme,
-  ) => Component;
-  readonly subagent_status: (
-    args: StatusCallArguments,
-    theme: MinimalSubagentsRenderTheme,
-  ) => Component;
-  readonly subagent_cancel: (
-    args: ManagementCallArguments,
-    theme: MinimalSubagentsRenderTheme,
-  ) => Component;
-  readonly subagent_delete: (
-    args: ManagementCallArguments,
-    theme: MinimalSubagentsRenderTheme,
-  ) => Component;
-};
-
-const COORDINATOR_TOOL_CALL_RENDERERS = {
-  subagent: (args, theme) =>
-    new Text(
-      `${coordinatorToolCallTitle(theme, "Subagent")} ${theme.fg("accent", args.agent_id ?? "generated")}${coordinatorToolCallPreview(theme, args.task)}`,
-      0,
-      0,
-    ),
-  agent_message: (args, theme) =>
-    new Text(
-      `${coordinatorToolCallTitle(theme, "Message")} ${theme.fg("accent", args.agent_id ?? "parent")}${coordinatorToolCallPreview(theme, args.message)}`,
-      0,
-      0,
-    ),
-  subagent_wait: (args, theme) =>
-    new Text(
-      `${coordinatorToolCallTitle(theme, "Wait")} ${theme.fg("accent", args.agent_id ?? "agent")}`,
-      0,
-      0,
-    ),
-  subagent_status: (args, theme) =>
-    new Text(
-      `${coordinatorToolCallTitle(theme, "Status")} ${theme.fg("accent", args.agent_id ?? "children")}`,
-      0,
-      0,
-    ),
-  subagent_cancel: (args, theme) => renderManagementToolCall("Cancel", args, theme),
-  subagent_delete: (args, theme) => renderManagementToolCall("Delete", args, theme),
-} satisfies CoordinatorToolCallRenderers;
-
 function renderSpawnResult(
   details: SpawnRenderDetails,
   options: ToolRenderResultOptions,
@@ -395,9 +341,12 @@ function renderWaitResult(
       : details.status;
   const duration = formatSubagentDuration(details.elapsed_ms);
   const tokens = formatSubagentTokenCount(details.usage?.totalTokens);
-  const metrics = [duration, tokens ? `${tokens} tokens` : undefined].filter(
-    (metric): metric is string => metric !== undefined,
-  );
+  const drainedMessageCount = details.event === "message" ? 0 : (details.messages?.length ?? 0);
+  const metrics = [
+    duration,
+    tokens ? `${tokens} tokens` : undefined,
+    drainedMessageCount > 0 ? `${drainedMessageCount} messages` : undefined,
+  ].filter((metric): metric is string => metric !== undefined);
   const summary = renderSubagentSummary(theme, status, agentId, metrics);
   if (options.isPartial || !options.expanded) {
     return new Text(`${summary}${options.isPartial ? "" : collapsedExpansionHint(theme)}`, 0, 0);
@@ -410,6 +359,14 @@ function renderWaitResult(
     container.addChild(renderLabelValue(theme, "Message ID", details.message_id));
     return container;
   }
+  if (details.messages && details.messages.length > 0) {
+    appendTextSection(
+      container,
+      theme,
+      "Messages",
+      details.messages.map((message) => message.message).join("\n\n"),
+    );
+  }
   const output = details.output ?? "";
   if (status === "completed") {
     if (output.length > 0) {
@@ -660,51 +617,6 @@ function renderDeleteResult(
   return container;
 }
 
-type CoordinatorToolResultRenderers = {
-  readonly subagent: (
-    details: SpawnRenderDetails,
-    options: ToolRenderResultOptions,
-    theme: MinimalSubagentsRenderTheme,
-    args: SpawnCallArguments,
-  ) => Component;
-  readonly agent_message: (
-    details: MessageRenderDetails,
-    options: ToolRenderResultOptions,
-    theme: MinimalSubagentsRenderTheme,
-    args: MessageCallArguments,
-  ) => Component;
-  readonly subagent_wait: (
-    details: WaitRenderDetails,
-    options: ToolRenderResultOptions,
-    theme: MinimalSubagentsRenderTheme,
-    args: WaitCallArguments,
-  ) => Component;
-  readonly subagent_status: (
-    details: StatusRenderDetails,
-    options: ToolRenderResultOptions,
-    theme: MinimalSubagentsRenderTheme,
-  ) => Component;
-  readonly subagent_cancel: (
-    details: CancelRenderDetails,
-    options: ToolRenderResultOptions,
-    theme: MinimalSubagentsRenderTheme,
-  ) => Component;
-  readonly subagent_delete: (
-    details: DeleteRenderDetails,
-    options: ToolRenderResultOptions,
-    theme: MinimalSubagentsRenderTheme,
-  ) => Component;
-};
-
-const COORDINATOR_TOOL_RESULT_RENDERERS = {
-  subagent: renderSpawnResult,
-  agent_message: renderMessageResult,
-  subagent_wait: renderWaitResult,
-  subagent_status: renderStatusResult,
-  subagent_cancel: renderCancelResult,
-  subagent_delete: renderDeleteResult,
-} satisfies CoordinatorToolResultRenderers;
-
 /** Render one of the six coordinator tool calls with a shared native Pi grammar. */
 export function renderCoordinatorToolCall(
   toolName: CoordinatorToolName,
@@ -715,17 +627,33 @@ export function renderCoordinatorToolCall(
   if (parsed === undefined) return new Text(coordinatorToolCallTitle(theme, toolName), 0, 0);
   switch (parsed.toolName) {
     case "subagent":
-      return COORDINATOR_TOOL_CALL_RENDERERS.subagent(parsed.args, theme);
+      return new Text(
+        `${coordinatorToolCallTitle(theme, "Subagent")} ${theme.fg("accent", parsed.args.agent_id ?? "generated")}${coordinatorToolCallPreview(theme, parsed.args.task)}`,
+        0,
+        0,
+      );
     case "agent_message":
-      return COORDINATOR_TOOL_CALL_RENDERERS.agent_message(parsed.args, theme);
+      return new Text(
+        `${coordinatorToolCallTitle(theme, "Message")} ${theme.fg("accent", parsed.args.agent_id ?? "parent")}${coordinatorToolCallPreview(theme, parsed.args.message)}`,
+        0,
+        0,
+      );
     case "subagent_wait":
-      return COORDINATOR_TOOL_CALL_RENDERERS.subagent_wait(parsed.args, theme);
+      return new Text(
+        `${coordinatorToolCallTitle(theme, "Wait")} ${theme.fg("accent", parsed.args.agent_id ?? "agent")}`,
+        0,
+        0,
+      );
     case "subagent_status":
-      return COORDINATOR_TOOL_CALL_RENDERERS.subagent_status(parsed.args, theme);
+      return new Text(
+        `${coordinatorToolCallTitle(theme, "Status")} ${theme.fg("accent", parsed.args.agent_id ?? "children")}`,
+        0,
+        0,
+      );
     case "subagent_cancel":
-      return COORDINATOR_TOOL_CALL_RENDERERS.subagent_cancel(parsed.args, theme);
+      return renderManagementToolCall("Cancel", parsed.args, theme);
     case "subagent_delete":
-      return COORDINATOR_TOOL_CALL_RENDERERS.subagent_delete(parsed.args, theme);
+      return renderManagementToolCall("Delete", parsed.args, theme);
   }
 }
 
@@ -743,44 +671,32 @@ export function renderCoordinatorToolResult(
   const parsedCall = parseCoordinatorToolCall(toolName, args);
   switch (parsedResult.toolName) {
     case "subagent":
-      return COORDINATOR_TOOL_RESULT_RENDERERS.subagent(
+      return renderSpawnResult(
         parsedResult.details,
         options,
         theme,
         parsedCall?.toolName === "subagent" ? parsedCall.args : {},
       );
     case "agent_message":
-      return COORDINATOR_TOOL_RESULT_RENDERERS.agent_message(
+      return renderMessageResult(
         parsedResult.details,
         options,
         theme,
         parsedCall?.toolName === "agent_message" ? parsedCall.args : {},
       );
     case "subagent_wait":
-      return COORDINATOR_TOOL_RESULT_RENDERERS.subagent_wait(
+      return renderWaitResult(
         parsedResult.details,
         options,
         theme,
         parsedCall?.toolName === "subagent_wait" ? parsedCall.args : {},
       );
     case "subagent_status":
-      return COORDINATOR_TOOL_RESULT_RENDERERS.subagent_status(
-        parsedResult.details,
-        options,
-        theme,
-      );
+      return renderStatusResult(parsedResult.details, options, theme);
     case "subagent_cancel":
-      return COORDINATOR_TOOL_RESULT_RENDERERS.subagent_cancel(
-        parsedResult.details,
-        options,
-        theme,
-      );
+      return renderCancelResult(parsedResult.details, options, theme);
     case "subagent_delete":
-      return COORDINATOR_TOOL_RESULT_RENDERERS.subagent_delete(
-        parsedResult.details,
-        options,
-        theme,
-      );
+      return renderDeleteResult(parsedResult.details, options, theme);
   }
 }
 

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

@@ -28,6 +28,11 @@ export const ForkOwnershipRecordSchema = Type.Object({
   direct_parent_id: Type.String(),
 });
 
+const DeliveryEvidenceMessageSchema = Type.Object({
+  delivery_id: Type.Optional(Type.String()),
+  message_id: Type.Optional(Type.String()),
+});
+
 /** Parses durable custom-message and wait-tool Delivery Evidence details. */
 export const DeliveryEvidenceDetailsSchema = Type.Object({
   event: Type.Optional(Type.String()),
@@ -35,6 +40,7 @@ export const DeliveryEvidenceDetailsSchema = Type.Object({
   source_turn_id: Type.String(),
   delivery_id: Type.Optional(Type.String()),
   message_id: Type.Optional(Type.String()),
+  messages: Type.Optional(Type.Array(DeliveryEvidenceMessageSchema)),
 });
 
 export type ChildSessionIdentityRecord = Static<typeof ChildSessionIdentityRecordSchema>;

package/src/minimal-subagents-sessions.ts

@@ -53,7 +53,6 @@ import type {
   PersistedAgent,
   PersistedSessionIdentity,
   ProjectContextMode,
-  RuntimeCreationRequest,
   RuntimeProfile,
   RuntimeTurnOutcome,
 } from "./minimal-subagents-types.js";
@@ -203,12 +202,14 @@ function findLatestChildSessionRecord<TRecordSchema extends TSchema>(
   customType: string,
   schema: TRecordSchema,
 ): Static<TRecordSchema> | undefined {
-  for (let index = entries.length - 1; index >= 0; index--) {
-    const entry = entries[index];
-    if (!entry || entry.type !== "custom" || entry.customType !== customType) continue;
-    if (Value.Check(schema, entry.data)) return entry.data;
-  }
-  return undefined;
+  return entries.findLast(
+    (
+      entry,
+    ): entry is Extract<SessionEntry, { type: "custom" }> & {
+      data: Static<TRecordSchema>;
+    } =>
+      entry.type === "custom" && entry.customType === customType && Value.Check(schema, entry.data),
+  )?.data;
 }
 
 function findLatestForkGeneration(
@@ -247,18 +248,17 @@ function findCurrentForkOwnership(
   entries: ReturnType<SessionManager["getBranch"]>,
   cloneSessionId: string,
 ): ForkOwnershipRecord | undefined {
-  for (let index = entries.length - 1; index >= 0; index--) {
-    const entry = entries[index];
-    if (!entry || entry.type !== "custom" || entry.customType !== FORK_OWNERSHIP_ENTRY_TYPE)
-      continue;
-    if (
+  return entries.findLast(
+    (
+      entry,
+    ): entry is Extract<SessionEntry, { type: "custom" }> & {
+      data: ForkOwnershipRecord;
+    } =>
+      entry.type === "custom" &&
+      entry.customType === FORK_OWNERSHIP_ENTRY_TYPE &&
       Value.Check(ForkOwnershipRecordSchema, entry.data) &&
-      entry.data.clone_session_id === cloneSessionId
-    ) {
-      return entry.data;
-    }
-  }
-  return undefined;
+      entry.data.clone_session_id === cloneSessionId,
+  )?.data;
 }
 
 function verifyForkCloneProvenance(
@@ -411,7 +411,11 @@ export function findDeliveryEvidence(
       return (
         details.source_agent_id === sourceAgentId &&
         details.source_turn_id === sourceTurnId &&
-        (details.delivery_id === deliveryId || details.message_id === deliveryId)
+        (details.delivery_id === deliveryId ||
+          details.message_id === deliveryId ||
+          details.messages?.some(
+            (message) => message.delivery_id === deliveryId || message.message_id === deliveryId,
+          ))
       );
     }
     if (waitToolResult && details.event === "message") return false;
@@ -527,17 +531,6 @@ class PiChildAgentRuntime implements ChildAgentRuntime {
     });
   }
 
-  get sessionFile(): string {
-    const sessionFile = this.session.sessionFile;
-    if (!sessionFile)
-      throw new Error("Minimal subagents child runtime lost its persistent session file");
-    return sessionFile;
-  }
-
-  get sessionId(): string {
-    return this.session.sessionId;
-  }
-
   get sessionLeafId(): string | undefined {
     return this.session.sessionManager.getLeafId() ?? undefined;
   }
@@ -720,14 +713,6 @@ export class PiAgentSessionFactory implements AgentSessionFactory {
     });
   }
 
-  createRuntime(request: RuntimeCreationRequest): Promise<ChildAgentRuntime> {
-    return this.openRuntime(request.agent);
-  }
-
-  restoreRuntime(agent: PersistedAgent): Promise<ChildAgentRuntime> {
-    return this.openRuntime(agent);
-  }
-
   resolveLaunchMissingDependencies(agent: PersistedAgent): Promise<string[]> {
     return this.findMissingDependencies(agent, false);
   }
@@ -967,7 +952,8 @@ export class PiAgentSessionFactory implements AgentSessionFactory {
     return discovery;
   }
 
-  private async openRuntime(agent: PersistedAgent): Promise<ChildAgentRuntime> {
+  /** Open one verified persisted Child Agent runtime for launch or restoration. */
+  async openRuntime(agent: PersistedAgent): Promise<ChildAgentRuntime> {
     if (!agent.session_file)
       throw new Error(`Minimal subagents restore: ${agent.agent_id} has no session file`);
     const model = this.modelById.get(agent.launch_contract.model);

package/src/minimal-subagents-tools.ts

@@ -9,7 +9,6 @@ import {
   type ToolDefinition,
   type ToolRenderResultOptions,
 } from "@earendil-works/pi-coding-agent";
-import type { Static } from "typebox";
 import type { MinimalSubagentsCoordinator } from "./minimal-subagents-coordinator.js";
 import type { MinimalSubagentsModelRole } from "./minimal-subagents-config.js";
 import {
@@ -53,27 +52,6 @@ export interface CoordinatorToolDefinitionOptions {
   onAttention?: (message: string) => void;
 }
 
-/** Arguments consumed by the wait tool's narrow coordinator execution seam. */
-export type CoordinatorWaitToolParameters = Static<
-  ReturnType<typeof createCoordinatorToolSchemas>["subagent_wait"]
->;
-
-/** Forward one typed wait-tool request without requiring an unrelated Pi execution context. */
-export function executeCoordinatorWaitTool(
-  coordinator: Pick<CoordinatorToolOperations, "wait">,
-  callerId: string,
-  parameters: CoordinatorWaitToolParameters,
-  signal: AbortSignal | undefined,
-): Promise<WaitResult> {
-  return coordinator.wait(
-    callerId,
-    parameters.agent_id,
-    parameters.timeout_ms,
-    signal,
-    parameters.turn_id,
-  );
-}
-
 function buildModelRolePromptGuidelines(
   modelRoles: readonly MinimalSubagentsModelRole[],
 ): string[] | undefined {
@@ -224,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. A Wait Event containing a Coordination Message may arrive first as event=message; call again for the terminal turn result. A successful wait durably claims that turn so later messages and its terminal result return through wait without duplicate automatic delivery. 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 never cancels the child.",
     promptSnippet: "Wait for one direct child's exact turn",
     parameters: options.schemas.subagent_wait,
     async execute(_toolCallId, parameters, signal, onUpdate) {
@@ -243,11 +221,12 @@ export function createCoordinatorToolDefinitions(
       waitingInterval.unref?.();
       try {
         return await runCoordinatorToolActivity(options, async () => {
-          const result = await executeCoordinatorWaitTool(
-            options.coordinator,
+          const result = await options.coordinator.wait(
             options.callerId,
-            parameters,
+            parameters.agent_id,
+            parameters.timeout_ms,
             signal,
+            parameters.turn_id,
           );
           return {
             ...structuredToolResult(result),

package/src/minimal-subagents-types.ts

@@ -1,9 +1,6 @@
 import type { AgentMessage, ThinkingLevel } from "@earendil-works/pi-agent-core";
 import type { Usage } from "@earendil-works/pi-ai";
 
-/** Canonical path-like identity for one persistent subagent. */
-export type AgentId = string & { readonly __agentId: unique symbol };
-
 /** Stable identity for one prompt and its complete assistant/tool loop. */
 export type TurnId = string & { readonly __turnId: unique symbol };
 
@@ -78,8 +75,14 @@ export interface WaitMessageResult {
   message: string;
 }
 
+/** Reports one terminal child turn and any earlier messages drained by the same wait. */
+export interface WaitTurnResult extends TurnResult {
+  event: "turn";
+  messages?: WaitMessageResult[];
+}
+
 /** Reports one terminal child turn returned by subagent_wait. */
-export type WaitResult = WaitMessageResult | ({ event: "turn" } & TurnResult);
+export type WaitResult = WaitMessageResult | WaitTurnResult;
 
 /** Provides bounded hierarchy, usage, and best-known Runtime Profile data for one persistent agent. */
 export interface AgentSummary extends RuntimeProfile {
@@ -190,8 +193,6 @@ export interface CoordinatorMessage {
 
 /** Process-local adapter around one SDK-created Pi child session. */
 export interface ChildAgentRuntime {
-  readonly sessionFile: string;
-  readonly sessionId: string;
   readonly sessionLeafId: string | undefined;
   readonly isRunning: boolean;
   runPrompt(
@@ -219,17 +220,11 @@ export interface PersistedSessionIdentity {
   sessionLeafId?: string;
 }
 
-/** Combines a persisted agent record with first-launch imported context. */
-export interface RuntimeCreationRequest {
-  agent: PersistedAgent;
-  importedMessages: AgentMessage[];
-}
-
 /** Pi-specific session operations injected into the pure coordinator. */
 export interface AgentSessionFactory {
   createIdentity(agent: PersistedAgent, importedMessages: AgentMessage[]): PersistedSessionIdentity;
-  createRuntime(request: RuntimeCreationRequest): Promise<ChildAgentRuntime>;
-  restoreRuntime(agent: PersistedAgent): Promise<ChildAgentRuntime>;
+  /** Open one verified persisted Child Agent runtime for launch or restoration. */
+  openRuntime(agent: PersistedAgent): Promise<ChildAgentRuntime>;
   resolveLaunchMissingDependencies(agent: PersistedAgent): Promise<string[]>;
   resolveRestorationMissingDependencies(agent: PersistedAgent): Promise<string[]>;
   resolveThinkingLevel(modelId: string, requested: ThinkingLevel): ThinkingLevel;
@@ -254,8 +249,6 @@ export interface RootConversationEndpoint {
   /** Queue one typed coordinator message into the root conversation. */
   queueCoordinatorMessage(message: CoordinatorMessage): Promise<void>;
   hasDeliveryEvidence(sourceAgentId: string, sourceTurnId: string, deliveryId?: string): boolean;
-  /** Report whether automatic delivery can start a new root turn without racing an active wait. */
-  isIdle(): boolean;
 }
 
 /** Stores root-owned agent identity, launch contract, availability, and latest activity. */