@narumitw/pi-subagents 1.0.0 → 1.0.2

package/README.md

@@ -613,6 +613,9 @@ A detached agent additionally needs a concrete isolation or specialization benef
 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.
@@ -1049,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": "1.0.0",
+	"version": "1.0.2",
 	"description": "Pi extension for delegating work to specialized isolated subagents.",
 	"type": "module",
 	"license": "MIT",
@@ -39,12 +39,12 @@
 		"typebox": "*"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.5.7",
-		"@earendil-works/pi-agent-core": "0.84.1",
-		"@earendil-works/pi-ai": "0.84.1",
-		"@earendil-works/pi-coding-agent": "0.84.1",
-		"@earendil-works/pi-tui": "0.84.1",
-		"typebox": "1.3.11",
+		"@biomejs/biome": "2.5.8",
+		"@earendil-works/pi-agent-core": "0.84.2",
+		"@earendil-works/pi-ai": "0.84.2",
+		"@earendil-works/pi-coding-agent": "0.84.2",
+		"@earendil-works/pi-tui": "0.84.2",
+		"typebox": "1.3.14",
 		"typescript": "7.0.2"
 	},
 	"dependencies": {

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");
+}

package/src/config-registration.ts

@@ -0,0 +1,114 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { cachedModuleLoader } from "./cached-module-loader.js";
+import type { SubagentMenuOwner, SubagentSettingsRuntime } from "./config-ui.js";
+
+const SUBCOMMANDS = [
+	{ value: "settings", label: "settings", description: "Configure subagent user settings" },
+	{ value: "status", label: "status", description: "Show effective subagent settings" },
+	{ value: "help", label: "help", description: "Show subagent settings help" },
+];
+
+type ConfigUiModule = Pick<
+	typeof import("./config-ui.js"),
+	"showSubagentManager" | "showSubagentSettings"
+>;
+
+type ConfigStatusModule = Pick<
+	typeof import("./config-status.js"),
+	"showSubagentHelp" | "showSubagentStatus"
+>;
+
+export interface ConfigRegistrationDependencies {
+	loadConfigUi?: () => Promise<ConfigUiModule>;
+	loadConfigStatus?: () => Promise<ConfigStatusModule>;
+}
+
+export function registerSubagentConfigLifecycle(pi: ExtensionAPI): SubagentMenuOwner {
+	const owner: SubagentMenuOwner = { generation: 0, controller: new AbortController() };
+	pi.on("session_start", () => {
+		owner.generation += 1;
+		owner.controller.abort(new DOMException("Subagent session replaced", "AbortError"));
+		owner.controller = new AbortController();
+	});
+	pi.on("session_shutdown", () => {
+		owner.generation += 1;
+		owner.controller.abort(new DOMException("Subagent session shut down", "AbortError"));
+	});
+	return owner;
+}
+
+export function registerSubagentConfigCommand(
+	pi: ExtensionAPI,
+	runtime: SubagentSettingsRuntime,
+	owner = registerSubagentConfigLifecycle(pi),
+	dependencies: ConfigRegistrationDependencies = {},
+): void {
+	const loadConfigUi = cachedModuleLoader(
+		dependencies.loadConfigUi ?? (() => import("./config-ui.js")),
+	);
+	const loadConfigStatus = cachedModuleLoader<ConfigStatusModule>(
+		dependencies.loadConfigStatus ?? (() => import("./config-status.js")),
+	);
+	pi.registerCommand("subagents", {
+		description: "Manage current-session subagents and user settings",
+		getArgumentCompletions(prefix: string) {
+			const normalized = prefix.trim().toLowerCase();
+			const matches = SUBCOMMANDS.filter((item) => item.value.startsWith(normalized));
+			return matches.length > 0 ? matches : null;
+		},
+		async handler(args, ctx) {
+			const subcommand = args.trim().toLowerCase();
+			const runStatusCommand = async (show: (status: ConfigStatusModule) => void) => {
+				const generation = owner.generation;
+				const controller = owner.controller;
+				const isCurrent = () =>
+					generation === owner.generation &&
+					controller === owner.controller &&
+					!controller.signal.aborted;
+				let status: ConfigStatusModule;
+				try {
+					status = await loadConfigStatus();
+				} catch (error) {
+					if (!isCurrent()) return;
+					throw error;
+				}
+				if (!isCurrent()) return;
+				show(status);
+			};
+			if (!subcommand && ctx.mode !== "tui") {
+				await runStatusCommand((status) => status.showSubagentStatus(ctx, runtime));
+				return;
+			}
+			if (subcommand === "status") {
+				await runStatusCommand((status) => status.showSubagentStatus(ctx, runtime));
+				return;
+			}
+			if (subcommand === "help") {
+				await runStatusCommand((status) => status.showSubagentHelp(ctx, runtime));
+				return;
+			}
+			if (!subcommand || subcommand === "settings") {
+				const generation = owner.generation;
+				const controller = owner.controller;
+				const isCurrent = () =>
+					generation === owner.generation &&
+					controller === owner.controller &&
+					!controller.signal.aborted;
+				let configUi: ConfigUiModule;
+				try {
+					configUi = await loadConfigUi();
+				} catch (error) {
+					if (!isCurrent()) return;
+					throw error;
+				}
+				if (!isCurrent()) return;
+				if (!subcommand) await configUi.showSubagentManager(pi, ctx, runtime, owner);
+				else await configUi.showSubagentSettings(ctx, runtime, owner);
+				return;
+			}
+			if (ctx.mode === "tui" || ctx.hasUI) {
+				ctx.ui.notify(`Unknown /subagents subcommand: ${subcommand}`, "warning");
+			}
+		},
+	});
+}

package/src/config-ui.ts

@@ -168,7 +168,7 @@ function registerSubagentPrimaryCommand(
 	});
 }
 
-async function showSubagentManager(
+export async function showSubagentManager(
 	pi: ExtensionAPI,
 	ctx: ExtensionCommandContext,
 	runtime: SubagentSettingsRuntime,
@@ -681,7 +681,7 @@ async function showSubagentManager(
 	});
 }
 
-async function showSubagentSettings(
+export async function showSubagentSettings(
 	ctx: ExtensionCommandContext,
 	runtime: SubagentSettingsRuntime,
 	owner: SubagentMenuOwner,