@ian-pascoe/pi-minimal-subagents 0.7.0 → 0.7.2

package/README.md

@@ -226,8 +226,14 @@ Deleting a child first verifies its session header and persistent identity,
 then uses the optional `trash` command when available and falls back to
 unlinking its session file. Deletion prunes pending delivery state and retained
 recent-message projections sourced from the complete deleted subtree. Restore
-and clone perform the same ownership check and reopen the recorded child-session
-leaf.
+and clone perform the same ownership check against the recorded child-session
+leaf. Restoration loads metadata and validates saved sessions without starting
+child runtimes or their extension services (including MCP Servers). Status,
+saved transcripts, settled-result waits, cancellation of idle children, and
+session management do not start runtimes. A message or an undelivered child-bound
+result opens only its recipient's runtime on demand; saved Delivery Evidence
+prevents already-delivered work from reopening it. Runtime initialization errors
+are reported when that child is first needed.
 
 Registry replay and Delivery Evidence are scoped to the Root Agent's active
 session-tree branch. Registry writes use V2 records with complete field,

package/package.json

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

package/src/minimal-subagents-access.ts

@@ -126,10 +126,11 @@ export function reconcileCoordinatorToolAccess(
   activeToolNames: readonly string[],
   enabled: boolean,
 ): string[] {
-  const ordinaryToolNames = activeToolNames.filter(
-    (toolName) => !COORDINATOR_TOOL_NAME_SET.has(toolName),
+  const missing = new Set<string>(COORDINATOR_TOOL_NAMES);
+  const retained = activeToolNames.filter(
+    (toolName) => !COORDINATOR_TOOL_NAME_SET.has(toolName) || (enabled && missing.delete(toolName)),
   );
-  return enabled ? [...ordinaryToolNames, ...COORDINATOR_TOOL_NAMES] : ordinaryToolNames;
+  return enabled ? [...retained, ...missing] : retained;
 }
 
 /** Resolve branch state over settings and include read-only Coordinator Tool activation. */

package/src/minimal-subagents-coordinator.ts

@@ -655,19 +655,6 @@ export class MinimalSubagentsCoordinator {
           });
           continue;
         }
-        const runtime = await this.dependencies.sessions.openRuntime(agent);
-        if (restoreEpoch !== this.lifecycleEpoch) {
-          runtime.dispose();
-          return;
-        }
-        if (!runtime.sessionLeafId) {
-          runtime.dispose();
-          throw new Error(
-            `Minimal subagents session restoration: no selected session leaf for ${agent.agent_id}`,
-          );
-        }
-        this.runtimes.set(agent.agent_id, runtime);
-        agent.session_leaf_id = runtime.sessionLeafId;
         agent.availability = "available";
         if (previousAvailability !== "available")
           agent.latest_activity_at = this.now().toISOString();
@@ -926,6 +913,7 @@ export class MinimalSubagentsCoordinator {
         new Error(agent.clone_error ?? `No persistent session exists for ${agent.agent_id}`),
       );
     }
+    const openingForTurn = agent.active_turn_id !== undefined;
     const initialization = this.dependencies.sessions
       .openRuntime(agent)
       .then((runtime) => {
@@ -933,9 +921,29 @@ export class MinimalSubagentsCoordinator {
           runtime.dispose();
           throw new Error(`Minimal subagents runtime replaced while opening ${agent.agent_id}`);
         }
+        if (!runtime.sessionLeafId) {
+          runtime.dispose();
+          throw new Error(
+            `Minimal subagents session restoration: no selected session leaf for ${agent.agent_id}`,
+          );
+        }
         this.runtimes.set(agent.agent_id, runtime);
+        agent.session_leaf_id = runtime.sessionLeafId;
         return runtime;
       })
