@narumitw/pi-subagents 0.54.0 → 1.0.1

package/README.md

@@ -299,8 +299,8 @@ No benchmark result in this release changes the default delegation policy or mak
 | --- | --- | --- |
 | `list_agents` | Optional `agentScope` (default `user`) and `limit` (default 32, maximum 100) | Bounded agent metadata and omission counts |
 | `get_agent` | Required `agent`; optional `agentScope` | One resolved definition, safe source path, configured tools, and consultation-effective tools; never the system prompt |
-| `list_runs` | Optional `includeClosed` and `limit` (default 50, maximum 100) | Metadata-only retained-run summaries and unread counts |
-| `get_run` | Required `agentId` | Safe `cwd`, current-task/error summaries, thinking level, context footprint, protocol, effective transport, bounded timing/usage telemetry, structured result when valid, policy, history count, and unread count |
+| `list_runs` | Optional `includeClosed` and `limit` (default 50, maximum 100) | Metadata-only retained-run summaries, turn generation, pending-completion count, and unread counts |
+| `get_run` | Required `agentId` | Safe `cwd`, current run and turn generation, current-task/error summaries, thinking level, context footprint, protocol, effective transport, bounded timing/usage telemetry, structured result when valid, policy, history count, pending-completion count, and unread count |
 | `list_workflows` | Optional `limit` (default 50, maximum 100) | Metadata-only persisted blocking-workflow summaries for the current session |
 | `get_workflow` | Required `workflowId` | Bounded task states, generations, dependencies, plan identities, artifact metadata, verification state, and outcome reasons without artifact contents |
 | `list_models` | Optional `limit` (default 50, maximum 100) | Session-scoped models, or the already-loaded available snapshot |
@@ -310,7 +310,7 @@ No benchmark result in this release changes the default delegation policy or mak
 
 The schema rejects fields that do not belong to the selected action. Explicit `project` or `both` scope fails before project-agent discovery unless Pi already trusts the project. Run inspection never returns history output, stored context, or mailbox content; unread counts come from a metadata-only snapshot and do not acknowledge messages. Workflow inspection reads validated, redacted snapshots without quarantining or rewriting invalid files. Paths beneath the Pi agent directory use `~`, project paths are workspace-relative, model objects are projected through an allow-list, and model-facing text is bounded to 50 KiB or 2,000 lines.
 
-Compatibility: `subagent_manage({ "action": "list" })` remains supported with its existing behavior. Prefer `subagent_inspect` when a whole tool must be safe to activate on a read-only surface.
+`subagent_manage` no longer accepts its former compatibility `list` action. Use `subagent_inspect({ "action": "list_runs", "includeClosed": true })` for metadata-only discovery and `get_run` for detail.
 
 ## 📖 Read-only consultation
 
@@ -599,9 +599,9 @@ Legacy v1 and v2 records without acceptance fields retain their prior completed
 
 ## 🔁 Stateful agents
 
-Stateful lifecycle tools are available by default. `subagent_spawn` is detached: it schedules work, returns immediately with an opaque `agentId`, and later injects a bounded `pi-subagent-completion` custom message. Completions that settle in the same dispatch window are batched, and the broker allows at most one in-flight root wake until that parent turn starts.
+Stateful lifecycle tools are available by default. `subagent_spawn` is detached: it schedules work, returns immediately with an opaque `agentId`, and later injects a bounded `pi-subagent-completion` custom message. Every turn receives an executor-owned `runId`, monotonically increasing agent-local generation, and unique `completionId`. The terminal completion is persisted before delivery, simultaneous completions are batched, and the broker allows at most one in-flight root wake until that parent turn starts.
 
