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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ian-pascoe/pi-minimal-subagents",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "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,
@@ -119,7 +118,6 @@ 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();
@@ -252,7 +250,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 }),
     );
@@ -505,7 +502,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 +516,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: ${
@@ -559,7 +552,6 @@ 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();
@@ -623,7 +615,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;
@@ -902,19 +894,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(() => {
@@ -1791,10 +1778,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,
@@ -1914,10 +1898,7 @@ export class MinimalSubagentsCoordinator {
   }
 
   private createRecipientIdleWait(agentId: string): CancelableWait {
-    let release!: () => void;
-    const promise = new Promise<void>((resolve) => {
-      release = resolve;
-    });
+    const { promise, resolve: release } = Promise.withResolvers<void>();
     const waiters = this.recipientIdleWaiters.get(agentId) ?? new Set();
     waiters.add(release);
     this.recipientIdleWaiters.set(agentId, waiters);
@@ -1932,10 +1913,7 @@ export class MinimalSubagentsCoordinator {
   }
 
   private createAutomaticDeliveryClaimWait(deliveryKey: string): CancelableWait {
-    let release!: () => void;
-    const promise = new Promise<void>((resolve) => {
-      release = resolve;
-    });
+    const { promise, resolve: release } = Promise.withResolvers<void>();
     const waiters = this.automaticDeliveryClaimWaiters.get(deliveryKey) ?? new Set();
     waiters.add(release);
     this.automaticDeliveryClaimWaiters.set(deliveryKey, waiters);

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-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(),
@@ -183,15 +173,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 +185,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 +245,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,
@@ -660,51 +606,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 +616,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 +660,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-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(
@@ -527,17 +527,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 +709,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 +948,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 {
@@ -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 };
 
@@ -190,8 +187,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 +214,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;