+      .catch((error) => {
+        if (!openingForTurn && this.agents.get(agent.agent_id) === agent) {
+          agent.availability = "unavailable";
+          agent.latest_activity_at = this.now().toISOString();
+          agent.unavailable_reason = error instanceof Error ? error.message : String(error);
+          this.dependencies.notify?.({
+            type: "unavailable",
+            agentId: agent.agent_id,
+            message: `${agent.agent_id} unavailable: ${agent.unavailable_reason}`,
+          });
+        }
+        throw error;
+      })
       .finally(() => {
         if (this.runtimeInitializations.get(agent.agent_id) === initialization) {
           this.runtimeInitializations.delete(agent.agent_id);
@@ -1307,6 +1315,7 @@ export class MinimalSubagentsCoordinator {
     }
     const target = this.requireUsableAgent(targetId, "message");
     const runtime = this.runtimes.get(targetId) ?? (await this.ensureRuntime(target));
+    this.assertAccepting();
     if (!isCurrentDelivery()) {
       throw new Error("Minimal subagents delivery abandoned after session branch change");
     }
@@ -1430,34 +1439,45 @@ export class MinimalSubagentsCoordinator {
   }
 
   private hasDeliveryEvidence(delivery: PersistedDelivery): boolean {
-    if (delivery.destination_agent_id === "root") {
-      return this.dependencies.root.hasDeliveryEvidence(
-        delivery.source_agent_id,
-        delivery.source_turn_id,
-      );
-    }
-    return (
-      this.runtimes
-        .get(delivery.destination_agent_id)
-        ?.hasDeliveryEvidence(delivery.source_agent_id, delivery.source_turn_id) ?? false
+    return this.hasRecipientDeliveryEvidence(
+      delivery.destination_agent_id,
+      delivery.source_agent_id,
+      delivery.source_turn_id,
     );
   }
 
   private hasCoordinationDeliveryEvidence(delivery: PersistedCoordinationDelivery): boolean {
-    const sourceAgentId = delivery.message.details.source_agent_id;
-    const sourceTurnId = delivery.message.details.source_turn_id;
-    if (delivery.destination_agent_id === "root") {
-      return this.dependencies.root.hasDeliveryEvidence(
-        sourceAgentId,
-        sourceTurnId,
-        delivery.delivery_id,
+    return this.hasRecipientDeliveryEvidence(
+      delivery.destination_agent_id,
+      delivery.message.details.source_agent_id,
+      delivery.message.details.source_turn_id,
+      delivery.delivery_id,
+    );
+  }
+
+  private hasRecipientDeliveryEvidence(
+    targetId: string,
+    sourceAgentId: string,
+    sourceTurnId: string,
+    deliveryId?: string,
+  ): boolean {
+    const endpoint = targetId === "root" ? this.dependencies.root : this.runtimes.get(targetId);
+    if (endpoint) return endpoint.hasDeliveryEvidence(sourceAgentId, sourceTurnId, deliveryId);
+    const agent = this.agents.get(targetId);
+    if (!agent) return false;
+    try {
+      return (
+        this.dependencies.sessions.hasDeliveryEvidence?.(
+          agent,
+          sourceAgentId,
+          sourceTurnId,
+          deliveryId,
+        ) ?? false
       );
+    } catch {
+      // Unverified sessions cannot prove delivery; runtime opening reports their failure.
+      return false;
     }
-    return (
-      this.runtimes
-        .get(delivery.destination_agent_id)
-        ?.hasDeliveryEvidence(sourceAgentId, sourceTurnId, delivery.delivery_id) ?? false
-    );
   }
 
   private settleDelivery(delivery: PersistedDelivery): void {
@@ -1518,7 +1538,9 @@ export class MinimalSubagentsCoordinator {
       capability_ceiling: [...agent.capability_ceiling],
       spawn_entry_id: agent.spawn_entry_id,
       recent_messages: structuredClone(agent.recent_messages),
-      recent_activity: buildRecentAgentActivity(runtime?.snapshotActivityMessages() ?? []),
+      recent_activity: buildRecentAgentActivity(
+        runtime?.snapshotActivityMessages() ?? this.inspectTranscript(agent.agent_id).messages,
+      ),
       latest_result: agent.latest_result ? structuredClone(agent.latest_result) : undefined,
       missing_dependencies: [...agent.missing_dependencies],
       unavailable_reason: agent.unavailable_reason,

package/src/minimal-subagents-registry.ts

@@ -157,7 +157,7 @@ export function createRegistryEvent(
       };
     }
     case "agent-created":
-      return { ...envelope, event, agent: data.agent };
+      return { ...envelope, event, agent: structuredClone(data.agent) };
     case "turn-started":
       return {
         ...envelope,

package/src/minimal-subagents-sessions.ts

@@ -826,24 +826,49 @@ export class PiAgentSessionFactory implements AgentSessionFactory {
       stat.ctimeMs,
     ]);
     if (this.savedTranscript?.key === key) return this.savedTranscript.snapshot;
+    const manager = this.readSession(agent);
+    const snapshot = selectChildAgentTranscript(
+      manager.getBranch(agent.session_leaf_id).flatMap(sessionEntryToContextMessages),
+    );
+    this.savedTranscript = { key, snapshot };
+    return snapshot;
+  }
+
+  /** Inspect durable evidence without starting child extensions or changing the saved branch. */
+  hasDeliveryEvidence(
+    agent: PersistedAgent,
+    sourceAgentId: string,
+    sourceTurnId: string,
+    deliveryId?: string,
+  ): boolean {
+    return findDeliveryEvidence(
+      this.readSession(agent).getBranch(agent.session_leaf_id),
+      sourceAgentId,
+      sourceTurnId,
+      deliveryId,
+    );
+  }
+
+  private readSession(agent: PersistedAgent): SessionManager {
+    if (!agent.session_file || !agent.session_id || !agent.session_leaf_id) {
+      throw new Error(`Child Session Position is unavailable for ${agent.agent_id}.`);
+    }
+    const sessionFile = canonicalPath(agent.session_file);
     const entries = parseSessionEntries(readFileSync(sessionFile, "utf8"));
     if (entries[0]?.type !== "session")
       throw new Error(`Invalid child session file: ${sessionFile}`);
     // SessionManager.open can migrate/rewrite files; an in-memory reader cannot write them.
     const manager = SessionManager.inMemory(this.options.cwd, undefined, entries);
     verifyChildSessionIdentity(manager, agent, this.options.rootSessionId);
-    const snapshot = selectChildAgentTranscript(
-      manager.getBranch(agent.session_leaf_id).flatMap(sessionEntryToContextMessages),
-    );
-    this.savedTranscript = { key, snapshot };
-    return snapshot;
+    return manager;
   }
 
   resolveLaunchMissingDependencies(agent: PersistedAgent): Promise<string[]> {
     return this.findMissingDependencies(agent, false);
   }
 
-  resolveRestorationMissingDependencies(agent: PersistedAgent): Promise<string[]> {
+  async resolveRestorationMissingDependencies(agent: PersistedAgent): Promise<string[]> {
+    this.readSession(agent);
     return this.findMissingDependencies(agent, this.options.modelScopeRestricted);
   }
 

package/src/minimal-subagents-types.ts

@@ -261,6 +261,13 @@ export interface AgentSessionFactory {
   openRuntime(agent: PersistedAgent): Promise<ChildAgentRuntime>;
   /** Read verified saved history independently of runtime restoration dependencies. */
   readTranscript?(agent: PersistedAgent): ChildAgentTranscriptSnapshot;
+  /** Read verified selected-branch evidence without opening a runtime. */
+  hasDeliveryEvidence?(
+    agent: PersistedAgent,
+    sourceAgentId: string,
+    sourceTurnId: string,
+    deliveryId?: string,
+  ): boolean;
   resolveLaunchMissingDependencies(agent: PersistedAgent): Promise<string[]>;
   resolveRestorationMissingDependencies(agent: PersistedAgent): Promise<string[]>;
   resolveThinkingLevel(modelId: string, requested: ThinkingLevel): ThinkingLevel;