-Detached work follows a non-polling policy. With default `next-turn` delivery, prefer one bounded `subagent_spawn` for related asynchronous research or review only when the current response does not depend on its result. If it does, use blocking `subagent` when registered; in **Async only**, complete required work directly, opt into `auto-resume` when a later synthesis turn is appropriate, or switch workflows. With opt-in `auto-resume`, detached broad work may be final-answer-dependent because completion requests a synthesis turn after the root settles. In either mode, do useful non-overlapping main-agent work immediately, do not poll `subagent_manage` with `action: "list"` or `subagent_mailbox` with `action: "read"`, and do not duplicate delegated work. Add another detached agent only for truly independent work with safe workspace concurrency. Detached lifecycle work intentionally has no `subagent_wait` tool.
+Detached work follows a non-polling policy. With default `next-turn` delivery, prefer one bounded `subagent_spawn` for related asynchronous research or review only when the current response does not depend on its result. If it does, use blocking `subagent` when registered; in **Async only**, complete required work directly, opt into `auto-resume` when a later synthesis turn is appropriate, or switch workflows. With opt-in `auto-resume`, detached broad work may be final-answer-dependent because completion requests a synthesis turn after the root settles. In either mode, do useful non-overlapping main-agent work immediately, do not poll `subagent_inspect` or `subagent_mailbox` with `action: "read"`, and do not duplicate delegated work. Add another detached agent only for truly independent work with safe workspace concurrency. Detached lifecycle work intentionally has no `subagent_wait` tool.
 
 A detached agent additionally needs a concrete isolation or specialization benefit such as independent review, bounded context/output, a distinct model/tool profile, or workspace isolation. Simple work that the main agent can perform directly should not be delegated.
 
@@ -610,9 +610,12 @@ A detached agent additionally needs a concrete isolation or specialization benef
 - `"next-turn"` (default) preserves the previous behavior: use `deliverAs: "steer"` with `triggerTurn: false`. An active root can consume completion naturally; an idle root is not awakened.
 - `"auto-resume"` holds completion while the root is active, then requests one synthesis turn after the parent settles when no user or extension messages are already pending. Simultaneous completions share that turn, active work is not interrupted, and pending input suppresses the autonomous wake.
 
-Auto-resume is best-effort because Pi's custom-message API is fire-and-forget. Session-generation checks, shutdown cleanup, batching, and the in-flight wake guard prevent stale or duplicate scheduling pressure, but they do not make completion delivery durable across process exit.
+The bounded persisted completion outbox provides ordered at-least-once delivery across process restart without replaying the child turn. When state must be reduced to its storage bound, persistence drops roots without pending completions first and trims old history rather than discarding an outbox-owned root. A completion is acknowledged only after parent context assembly observes its exact `completionId`; an injection that returns synchronously but never reaches context remains pending for retry. If the process exits after context assembly but before acknowledgement is persisted, the same ID can be delivered again and consumers must deduplicate it. Auto-resume wake admission remains best-effort because Pi's custom-message API is fire-and-forget, but an unacknowledged terminal completion itself remains available for redelivery on the next start of the owning session. Transient terminal-persistence failures retry with bounded exponential backoff and keep the run pending; shutdown cancels retry waits and reports a final persistence failure instead of silently resolving unsaved work.
 
 The default `subprocess` transport preserves compatibility: each turn starts a fresh isolated `pi --mode json -p --no-session` child and receives sanitized, bounded history.
+Pi registers every Subagents tool and command during startup, but loads blocking execution, manager UI, inspection work, and the selected detached transport implementation only on first use.
+Session restoration, pending completion delivery, settings validation, and cleanup ownership remain eager.
+A failed first-use code load is reported normally and can be retried.
 Set `transport` to `in-process` to retain one public Pi SDK `AgentSession` per stateful `agentId`, avoiding repeated process startup while preserving native child history in memory.
 Set it to `rpc` to retain one `pi --mode rpc --no-session --no-extensions` process per active retained agent, preserving native child history with a separate process boundary.
 Set it to `auto` for deterministic preflight selection: read-only built-in tools use in-process, write-capable built-in tools use RPC, and extension/custom tools use subprocess.
@@ -687,7 +690,7 @@ This avoids lifecycle-driven tool-schema churn and preserves a stable provider p
 | --- | --- |
 | `subagent_spawn` | Start detached work with optional task-selected thinking and retained timeout, exact-retry `idempotencyKey`, and `text`, `structured-v1`, or `structured-v2` result format; return an opaque `agentId` immediately and deliver completion asynchronously. |
 | `subagent_send` | Send follow-up work with an optional one-turn timeout override and trigger a new turn on a reusable agent; semantic skew requires explicit `revalidate: true`, and shared-workspace write conflicts are guarded unless explicitly overridden. |
-| `subagent_manage` | Use `action: "list"` to inspect agents, `"interrupt"` to retain an agent after aborting active work, or `"close"` to release it; interrupt/close accept optional `subtree`. |
+| `subagent_manage` | Use `"interrupt"` to retain an agent after aborting active work or `"close"` to release it; both actions accept optional `subtree`. Use `subagent_inspect` for all list and detail operations. |
 | `subagent_mailbox` | Use `action: "send"` for queue-only messages that do not start a turn, or `"read"` to read and optionally acknowledge unread messages. |
 
 The action schemas are flat for provider compatibility and reject parameters that belong to another action. For example:
@@ -721,13 +724,14 @@ The five replaced names are intentionally not registered as aliases. Update expl
 
 | Previous call | Fixed-surface call |
 | --- | --- |
-| `subagent_list({ includeClosed })` | `subagent_manage({ action: "list", includeClosed })` |
+| `subagent_list({ includeClosed })` | `subagent_inspect({ action: "list_runs", includeClosed })` |
+| `subagent_manage({ action: "list", includeClosed })` | `subagent_inspect({ action: "list_runs", includeClosed })` |
 | `subagent_interrupt({ agentId, subtree })` | `subagent_manage({ action: "interrupt", agentId, subtree })` |
 | `subagent_close({ agentId, subtree })` | `subagent_manage({ action: "close", agentId, subtree })` |
 | `subagent_message({ agentId, message, ... })` | `subagent_mailbox({ action: "send", agentId, message, ... })` |
 | `subagent_messages({ agentId, acknowledge, limit })` | `subagent_mailbox({ action: "read", agentId, acknowledge, limit })` |
 
-Persisted agent and mailbox records require no migration. If an explicit prompt in a resumed conversation keeps requesting an old name, update it with the mapping above or start a fresh conversation. To roll back after an upgrade, pin the package version used before the upgrade; for this migration, use `pi install npm:@narumitw/pi-subagents@0.26.0`. The previous release can read the same state directory.
+Persisted agent and mailbox records require no manual migration; older records load with an empty completion outbox and generation zero. If an explicit prompt in a resumed conversation keeps requesting an old name, update it with the mapping above or start a fresh conversation. To roll back after an upgrade, pin the package version used before the upgrade; for this migration, use `pi install npm:@narumitw/pi-subagents@0.26.0`. The previous release can read the same state directory.
 
 A spawn can request a thinking level explicitly:
 
@@ -1048,20 +1052,25 @@ Downgrading is safe: older extension versions ignore this separate state directo
 packages/pi-subagents/
 ├── src/
 │   ├── index.ts                  # Pi package entrypoint
-│   ├── subagents.ts              # Extension registration and blocking tool schema
-│   ├── automation.ts             # Explicit autonomous planning tool and lifecycle owner
+│   ├── subagents.ts              # Lightweight extension composition and blocking registration
+│   ├── cached-module-loader.ts   # Retryable first-use code-module cache
+│   ├── automation-registration.ts # Lightweight autonomous tool registration
+│   ├── automation.ts             # First-use autonomous planning execution
 │   ├── automation-contract.ts    # Strict request, proposal, and graph-patch contracts
 │   ├── automation-planner.ts     # Bounded read-only planner prompt and resource policy
 │   ├── workflow-plan-compiler.ts # Deterministic admission, routing, and workflow compilation
 │   ├── workflow-plan-patch.ts    # Generation-safe revisions and atomic plan persistence
 │   ├── workflow-planning-benchmark.ts # Frozen matched offline evaluation protocol
-│   ├── inspect.ts                # Side-effect-free metadata inspection tool
-│   ├── consult.ts                # Synchronous read-only consultation tool
+│   ├── inspect-registration.ts   # Lightweight inspection tool registration
+│   ├── inspect.ts                # First-use side-effect-free metadata inspection
+│   ├── consult-registration.ts   # Lightweight consultation tool registration
+│   ├── consult.ts                # First-use synchronous read-only consultation
 │   ├── consult-policy.ts         # Enforced read-only tool intersection
 │   ├── cwd-policy.ts             # Canonical target and saved-trust resolution
 │   ├── prompt-resources.ts       # Core-selected SYSTEM and APPEND_SYSTEM resources
 │   ├── safe-text.ts              # Shared byte/line/path sanitization
 │   ├── stateful.ts               # Detached lifecycle registration and dispatch
+│   ├── create-stateful-transport.ts # First-turn selected transport loader
 │   ├── rpc-transport.ts          # Persistent strict-JSONL Pi RPC child transport
 │   ├── rpc-timeout-finalization.ts # RPC abort-settle-summary recovery
 │   ├── rpc-transport-metadata.ts # RPC result policy and bounded metadata helpers

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-subagents",
-	"version": "0.54.0",
+	"version": "1.0.1",
 	"description": "Pi extension for delegating work to specialized isolated subagents.",
 	"type": "module",
 	"license": "MIT",

package/src/automation-registration.ts

@@ -0,0 +1,137 @@
+import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import type { AutomationExecutionOptions } from "./automation.js";
+import { type AutomationDetails, SubagentAutomationParams } from "./automation-tool.js";
+import { cachedModuleLoader, throwIfAborted } from "./cached-module-loader.js";
+import { renderFallbackResult, safeLine, toolHeader } from "./render-common.js";
+
+interface AutomationExecutionModule {
+	executeAutomationRequest: typeof import("./automation.js").executeAutomationRequest;
+}
+
+export interface AutomationRegistrationDependencies {
+	loadExecution?: () => Promise<AutomationExecutionModule>;
+}
+
+export function registerSubagentAutomation(
+	pi: ExtensionAPI,
+	options: AutomationExecutionOptions,
+	dependencies: AutomationRegistrationDependencies = {},
+): void {
+	const loadExecution = cachedModuleLoader(
+		dependencies.loadExecution ?? (() => import("./automation.js")),
+	);
+	let generation = 0;
+	const activeControllers = new Set<AbortController>();
+	const activeWork = new Set<Promise<unknown>>();
+	const cancelAndWait = async (reason: string) => {
+		generation++;
+		for (const controller of activeControllers) {
+			controller.abort(new DOMException(reason, "AbortError"));
+		}
+		await Promise.allSettled([...activeWork]);
+	};
+	pi.on("session_start", () => cancelAndWait("Autonomous workflow session replaced"));
+	pi.on("session_shutdown", () => cancelAndWait("Autonomous workflow session shut down"));
+	const definition: ToolDefinition<typeof SubagentAutomationParams, AutomationDetails> = {
+		name: "subagent_auto",
+		label: "Autonomous Subagent Workflow",
+		description: [
+			"Explicitly opt in to one bounded read-only planning turn that compiles a high-level objective into the smallest justified existing workflow.",
+			"The deterministic compiler may return parent-owned work, request missing input, or reject without launching execution workers.",
+			"Mutating workflows require an authoritative integration path and an independent verifier, allow at most two concurrent mutating workers, and never allow workflow grandchildren.",
+			"The first version routes only built-in and user-scoped agents; use caller-authored workflow mode for project-local agents.",
+		].join(" "),
+		promptSnippet:
+			"Explicitly compile one high-level objective into a bounded capability-matched workflow",
+		promptGuidelines: [
+			"Use subagent_auto only when the caller explicitly opts into autonomous workflow planning.",
+			"Provide a complete authority ceiling and aggregate budget; parent-owned and insufficient-evidence results launch no execution workers.",
+			"Use caller-authored subagent workflow mode as the compatibility fallback when deterministic task control is required.",
+		],
+		parameters: SubagentAutomationParams,
+		async execute(toolCallId, params, signal, onUpdate, ctx) {
+			const ownerGeneration = generation;
+			const controller = new AbortController();
+			activeControllers.add(controller);
+			const combined = combineSignals(signal, controller.signal);
+			const work = (async () => {
+				throwIfAborted(combined.signal, "Autonomous workflow loading was cancelled");
+				let executionModule: AutomationExecutionModule;
+				try {
+					executionModule = await loadExecution();
+				} catch (error) {
+					throwIfAborted(combined.signal, "Autonomous workflow loading was cancelled");
+					throw error;
+				}
+				throwIfAborted(combined.signal, "Autonomous workflow loading was cancelled");
+				if (ownerGeneration !== generation) {
+					throw new DOMException("Autonomous workflow owner was replaced", "AbortError");
+				}
+				return executionModule.executeAutomationRequest(
+					toolCallId,
+					params,
+					combined.signal,
+					onUpdate,
+					ctx,
+					options,
+					() => ownerGeneration === generation,
+				);
+			})();
+			activeWork.add(work);
+			try {
+				return await work;
+			} finally {
+				combined.dispose();
+				activeControllers.delete(controller);
+				activeWork.delete(work);
+			}
+		},
+		renderCall(args, theme) {
+			const request = (args as { request?: { objective?: string; version?: string } }).request;
+			return new Text(
+				toolHeader(theme, "subagent_auto", request?.objective, [request?.version ?? "request"]),
+				0,
+				0,
+			);
+		},
+		renderResult(result, renderOptions, theme) {
+			const status = safeLine(result.details?.status, "completed", 128);
+			return renderFallbackResult(
+				result,
+				renderOptions,
+				theme,
+				result.details?.isError === true ||
+					status.endsWith("failed") ||
+					status.endsWith("rejected"),
+			);
+		},
+	};
+	pi.registerTool<typeof SubagentAutomationParams, AutomationDetails>(definition);
+	pi.on("tool_result", (event) => {
+		if (event.toolName !== "subagent_auto") return;
+		if ((event.details as AutomationDetails | undefined)?.isError) return { isError: true };
+	});
+}
+
+function combineSignals(
+	external: AbortSignal | undefined,
+	owned: AbortSignal,
+): { signal: AbortSignal; dispose(): void } {
+	const controller = new AbortController();
+	const signals = [external, owned].filter((value): value is AbortSignal => value !== undefined);
+	const listeners = signals.map((source) => {
+		const listener = () => {
+			if (!controller.signal.aborted) controller.abort(source.reason);
+		};
+		if (source.aborted) listener();
+		else source.addEventListener("abort", listener, { once: true });
+		return { source, listener };
+	});
+	return {
+		signal: controller.signal,
+		dispose() {
+			for (const { source, listener } of listeners) source.removeEventListener("abort", listener);
+		},
+	};
+}

package/src/automation-tool.ts

@@ -0,0 +1,40 @@
+import { type Static, Type } from "typebox";
+import { AutomationRequestSchema } from "./automation-contract.js";
+import type { SubagentDetails } from "./runner.js";
+import type { CompiledWorkflowPlan } from "./workflow-plan-compiler.js";
+
+export const SubagentAutomationParams = Type.Object(
+	{ request: AutomationRequestSchema },
+	{ additionalProperties: false },
+);
+export type SubagentAutomationParams = Static<typeof SubagentAutomationParams>;
+
+export interface AutomationDetails {
+	status:
+		| "planning"
+		| "planner-failed"
+		| "parent-owned"
+		| "needs-input"
+		| "compiler-rejected"
+		| "executed";
+	requestVersion: string;
+	planVersion?: string;
+	planId?: string;
+	workflowGeneration?: number;
+	revision?: number;
+	childCount: number;
+	reasonCodes: string[];
+	missingInputs?: string[];
+	planner?: {
+		agent: string;
+		tools: string[];
+		resources: "project-context" | "none";
+		timeoutMs: number;
+		maxTurns: number;
+		maxToolCalls: number;
+		failed?: boolean;
+	};
+	compiled?: CompiledWorkflowPlan;
+	execution?: SubagentDetails;
+	isError?: boolean;
+}

package/src/automation.ts

@@ -1,22 +1,11 @@
 import { createHash } from "node:crypto";
 import * as path from "node:path";
 import type { AgentToolResult, AgentToolUpdateCallback } from "@earendil-works/pi-agent-core";
-import {
-	type ExtensionAPI,
-	type ExtensionContext,
-	getAgentDir,
-	type ToolDefinition,
-} from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import { type Static, Type } from "typebox";
+import { type ExtensionContext, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { getBuiltInAgent } from "./agents/built-ins.js";
 import { discoverAgents } from "./agents/discovery.js";
 import type { SubagentSettings } from "./agents/types.js";
-import {
-	AutomationRequestSchema,
-	parseAutomationRequest,
-	type WorkflowPlan,
-} from "./automation-contract.js";
+import { parseAutomationRequest, type WorkflowPlan } from "./automation-contract.js";
 import {
 	AUTOMATION_PLANNER_MAX_TIMEOUT_MS,
 	AUTOMATION_PLANNER_MAX_TOOL_CALLS,
@@ -26,13 +15,13 @@ import {
 	parseAutomationPlannerOutput,
 	resolveAutomationPlannerPolicy,
 } from "./automation-planner.js";
+import type { AutomationDetails, SubagentAutomationParams } from "./automation-tool.js";
 import {
 	assertDelegationTargetAllowed,
 	resolveSubagentTarget,
 	targetPolicyAudit,
 } from "./cwd-policy.js";
 import { executeSubagent } from "./execution.js";
-import { renderFallbackResult, safeLine, toolHeader } from "./render-common.js";
 import {
 	getResultFinalOutput,
 	isResultError,
@@ -53,41 +42,9 @@ import {
 import { AutomationPlanPersistence, createWorkflowPlanRecord } from "./workflow-plan-patch.js";
 import { createBlockingWorkLedger, resolveWorkflowTasks } from "./workflow-planning.js";
 
-export const SubagentAutomationParams = Type.Object(
-	{ request: AutomationRequestSchema },
-	{ additionalProperties: false },
-);
-export type SubagentAutomationParams = Static<typeof SubagentAutomationParams>;
-
-export interface AutomationDetails {
-	status:
-		| "planning"
-		| "planner-failed"
-		| "parent-owned"
-		| "needs-input"
-		| "compiler-rejected"
-		| "executed";
-	requestVersion: string;
-	planVersion?: string;
-	planId?: string;
-	workflowGeneration?: number;
-	revision?: number;
-	childCount: number;
-	reasonCodes: string[];
-	missingInputs?: string[];
-	planner?: {
-		agent: string;
-		tools: string[];
-		resources: "project-context" | "none";
-		timeoutMs: number;
-		maxTurns: number;
-		maxToolCalls: number;
-		failed?: boolean;
-	};
-	compiled?: CompiledWorkflowPlan;
-	execution?: SubagentDetails;
-	isError?: boolean;
-}
+export { registerSubagentAutomation } from "./automation-registration.js";
+export type { AutomationDetails } from "./automation-tool.js";
+export { SubagentAutomationParams } from "./automation-tool.js";
 
 export interface AutomationPlannerRequest {
 	prompt: string;
@@ -110,91 +67,6 @@ export interface AutomationExecutionOptions {
 	persistCompiled?: (compiled: CompiledWorkflowPlan, ctx: ExtensionContext) => Promise<void>;
 }
 
-export function registerSubagentAutomation(
-	pi: ExtensionAPI,
-	options: AutomationExecutionOptions,
-): void {
-	let generation = 0;
-	const activeControllers = new Set<AbortController>();
-	const activeWork = new Set<Promise<unknown>>();
-	const cancelAndWait = async (reason: string) => {
-		generation++;
-		for (const controller of activeControllers) {
-			controller.abort(new DOMException(reason, "AbortError"));
-		}
-		await Promise.allSettled([...activeWork]);
-	};
-	pi.on("session_start", () => cancelAndWait("Autonomous workflow session replaced"));
-	pi.on("session_shutdown", () => cancelAndWait("Autonomous workflow session shut down"));
-	const description = () =>
-		[
-			"Explicitly opt in to one bounded read-only planning turn that compiles a high-level objective into the smallest justified existing workflow.",
-			"The deterministic compiler may return parent-owned work, request missing input, or reject without launching execution workers.",
-			"Mutating workflows require an authoritative integration path and an independent verifier, allow at most two concurrent mutating workers, and never allow workflow grandchildren.",
-			"The first version routes only built-in and user-scoped agents; use caller-authored workflow mode for project-local agents.",
-		].join(" ");
-	const definition: ToolDefinition<typeof SubagentAutomationParams, AutomationDetails> = {
-		name: "subagent_auto",
-		label: "Autonomous Subagent Workflow",
-		description: description(),
-		promptSnippet:
-			"Explicitly compile one high-level objective into a bounded capability-matched workflow",
-		promptGuidelines: [
-			"Use subagent_auto only when the caller explicitly opts into autonomous workflow planning.",
-			"Provide a complete authority ceiling and aggregate budget; parent-owned and insufficient-evidence results launch no execution workers.",
-			"Use caller-authored subagent workflow mode as the compatibility fallback when deterministic task control is required.",
-		],
-		parameters: SubagentAutomationParams,
-		async execute(toolCallId, params, signal, onUpdate, ctx) {
-			const ownerGeneration = generation;
-			const controller = new AbortController();
-			activeControllers.add(controller);
-			const combined = combineSignals(signal, controller.signal);
-			const work = executeAutomationRequest(
-				toolCallId,
-				params,
-				combined.signal,
-				onUpdate,
-				ctx,
-				options,
-				() => ownerGeneration === generation,
-			);
-			activeWork.add(work);
-			try {
-				return await work;
-			} finally {
-				combined.dispose();
-				activeControllers.delete(controller);
-				activeWork.delete(work);
-			}
-		},
-		renderCall(args, theme) {
-			const request = (args as { request?: { objective?: string; version?: string } }).request;
-			return new Text(
-				toolHeader(theme, "subagent_auto", request?.objective, [request?.version ?? "request"]),
-				0,
-				0,
-			);
-		},
-		renderResult(result, renderOptions, theme) {
-			const status = safeLine(result.details?.status, "completed", 128);
-			return renderFallbackResult(
-				result,
-				renderOptions,
-				theme,
-				result.details?.isError === true ||
-					status.endsWith("failed") ||
-					status.endsWith("rejected"),
-			);
-		},
-	};
-	pi.registerTool<typeof SubagentAutomationParams, AutomationDetails>(definition);
-	pi.on("tool_result", (event) => {
-		if (event.toolName !== "subagent_auto") return;
-		if ((event.details as AutomationDetails | undefined)?.isError) return { isError: true };
-	});
-}
-
 export async function executeAutomationRequest(
 	toolCallId: string,
 	params: SubagentAutomationParams,
@@ -561,25 +433,3 @@ function abortError(message: string): Error {
 	error.name = "AbortError";
 	return error;
 }
-
-function combineSignals(
-	external: AbortSignal | undefined,
-	owned: AbortSignal,
-): { signal: AbortSignal; dispose(): void } {
-	const controller = new AbortController();
-	const signals = [external, owned].filter((value): value is AbortSignal => value !== undefined);
-	const listeners = signals.map((source) => {
-		const listener = () => {
-			if (!controller.signal.aborted) controller.abort(source.reason);
-		};
-		if (source.aborted) listener();
-		else source.addEventListener("abort", listener, { once: true });
-		return { source, listener };
-	});
-	return {
-		signal: controller.signal,
-		dispose() {
-			for (const { source, listener } of listeners) source.removeEventListener("abort", listener);
-		},
-	};
-}

package/src/cached-module-loader.ts

@@ -0,0 +1,18 @@
+export function cachedModuleLoader<Module>(load: () => Promise<Module>): () => Promise<Module> {
+	let pending: Promise<Module> | undefined;
+	return () => {
+		if (!pending) {
+			pending = load().catch((error) => {
+				pending = undefined;
+				throw error;
+			});
+		}
+		return pending;
+	};
+}
+
+export function throwIfAborted(signal: AbortSignal | undefined, message: string): void {
+	if (!signal?.aborted) return;
+	if (signal.reason instanceof Error) throw signal.reason;
+	throw new DOMException(message, "AbortError");
+}