@narumitw/pi-subagents 0.35.0 → 0.38.0

package/README.md

@@ -240,7 +240,13 @@ Auto-resume is best-effort because Pi's custom-message API is fire-and-forget. S
 
 The default `subprocess` transport preserves compatibility: each turn starts a fresh isolated `pi --mode json -p --no-session` child and receives sanitized, bounded history. 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.
 
-Run `/subagents` in TUI mode to open the primary manager. It leads with the current delegation workflow, human-readable async completion behavior, and active/retained counts. **Change delegation**, **Current agents**, and **Completion behavior** cover the common workflows; agent permissions, transport/runtime details, source, and settings path remain under **Advanced settings**. Escape returns from a nested screen to a newly refreshed manager and then closes it.
+Run `/subagents` in TUI mode to open the standard primary manager. It leads with the current
+delegation workflow, human-readable async completion behavior, and active/retained counts. **Change
+delegation**, **Current agents**, and **Completion behavior** cover the common workflows; agent
+permissions, transport/runtime details, source, and settings path remain under **Advanced settings**.
+Escape returns from a nested screen to a newly refreshed manager; Ctrl+C closes the full flow.
+Exact workflow/reload and project-agent safety confirmations remain extension-owned because they
+guard live agent and trust-boundary policy rather than ordinary navigation.
 
 The direct routes remain predictable: `/subagents settings` changes user completion delivery and applies it immediately, including refreshing the model-facing spawn guidance; `/subagents status` reports current-session runtime values separately from the configured value, source, and path; `/subagents help` summarizes the single-command interface. In RPC mode, bare `/subagents` emits the same bounded status through Pi's notification protocol instead of opening a custom TUI. JSON and print modes do not emit ad hoc command output. Manual edits use `~/.pi/agent/pi-subagents.json` and take effect after reloading Pi:
 
@@ -382,7 +388,10 @@ Built-in agents inherit the active/default Pi model instead of forcing a provide
 
 ## ⚙️ Configure agent tools
 
-Open `/subagents`, choose **Advanced settings**, then **Agent tool settings** in an interactive Pi session to edit the tools each subagent may use. These are user settings stored in `~/.pi/agent/pi-subagents.json` and affect future sessions.
+Open `/subagents`, choose **Advanced settings**, then **Agent tool permissions** in an interactive
+Pi session to edit the tools each subagent may use. The standard bounded multi-select keeps a
+one-save draft: toggles do not write until **Save changes**, Escape discards the draft, and unavailable
+configured tool names remain visible and preserved. These are user settings stored in `~/.pi/agent/pi-subagents.json` and affect future sessions.
 
 Compatibility: a valid legacy `pi-subagents-config.json` remains readable with a warning and is never modified automatically; rename it to `pi-subagents.json`. The first subsequent settings save writes the canonical file. If both files exist, the new filename takes precedence.
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-subagents",
-	"version": "0.35.0",
+	"version": "0.38.0",
 	"description": "Pi extension for delegating work to specialized isolated subagents.",
 	"type": "module",
 	"license": "MIT",
@@ -29,6 +29,7 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
+		"@narumitw/pi-tui-kit": "<1",
 		"proper-lockfile": "^4.1.2",
 		"typebox": "^1.3.8"
 	},

package/src/config-ui.ts

@@ -1,18 +1,5 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { DynamicBorder, getSettingsListTheme } from "@earendil-works/pi-coding-agent";
-import {
-	type AutocompleteItem,
-	Container,
-	Key,
-	matchesKey,
-	type SelectItem,
-	SelectList,
-	type SettingItem,
-	SettingsList,
-	Spacer,
-	Text,
-	truncateToWidth,
-} from "@earendil-works/pi-tui";
+import { defineMenu, runMenu } from "@narumitw/pi-tui-kit";
 import { type CompletionDelivery, discoverAgents } from "./agents.js";
 import type { ManagedAgent } from "./registry.js";
 import {
@@ -29,11 +16,12 @@ import {
 } from "./settings.js";
 import { formatStatefulAgentLine, type StatefulSubagentRuntimeStatus } from "./stateful.js";
 
-const SUBCOMMANDS: AutocompleteItem[] = [
+const SUBCOMMANDS = [
 	{ value: "settings", label: "settings", description: "Configure completion behavior" },
 	{ value: "status", label: "status", description: "Show effective subagent settings" },
 	{ value: "help", label: "help", description: "Show subagent settings help" },
 ];
+const TOOL_VIEWPORT_SIZE = 10;
 
 export interface SubagentSettingsRuntime {
 	getBlockingEnabled(): boolean;
@@ -44,260 +32,42 @@ export interface SubagentSettingsRuntime {
 	clearAgents(): Promise<number>;
 }
 
-export class ToolToggleList {
-	private items: { name: string; displayName: string; selected: boolean }[];
-	private cursor = 0;
-	private cachedWidth?: number;
-	private cachedLines?: string[];
-	onDone?: (selected: string[]) => void;
-	onCancel?: () => void;
-
-	constructor(tools: string[], selected: Set<string>) {
-		this.items = tools.map((name) => ({
-			name,
-			displayName: safeTerminalText(name),
-			selected: selected.has(name),
-		}));
-	}
-
-	private getSelectedNames(): string[] {
-		return this.items.filter((i) => i.selected).map((i) => i.name);
-	}
-
-	handleInput(data: string): void {
-		if (matchesKey(data, Key.escape)) {
-			this.onCancel?.();
-			return;
-		}
-		if (data === "s" || data === "S") {
-			this.onDone?.(this.getSelectedNames());
-			return;
-		}
-		if (this.items.length === 0) return;
-
-		if (matchesKey(data, Key.up) && this.cursor > 0) {
-			this.cursor--;
-			this.invalidate();
-		} else if (matchesKey(data, Key.down) && this.cursor < this.items.length - 1) {
-			this.cursor++;
-			this.invalidate();
-		} else if (matchesKey(data, Key.enter) || matchesKey(data, Key.space)) {
-			this.items[this.cursor].selected = !this.items[this.cursor].selected;
-			this.invalidate();
-		}
-	}
-
-	render(width: number): string[] {
-		if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
-		this.cachedWidth = width;
-		this.cachedLines = this.items.map((item, i) => {
-			const pointer = i === this.cursor ? ">" : " ";
-			const check = item.selected ? "✓" : "○";
-			return truncateToWidth(`${pointer} ${check} ${item.displayName}`, width);
-		});
-		return this.cachedLines;
-	}
-
-	invalidate(): void {
-		this.cachedWidth = undefined;
-		this.cachedLines = undefined;
-	}
+interface MenuOwner {
+	generation: number;
+	controller: AbortController;
 }
 
-export function registerSubagentConfigCommand(pi: ExtensionAPI, runtime: SubagentSettingsRuntime) {
-	registerSubagentPrimaryCommand(pi, runtime);
+interface ToolDraft {
+	agentName: string;
+	agentSource: string;
+	allTools: string[];
+	defaultTools?: string[];
+	orderedTools: string[];
+	selected: Set<string>;
 }
 
-async function showSubagentToolSettings(pi: ExtensionAPI, ctx: ExtensionCommandContext) {
-	if (ctx.mode !== "tui") {
-		if (ctx.hasUI) ctx.ui.notify("Agent tool settings require TUI mode", "info");
-		return;
-	}
-
-	// Get current settings
-	const currentSettings = readSubagentSettings() ?? {};
-	const currentAgents = currentSettings.agents ?? {};
-
-	// Discover agents to show which ones are available
-	const discovery = discoverAgents(ctx.cwd, "user", currentSettings);
-	const agents = discovery.agents;
-
-	if (agents.length === 0) {
-		ctx.ui.notify("No agents found", "warning");
-		return;
-	}
-
-	// Loop: agent selection → tool toggle (Esc in tools returns here)
-	let selectedAgentIndex = 0;
-	while (true) {
-		// Step 1: pick an agent to configure
-		const agentItems: SelectItem[] = agents.map((a) => {
-			const cfg = currentAgents[a.name];
-			const hasToolsOverride = cfg ? hasOwn(cfg, "tools") : false;
-			const toolSummary = hasToolsOverride
-				? cfg?.tools && cfg.tools.length > 0
-					? cfg.tools.join(", ")
-					: "none"
-				: "defaults";
-			return {
-				value: a.name,
-				label: safeTerminalText(a.name),
-				description: safeTerminalText(`${a.source} · tools: ${toolSummary}`),
-			};
-		});
-
-		const agentName = await ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
-			const container = new Container();
-			container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
-			container.addChild(
-				new Text(theme.fg("accent", theme.bold("Subagent Tool Configuration")), 1, 0),
-			);
-			container.addChild(new Spacer(1));
-			container.addChild(
-				new Text(theme.fg("muted", "Select an agent to configure its allowed tools:"), 1, 0),
-			);
-			container.addChild(new Spacer(1));
-			const selectList = new SelectList(agentItems, Math.min(agentItems.length + 2, 15), {
-				selectedPrefix: (t: string) => theme.fg("accent", t),
-				selectedText: (t: string) => theme.fg("accent", t),
-				description: (t: string) => theme.fg("muted", t),
-				scrollInfo: (t: string) => theme.fg("dim", t),
-				noMatch: (t: string) => theme.fg("warning", t),
-			});
-			selectList.setSelectedIndex(selectedAgentIndex);
-			selectList.onSelectionChange = (item) => {
-				selectedAgentIndex = Math.max(
-					0,
-					agentItems.findIndex((candidate) => candidate.value === item.value),
-				);
-			};
-			selectList.onSelect = (item) => {
-				selectedAgentIndex = Math.max(
-					0,
-					agentItems.findIndex((candidate) => candidate.value === item.value),
-				);
-				done(item.value);
-			};
-			selectList.onCancel = () => done(null);
-			container.addChild(selectList);
-			container.addChild(
-				new Text(theme.fg("dim", "↑↓ navigate · enter select · esc cancel"), 1, 0),
-			);
-			container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
-			return {
-				render: (w: number) => container.render(w),
-				invalidate: () => container.invalidate(),
-				handleInput: (data: string) => {
-					selectList.handleInput(data);
-					tui.requestRender();
-				},
-			};
-		});
-
-		if (!agentName) return;
-
-		const agent = agents.find((a) => a.name === agentName);
-		if (!agent) return;
-
-		// Step 2: toggle tools for the selected agent
-		// Discover without overrides to get original built-in/frontmatter defaults.
-		// The main discovery above applies saved overrides, so agent.tools is already
-		// overridden — using it for the reset-to-default comparison would match the
-		// override against itself and silently delete it on a no-op save.
-		const defaultDiscovery = discoverAgents(ctx.cwd, "user");
-		const defaultTools = defaultDiscovery.agents.find((a) => a.name === agentName)?.tools;
-		const currentAgentSettings = currentAgents[agentName];
-		const configuredTools =
-			currentAgentSettings && hasOwn(currentAgentSettings, "tools")
-				? (currentAgentSettings.tools ?? [])
-				: undefined;
-
-		// Get all available tools from pi's registry
-		const allTools = uniqueToolNames(pi.getAllTools().map((t) => t.name)).sort((a, b) =>
-			a.localeCompare(b),
-		);
-		const currentTools = uniqueToolNames(configuredTools ?? defaultTools ?? allTools);
-		// Sort: currently selected tools first, then rest alphabetically. Preserve
-		// unavailable configured tools so saving does not silently drop them.
-		const currentSet = new Set(currentTools);
-		const selectedFirst = [...currentTools, ...allTools.filter((t) => !currentSet.has(t))];
-
-		const selectedTools = await ctx.ui.custom<string[] | null>((tui, theme, _kb, done) => {
-			const toggleList = new ToolToggleList(selectedFirst, currentSet);
-
-			const container = new Container();
-			container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
-			container.addChild(
-				new Text(
-					theme.fg("accent", theme.bold(`${safeTerminalText(agentName)} tools`)) +
-						theme.fg("muted", ` (${agent.source})`),
-					1,
-					0,
-				),
-			);
-			container.addChild(new Spacer(1));
-			container.addChild(
-				new Text(
-					theme.fg("muted", "Toggle tools with Enter/Space. S to save, Esc to cancel."),
-					1,
-					0,
-				),
-			);
-			container.addChild(new Spacer(1));
-
-			const listContainer = new Container();
-			listContainer.addChild({
-				render: (w: number) => toggleList.render(w),
-				invalidate: () => toggleList.invalidate(),
-			});
-			container.addChild(listContainer);
-
-			container.addChild(new Spacer(1));
-			container.addChild(
-				new Text(theme.fg("dim", "↑↓ navigate · enter/space toggle · S save · esc cancel"), 1, 0),
-			);
-			container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
-
-			toggleList.onDone = (tools) => done(tools);
-			toggleList.onCancel = () => done(null);
-
-			return {
-				render: (w: number) => container.render(w),
-				invalidate: () => container.invalidate(),
-				handleInput: (data: string) => {
-					toggleList.handleInput(data);
-					tui.requestRender();
-				},
-			};
-		});
-
-		// null means user cancelled — loop back to agent selection
-		if (selectedTools === null) continue;
-
-		// Patch only this agent's tool field so forward-compatible settings survive.
-		const restoredDefaults =
-			defaultTools === undefined
-				? sameToolSet(selectedTools, allTools)
-				: sameToolSet(selectedTools, defaultTools);
-		updateAgentToolsSetting(agentName, restoredDefaults ? undefined : selectedTools);
-		const safeAgentName = safeTerminalText(agentName);
-		const message = restoredDefaults
-			? `${safeAgentName}: defaults restored`
-			: `${safeAgentName}: ${selectedTools.length} tool${selectedTools.length !== 1 ? "s" : ""} configured`;
-		ctx.ui.notify(message, "info");
-		// Saved — exit the loop
-		break;
-	}
+export function registerSubagentConfigCommand(pi: ExtensionAPI, runtime: SubagentSettingsRuntime) {
+	const owner: MenuOwner = { 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"));
+	});
+	registerSubagentPrimaryCommand(pi, runtime, owner);
 }
 
-type ManagerAction = "workflow" | "agents" | "completion" | "advanced" | "help";
-type AdvancedAction = "agent-tools" | "status" | "back";
-type AgentManagerAction = "back" | "clear";
-
-function registerSubagentPrimaryCommand(pi: ExtensionAPI, runtime: SubagentSettingsRuntime) {
+function registerSubagentPrimaryCommand(
+	pi: ExtensionAPI,
+	runtime: SubagentSettingsRuntime,
+	owner: MenuOwner,
+) {
 	pi.registerCommand("subagents", {
 		description: "Manage current-session subagents and user settings",
-		getArgumentCompletions(prefix: string): AutocompleteItem[] | null {
+		getArgumentCompletions(prefix: string) {
 			const normalized = prefix.trim().toLowerCase();
 			const matches = SUBCOMMANDS.filter((item) => item.value.startsWith(normalized));
 			return matches.length > 0 ? matches : null;
@@ -305,12 +75,12 @@ function registerSubagentPrimaryCommand(pi: ExtensionAPI, runtime: SubagentSetti
 		async handler(args, ctx) {
 			const subcommand = args.trim().toLowerCase();
 			if (!subcommand) {
-				await showSubagentManager(pi, ctx, runtime);
+				await showSubagentManager(pi, ctx, runtime, owner);
 				return;
 			}
 			switch (subcommand) {
 				case "settings":
-					await showSubagentSettings(ctx, runtime);
+					await showSubagentSettings(ctx, runtime, owner);
 					return;
 				case "status":
 					showSubagentStatus(ctx, runtime);
@@ -331,216 +101,440 @@ async function showSubagentManager(
 	pi: ExtensionAPI,
 	ctx: ExtensionCommandContext,
 	runtime: SubagentSettingsRuntime,
+	owner: MenuOwner,
 ) {
 	if (ctx.mode !== "tui") {
 		showSubagentStatus(ctx, runtime);
 		return;
 	}
-	while (true) {
-		const action = await selectManagerAction(ctx, runtime);
-		if (!action) return;
-		switch (action) {
-			case "workflow":
-				if (await showDelegationWorkflow(ctx, runtime)) return;
-				break;
-			case "agents":
-				await showCurrentSessionAgents(ctx, runtime);
-				break;
-			case "completion":
-				await showSubagentSettings(ctx, runtime);
-				break;
-			case "advanced":
-				await showAdvancedSettings(pi, ctx, runtime);
-				break;
-			case "help":
-				showSubagentHelp(ctx);
-				break;
-		}
-	}
-}
-
-async function selectManagerAction(
-	ctx: ExtensionCommandContext,
-	runtime: SubagentSettingsRuntime,
-): Promise<ManagerAction | null> {
-	const status = runtime.getRuntimeStatus();
-	const workflow = inspectDelegationWorkflowSettings();
-	const items: SelectItem[] = [
-		{
-			value: "workflow",
-			label: "Change delegation",
-			description: "Choose all methods, async only, or blocking only",
-		},
-		{
-			value: "agents",
-			label: "Current agents",
-			description: `${status.activeAgents} active · ${status.retainedAgents} retained`,
-		},
-		{
-			value: "completion",
-			label: "Completion behavior",
-			description: "Choose whether async completion waits or resumes automatically",
-		},
-		{
-			value: "advanced",
-			label: "Advanced settings",
-			description: "Agent permissions, runtime details, and settings path",
+	const generation = owner.generation;
+	let availableAgents = discoverAgents(ctx.cwd, "user", readSubagentSettings() ?? {}).agents;
+	let toolDraft: ToolDraft | undefined;
+	type Screen =
+		| "main"
+		| "workflow"
+		| "agents"
+		| "completion"
+		| "advanced"
+		| "status"
+		| "help"
+		| "agent-picker"
+		| "tool-draft";
+	type Action =
+		| "set-workflow"
+		| "clear-agents"
+		| "set-completion"
+		| "load-agent-picker"
+		| "pick-agent"
+		| "toggle-tool"
+		| "save-tools"
+		| "discard-tools"
+		| "back";
+	const menu = defineMenu<undefined, Screen, Action, ExtensionCommandContext>({
+		start: "main",
+		screens: {
+			main: () => {
+				const status = runtime.getRuntimeStatus();
+				const workflow = inspectDelegationWorkflowSettings();
+				return {
+					kind: "actions",
+					title: "Subagents",
+					lines: formatManagerSummary(runtime, status, workflow).split("\n"),
+					items: [
+						{
+							id: "workflow",
+							label: "Change delegation",
+							description: "Choose all methods, async only, or blocking only",
+							to: "workflow",
+						},
+						{
+							id: "agents",
+							label: "Current agents",
+							description: `${status.activeAgents} active · ${status.retainedAgents} retained`,
+							to: "agents",
+						},
+						{
+							id: "completion",
+							label: "Completion behavior",
+							description: "Choose whether async completion waits or resumes automatically",
+							to: "completion",
+						},
+						{
+							id: "advanced",
+							label: "Advanced settings",
+							description: "Agent permissions, runtime details, and settings path",
+							to: "advanced",
+						},
+						{ id: "help", label: "Help", to: "help" },
+					],
+					hint: "close",
+				};
+			},
+			workflow: () => {
+				const snapshot = inspectDelegationWorkflowSettings();
+				const active = currentWorkflow(runtime, runtime.getRuntimeStatus());
+				return {
+					kind: "actions",
+					title: "Change Delegation",
+					lines: [
+						`Current: ${workflowLabel(active)}`,
+						...(snapshot.value !== active
+							? [`Configured after reload: ${workflowLabel(snapshot.value)}`]
+							: []),
+						...(snapshot.error
+							? [
+									`Settings cannot be edited: ${safeTerminalText(snapshot.error)}`,
+									`Repair ${safeTerminalText(snapshot.path)} and retry.`,
+								]
+							: []),
+					],
+					items: snapshot.error
+						? []
+						: [
+								{
+									id: "all",
+									label: "All delegation methods",
+									description: "Allow blocking batches and reusable async agents",
+									action: "set-workflow" as const,
+								},
+								{
+									id: "async-only",
+									label: "Async only",
+									description: "Keep the root responsive; remove blocking subagent",
+									action: "set-workflow" as const,
+								},
+								{
+									id: "blocking-only",
+									label: "Blocking only",
+									description: "Keep blocking batches; remove reusable async agents",
+									action: "set-workflow" as const,
+								},
+							],
+					hint: "back",
+				};
+			},
+			agents: () => {
+				const agents = runtime.listAgents();
+				const status = runtime.getRuntimeStatus();
+				return {
+					kind: "actions",
+					title: "Current-session Subagents",
+					lines: agents.length ? agents.map(formatStatefulAgentLine) : [formatEmptyRuntime(status)],
+					items: [
+						...(agents.length > 0
+							? [
+									{
+										id: "clear",
+										label: "Clear current-session agents",
+										description: "Close and delete retained agents for this session",
+										action: "clear-agents" as const,
+									},
+								]
+							: []),
+						{ id: "back", label: "Back", action: "back" },
+					],
+					hint: "back",
+				};
+			},
+			completion: () => completionSettingsScreen(),
+			advanced: () => ({
+				kind: "actions",
+				title: "Advanced Subagent Settings",
+				items: [
+					{
+						id: "agent-tools",
+						label: "Agent tool permissions",
+						description: "Customize persistent per-agent tool allow-lists",
+						action: "load-agent-picker",
+					},
+					{
+						id: "status",
+						label: "Runtime details",
+						description: "Show transport, configured source, and settings path",
+						to: "status",
+					},
+					{ id: "back", label: "Back", action: "back" },
+				],
+				hint: "back",
+			}),
+			status: () => ({
+				kind: "detail",
+				title: "Subagent runtime details",
+				lines: statusLines(runtime),
+				hint: "back",
+			}),
+			help: () => ({
+				kind: "detail",
+				title: "Subagents help",
+				lines: helpLines(),
+				hint: "back",
+			}),
+			"agent-picker": () => {
+				const settings = readSubagentSettings() ?? {};
+				const configured = settings.agents ?? {};
+				return {
+					kind: "actions",
+					title: "Subagent Tool Configuration",
+					lines: ["Select an agent to configure its allowed tools."],
+					items: availableAgents.map((agent) => {
+						const override = configured[agent.name];
+						const hasOverride = override ? hasOwn(override, "tools") : false;
+						const summary = hasOverride
+							? override?.tools && override.tools.length > 0
+								? override.tools.join(", ")
+								: "none"
+							: "defaults";
+						return {
+							id: agent.name,
+							label: safeTerminalText(agent.name),
+							description: safeTerminalText(`${agent.source} · tools: ${summary}`),
+							action: "pick-agent" as const,
+						};
+					}),
+					hint: "back",
+				};
+			},
+			"tool-draft": () => ({
+				kind: "multiSelect",
+				title: toolDraft ? `${safeTerminalText(toolDraft.agentName)} tools` : "Agent tools",
+				lines: toolDraft
+					? [
+							`Source: ${safeTerminalText(toolDraft.agentSource)}`,
+							"Toggle a draft, then Save changes.",
+						]
+					: ["No agent selected."],
+				viewportSize: TOOL_VIEWPORT_SIZE,
+				items:
+					toolDraft?.orderedTools.map((name) => {
+						const available = toolDraft?.allTools.includes(name) ?? false;
+						return {
+							id: name,
+							label: safeTerminalText(name),
+							description: available ? "Available tool" : "Configured tool is not currently loaded",
+							selected: toolDraft?.selected.has(name) ?? false,
+							disabled: !available,
+							disabledReason: available
+								? undefined
+								: "Unavailable; preserved until explicitly changed in JSON",
+						};
+					}) ?? [],
+				action: "toggle-tool",
+				actions: [
+					{ id: "save", label: "Save changes", action: "save-tools" },
+					{ id: "discard", label: "Discard draft", action: "discard-tools" },
+				],
+				hint: "back",
+				doneLabel: "Close without saving",
+			}),
 		},
-		{ value: "help", label: "Help", description: "Show commands and manual configuration" },
-	];
-	return ctx.ui.custom<ManagerAction | null>((tui, theme, _keybindings, done) => {
-		const container = new Container();
-		container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
-		container.addChild(new Text(theme.fg("accent", theme.bold("Subagents")), 1, 0));
-		container.addChild(new Spacer(1));
-		container.addChild(
-			new Text(theme.fg("muted", formatManagerSummary(runtime, status, workflow)), 1, 0),
-		);
-		container.addChild(new Spacer(1));
-		const selectList = new SelectList(items, Math.min(items.length + 2, 15), {
-			selectedPrefix: (text: string) => theme.fg("accent", text),
-			selectedText: (text: string) => theme.fg("accent", text),
-			description: (text: string) => theme.fg("muted", text),
-			scrollInfo: (text: string) => theme.fg("dim", text),
-			noMatch: (text: string) => theme.fg("warning", text),
-		});
-		selectList.onSelect = (item) => done(item.value as ManagerAction);
-		selectList.onCancel = () => done(null);
-		container.addChild(selectList);
-		container.addChild(new Text(theme.fg("dim", "↑↓ navigate · enter select · esc close"), 1, 0));
-		container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
-		return {
-			render: (width: number) => container.render(width),
-			invalidate: () => container.invalidate(),
-			handleInput(data: string) {
-				selectList.handleInput(data);
-				tui.requestRender();
+		actions: {
+			"set-workflow": async ({ itemId }) => {
+				if (!isWorkflow(itemId)) return { kind: "rejected" };
+				const snapshot = inspectDelegationWorkflowSettings();
+				if (snapshot.error) return { kind: "rejected" };
+				const active = currentWorkflow(runtime, runtime.getRuntimeStatus());
+				if (itemId === active && itemId === snapshot.value) {
+					ctx.ui.notify(`Delegation already uses ${workflowLabel(itemId)}.`, "info");
+					return { kind: "stay" };
+				}
+				const requiresReload = itemId !== active;
+				if (requiresReload && blockReloadWithRetainedAgents(ctx, runtime)) {
+					return { kind: "rejected" };
+				}
+				if (!(await showWorkflowPreview(ctx, active, itemId, requiresReload))) {
+					return { kind: "rejected" };
+				}
+				if (requiresReload && blockReloadWithRetainedAgents(ctx, runtime)) {
+					return { kind: "rejected" };
+				}
+				try {
+					updateDelegationWorkflowSetting(itemId);
+				} catch (error) {
+					ctx.ui.notify(
+						`Delegation settings were not saved: ${formatError(error)}. The current workflow is unchanged.`,
+						"error",
+					);
+					return { kind: "rejected" };
+				}
+				if (!requiresReload) {
+					ctx.ui.notify(
+						`Saved ${workflowLabel(itemId)}. The current tool surface already matches.`,
+						"info",
+					);
+					return { kind: "stay" };
+				}
+				ctx.ui.notify(
+					`Saved ${workflowLabel(itemId)}. Reloading subagent tools… If the tool surface does not refresh, run /reload.`,
+					"info",
+				);
+				await ctx.reload();
+				return { kind: "close" };
+			},
+			"clear-agents": async () => {
+				const agents = runtime.listAgents();
+				if (agents.length === 0) return { kind: "stay" };
+				const confirmed = await ctx.ui.confirm(
+					"Clear current-session subagents?",
+					`Close and delete ${agents.length} retained agent${agents.length === 1 ? "" : "s"}?`,
+				);
+				if (!confirmed) return { kind: "rejected" };
+				const cleared = await runtime.clearAgents();
+				ctx.ui.notify(
+					`Cleared ${cleared} current-session subagent${cleared === 1 ? "" : "s"}.`,
+					"info",
+				);
+				return { kind: "stay" };
+			},
+			"set-completion": async ({ value }) => applyCompletionSetting(value, ctx, runtime),
+			"load-agent-picker": async () => {
+				availableAgents = discoverAgents(ctx.cwd, "user", readSubagentSettings() ?? {}).agents;
+				if (availableAgents.length === 0) {
+					ctx.ui.notify("No agents found", "warning");
+					return { kind: "rejected" };
+				}
+				return { kind: "to", screen: "agent-picker" };
+			},
+			"pick-agent": async ({ itemId }) => {
+				const agent = availableAgents.find((candidate) => candidate.name === itemId);
+				if (!agent) return { kind: "rejected" };
+				const settings = readSubagentSettings() ?? {};
+				const configured = settings.agents?.[agent.name];
+				const configuredTools =
+					configured && hasOwn(configured, "tools") ? (configured.tools ?? []) : undefined;
+				const defaults = discoverAgents(ctx.cwd, "user").agents.find(
+					(candidate) => candidate.name === agent.name,
+				)?.tools;
+				const allTools = uniqueToolNames(pi.getAllTools().map((tool) => tool.name)).sort((a, b) =>
+					a.localeCompare(b),
+				);
+				const selected = uniqueToolNames(configuredTools ?? defaults ?? allTools);
+				const selectedSet = new Set(selected);
+				toolDraft = {
+					agentName: agent.name,
+					agentSource: agent.source,
+					allTools,
+					defaultTools: defaults,
+					orderedTools: [...selected, ...allTools.filter((name) => !selectedSet.has(name))],
+					selected: selectedSet,
+				};
+				return { kind: "to", screen: "tool-draft" };
+			},
+			"toggle-tool": async ({ itemId, selected }) => {
+				if (!toolDraft?.allTools.includes(itemId)) return { kind: "rejected" };
+				if (selected) toolDraft.selected.add(itemId);
+				else toolDraft.selected.delete(itemId);
+				return { kind: "stay" };
+			},
+			"save-tools": async () => {
+				if (!toolDraft) return { kind: "rejected" };
+				const selected = toolDraft.orderedTools.filter((name) => toolDraft?.selected.has(name));
+				const restoredDefaults =
+					toolDraft.defaultTools === undefined
+						? sameToolSet(selected, toolDraft.allTools)
+						: sameToolSet(selected, toolDraft.defaultTools);
+				try {
+					updateAgentToolsSetting(toolDraft.agentName, restoredDefaults ? undefined : selected);
+				} catch (error) {
+					ctx.ui.notify(`Agent tool settings were not saved: ${formatError(error)}`, "error");
+					return { kind: "rejected" };
+				}
+				ctx.ui.notify(
+					restoredDefaults
+						? `${safeTerminalText(toolDraft.agentName)}: defaults restored`
+						: `${safeTerminalText(toolDraft.agentName)}: ${selected.length} tool${selected.length === 1 ? "" : "s"} configured`,
+					"info",
+				);
+				toolDraft = undefined;
+				return { kind: "back" };
 			},
-		};
+			"discard-tools": async () => {
+				toolDraft = undefined;
+				return { kind: "back" };
+			},
+			back: async () => ({ kind: "back" }),
+		},
+	});
+	await runMenu(ctx, menu, {
+		getState: () => undefined,
+		signal: owner.controller.signal,
+		isCurrent: () => generation === owner.generation && !owner.controller.signal.aborted,
 	});
 }
 
-async function showDelegationWorkflow(
+async function showSubagentSettings(
 	ctx: ExtensionCommandContext,
 	runtime: SubagentSettingsRuntime,
-): Promise<boolean> {
-	const snapshot = inspectDelegationWorkflowSettings();
+	owner: MenuOwner,
+) {
+	const snapshot = inspectCompletionDeliverySettings();
 	if (ctx.mode !== "tui") {
 		if (ctx.hasUI) {
 			ctx.ui.notify(
-				`Edit delegation settings manually: ${safeTerminalText(snapshot.path)}`,
+				`User settings apply to this and future sessions. Edit settings manually: ${safeTerminalText(snapshot.path)}`,
 				"info",
 			);
 		}
-		return false;
-	}
-	if (snapshot.error) {
-		ctx.ui.notify(
-			`Delegation settings cannot be edited: ${safeTerminalText(snapshot.error)}. Repair ${safeTerminalText(snapshot.path)} and retry.`,
-			"error",
-		);
-		return false;
+		return;
 	}
-	const activeWorkflow = currentWorkflow(runtime, runtime.getRuntimeStatus());
-	const choices: SelectItem[] = [
-		{
-			value: "all",
-			label: "All delegation methods",
-			description: "Allow blocking batches and reusable async agents",
-		},
-		{
-			value: "async-only",
-			label: "Async only",
-			description: "Keep the root responsive; remove blocking subagent",
-		},
-		{
-			value: "blocking-only",
-			label: "Blocking only",
-			description: "Keep blocking batches; remove reusable async agents",
-		},
-	];
-	const selected = await ctx.ui.custom<DelegationWorkflow | null>(
-		(tui, theme, _keybindings, done) => {
-			const container = new Container();
-			container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
-			container.addChild(new Text(theme.fg("accent", theme.bold("Change Delegation")), 1, 0));
-			container.addChild(
-				new Text(
-					theme.fg(
-						"muted",
-						[
-							`Current: ${workflowLabel(activeWorkflow)}`,
-							...(snapshot.value !== activeWorkflow
-								? [`Configured after reload: ${workflowLabel(snapshot.value)}`]
-								: []),
-						].join("\n"),
-					),
-					1,
-					0,
-				),
-			);
-			container.addChild(new Spacer(1));
-			const selectList = new SelectList(choices, Math.min(choices.length + 2, 10), {
-				selectedPrefix: (text: string) => theme.fg("accent", text),
-				selectedText: (text: string) => theme.fg("accent", text),
-				description: (text: string) => theme.fg("muted", text),
-				scrollInfo: (text: string) => theme.fg("dim", text),
-				noMatch: (text: string) => theme.fg("warning", text),
-			});
-			selectList.setSelectedIndex(
-				Math.max(
-					0,
-					choices.findIndex((item) => item.value === snapshot.value),
-				),
-			);
-			selectList.onSelect = (item) => done(item.value as DelegationWorkflow);
-			selectList.onCancel = () => done(null);
-			container.addChild(selectList);
-			container.addChild(new Text(theme.fg("dim", "↑↓ navigate · enter preview · esc back"), 1, 0));
-			container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
-			return {
-				render: (width: number) => container.render(width),
-				invalidate: () => container.invalidate(),
-				handleInput(data: string) {
-					selectList.handleInput(data);
-					tui.requestRender();
-				},
-			};
+	const generation = owner.generation;
+	const menu = defineMenu<undefined, "completion", "set-completion", ExtensionCommandContext>({
+		start: "completion",
+		screens: { completion: () => completionSettingsScreen() },
+		actions: {
+			"set-completion": async ({ value }) => applyCompletionSetting(value, ctx, runtime),
 		},
-	);
-	if (!selected) return false;
-	if (selected === activeWorkflow && selected === snapshot.value) {
-		ctx.ui.notify(`Delegation already uses ${workflowLabel(selected)}.`, "info");
-		return false;
-	}
-	const requiresReload = selected !== activeWorkflow;
-	if (requiresReload && blockReloadWithRetainedAgents(ctx, runtime)) return false;
+	});
+	await runMenu(ctx, menu, {
+		getState: () => undefined,
+		signal: owner.controller.signal,
+		isCurrent: () => generation === owner.generation && !owner.controller.signal.aborted,
+	});
+}
 
-	const confirmed = await showWorkflowPreview(ctx, activeWorkflow, selected, requiresReload);
-	if (!confirmed) return false;
-	if (requiresReload && blockReloadWithRetainedAgents(ctx, runtime)) return false;
+function completionSettingsScreen() {
+	const snapshot = inspectCompletionDeliverySettings();
+	return {
+		kind: "settings" as const,
+		title: snapshot.error ? "Subagent User Settings · Read only" : "Subagent User Settings",
+		lines: [
+			"Applies now and to future sessions",
+			safeTerminalText(snapshot.path),
+			...(snapshot.error ? [`Settings cannot be edited: ${safeTerminalText(snapshot.error)}`] : []),
+		],
+		items: snapshot.error
+			? []
+			: [
+					{
+						id: "completionDelivery",
+						label: "When async work finishes",
+						description:
+							"Wait for your next turn, or request one synthesis turn after the root settles.",
+						currentValue: completionLabel(snapshot.value),
+						values: ["Wait until my next turn", "Resume automatically when finished"],
+						action: "set-completion" as const,
+					},
+				],
+	};
+}
+
+function applyCompletionSetting(
+	value: string | undefined,
+	ctx: ExtensionCommandContext,
+	runtime: SubagentSettingsRuntime,
+) {
+	const previous = runtime.getCompletionDelivery();
+	const next: CompletionDelivery =
+		value === "Resume automatically when finished" ? "auto-resume" : "next-turn";
+	if (next === previous) return { kind: "stay" as const };
 	try {
-		updateDelegationWorkflowSetting(selected as Exclude<DelegationWorkflow, "disabled">);
+		updateCompletionDeliverySetting(next);
+		runtime.setCompletionDelivery(next);
+		ctx.ui.notify(`Saved and applied: ${completionLabel(next)}.`, "info");
+		return { kind: "stay" as const };
 	} catch (error) {
-		ctx.ui.notify(
-			`Delegation settings were not saved: ${formatError(error)}. The current workflow is unchanged.`,
-			"error",
-		);
-		return false;
-	}
-	if (!requiresReload) {
-		ctx.ui.notify(
-			`Saved ${workflowLabel(selected)}. The current tool surface already matches.`,
-			"info",
-		);
-		return false;
+		ctx.ui.notify(`Subagent settings were not saved: ${formatError(error)}`, "error");
+		return { kind: "rejected" as const };
 	}
-	ctx.ui.notify(
-		`Saved ${workflowLabel(selected)}. Reloading subagent tools… If the tool surface does not refresh, run /reload.`,
-		"info",
-	);
-	await ctx.reload();
-	return true;
 }
 
 function blockReloadWithRetainedAgents(
@@ -562,266 +556,20 @@ async function showWorkflowPreview(
 	next: DelegationWorkflow,
 	requiresReload: boolean,
 ): Promise<boolean> {
-	const workflowChanges = workflowEffects(current, next);
-	const effects = (
-		workflowChanges.length > 0
-			? workflowChanges
-			: ["Keep the current registered tools and cancel the pending workflow change"]
-	)
-		.map((effect) => `- ${effect}`)
-		.join("\n");
-	return ctx.ui.custom<boolean>((tui, theme, _keybindings, done) => {
-		const container = new Container();
-		container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
-		container.addChild(new Text(theme.fg("accent", theme.bold("Review Delegation Change")), 1, 0));
-		container.addChild(
-			new Text(
-				theme.fg(
-					"muted",
-					`Current: ${workflowLabel(current)}\nNew: ${workflowLabel(next)}\n\nEffect:\n${effects}\n- ${requiresReload ? "Reload the extension to apply this tool surface" : "No reload is needed because the active tools already match"}`,
-				),
-				1,
-				0,
-			),
-		);
-		container.addChild(new Spacer(1));
-		const actions: SelectItem[] = [
-			{
-				value: "save",
-				label: requiresReload ? "Save and reload" : "Save",
-				description: requiresReload
-					? "Persist and apply this workflow"
-					: "Persist the workflow that is already active",
-			},
-			{ value: "cancel", label: "Cancel", description: "Leave settings and tools unchanged" },
-		];
-		const selectList = new SelectList(actions, 4, {
-			selectedPrefix: (text: string) => theme.fg("accent", text),
-			selectedText: (text: string) => theme.fg("accent", text),
-			description: (text: string) => theme.fg("muted", text),
-			scrollInfo: (text: string) => theme.fg("dim", text),
-			noMatch: (text: string) => theme.fg("warning", text),
-		});
-		selectList.onSelect = (item) => done(item.value === "save");
-		selectList.onCancel = () => done(false);
-		container.addChild(selectList);
-		container.addChild(new Text(theme.fg("dim", "↑↓ navigate · enter choose · esc cancel"), 1, 0));
-		container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
-		return {
-			render: (width: number) => container.render(width),
-			invalidate: () => container.invalidate(),
-			handleInput(data: string) {
-				selectList.handleInput(data);
-				tui.requestRender();
-			},
-		};
-	});
-}
-
-async function showAdvancedSettings(
-	pi: ExtensionAPI,
-	ctx: ExtensionCommandContext,
-	runtime: SubagentSettingsRuntime,
-) {
-	while (true) {
-		const action = await ctx.ui.custom<AdvancedAction | null>((tui, theme, _keybindings, done) => {
-			const container = new Container();
-			container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
-			container.addChild(
-				new Text(theme.fg("accent", theme.bold("Advanced Subagent Settings")), 1, 0),
-			);
-			container.addChild(new Spacer(1));
-			const items: SelectItem[] = [
-				{
-					value: "agent-tools",
-					label: "Agent tool permissions",
-					description: "Customize persistent per-agent tool allow-lists",
-				},
-				{
-					value: "status",
-					label: "Runtime details",
-					description: "Show transport, configured source, and settings path",
-				},
-				{ value: "back", label: "Back", description: "Return to the Subagents manager" },
-			];
-			const selectList = new SelectList(items, 5, {
-				selectedPrefix: (text: string) => theme.fg("accent", text),
-				selectedText: (text: string) => theme.fg("accent", text),
-				description: (text: string) => theme.fg("muted", text),
-				scrollInfo: (text: string) => theme.fg("dim", text),
-				noMatch: (text: string) => theme.fg("warning", text),
-			});
-			selectList.onSelect = (item) => done(item.value as AdvancedAction);
-			selectList.onCancel = () => done(null);
-			container.addChild(selectList);
-			container.addChild(new Text(theme.fg("dim", "↑↓ navigate · enter select · esc back"), 1, 0));
-			container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
-			return {
-				render: (width: number) => container.render(width),
-				invalidate: () => container.invalidate(),
-				handleInput(data: string) {
-					selectList.handleInput(data);
-					tui.requestRender();
-				},
-			};
-		});
-		if (!action || action === "back") return;
-		if (action === "agent-tools") await showSubagentToolSettings(pi, ctx);
-		else showSubagentStatus(ctx, runtime);
-	}
-}
-
-async function showCurrentSessionAgents(
-	ctx: ExtensionCommandContext,
-	runtime: SubagentSettingsRuntime,
-) {
-	while (true) {
-		const agents = runtime.listAgents();
-		const status = runtime.getRuntimeStatus();
-		const action = await ctx.ui.custom<AgentManagerAction | null>(
-			(tui, theme, _keybindings, done) => {
-				const container = new Container();
-				container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
-				container.addChild(
-					new Text(theme.fg("accent", theme.bold("Current-session Subagents")), 1, 0),
-				);
-				container.addChild(new Spacer(1));
-				container.addChild(
-					new Text(
-						theme.fg(
-							"muted",
-							agents.length
-								? agents.map(formatStatefulAgentLine).join("\n")
-								: formatEmptyRuntime(status),
-						),
-						1,
-						0,
-					),
-				);
-				container.addChild(new Spacer(1));
-				const actions: SelectItem[] = [
-					{ value: "back", label: "Back", description: "Return to the Subagents manager" },
-					...(agents.length > 0
-						? [
-								{
-									value: "clear",
-									label: "Clear current-session agents",
-									description: "Close and delete retained agents for this session",
-								},
-							]
-						: []),
-				];
-				const selectList = new SelectList(actions, Math.min(actions.length + 2, 8), {
-					selectedPrefix: (text: string) => theme.fg("accent", text),
-					selectedText: (text: string) => theme.fg("accent", text),
-					description: (text: string) => theme.fg("muted", text),
-					scrollInfo: (text: string) => theme.fg("dim", text),
-					noMatch: (text: string) => theme.fg("warning", text),
-				});
-				selectList.onSelect = (item) => done(item.value as AgentManagerAction);
-				selectList.onCancel = () => done(null);
-				container.addChild(selectList);
-				container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
-				return {
-					render: (width: number) => container.render(width),
-					invalidate: () => container.invalidate(),
-					handleInput(data: string) {
-						selectList.handleInput(data);
-						tui.requestRender();
-					},
-				};
-			},
-		);
-		if (!action || action === "back") return;
-		const confirmed = await ctx.ui.confirm(
-			"Clear current-session subagents?",
-			`Close and delete ${agents.length} retained agent${agents.length === 1 ? "" : "s"}?`,
-		);
-		if (!confirmed) continue;
-		const cleared = await runtime.clearAgents();
-		ctx.ui.notify(
-			`Cleared ${cleared} current-session subagent${cleared === 1 ? "" : "s"}.`,
-			"info",
-		);
-	}
-}
-
-async function showSubagentSettings(
-	ctx: ExtensionCommandContext,
-	runtime: SubagentSettingsRuntime,
-) {
-	const snapshot = inspectCompletionDeliverySettings();
-	if (ctx.mode !== "tui") {
-		if (ctx.hasUI) {
-			ctx.ui.notify(
-				`User settings apply to this and future sessions. Edit settings manually: ${safeTerminalText(snapshot.path)}`,
-				"info",
-			);
-		}
-		return;
-	}
-	if (snapshot.error) {
-		ctx.ui.notify(
-			`Subagent settings cannot be edited: ${safeTerminalText(snapshot.error)}`,
-			"error",
-		);
-		return;
-	}
-	let currentValue = snapshot.value;
-	await ctx.ui.custom((tui, theme, _keybindings, done) => {
-		const items: SettingItem[] = [
-			{
-				id: "completionDelivery",
-				label: "When async work finishes",
-				description:
-					"Wait for your next turn, or request one synthesis turn after the root settles.",
-				currentValue: completionLabel(currentValue),
-				values: ["Wait until my next turn", "Resume automatically when finished"],
-			},
-		];
-		const container = new Container();
-		container.addChild(new Text(theme.fg("accent", theme.bold("Subagent User Settings")), 1, 0));
-		container.addChild(
-			new Text(
-				theme.fg("muted", `Applies now and to future sessions\n${safeTerminalText(snapshot.path)}`),
-				1,
-				0,
+	const changes = workflowEffects(current, next);
+	return ctx.ui.confirm(
+		requiresReload ? "Save delegation change and reload?" : "Save delegation change?",
+		[
+			`Current: ${workflowLabel(current)}`,
+			`New: ${workflowLabel(next)}`,
+			"",
+			"Effect:",
+			...(changes.length > 0 ? changes : ["Keep the current registered tools"]).map(
+				(effect) => `- ${effect}`,
 			),
-		);
-		container.addChild(new Spacer(1));
-		let settingsList: SettingsList;
-		settingsList = new SettingsList(
-			items,
-			Math.min(items.length + 2, 15),
-			getSettingsListTheme(),
-			(id, newValue) => {
-				if (id !== "completionDelivery") return;
-				const previous = currentValue;
-				const next: CompletionDelivery =
-					newValue === "Resume automatically when finished" ? "auto-resume" : "next-turn";
-				try {
-					updateCompletionDeliverySetting(next);
-					runtime.setCompletionDelivery(next);
-					currentValue = next;
-					ctx.ui.notify(`Saved and applied: ${completionLabel(next)}.`, "info");
-				} catch (error) {
-					settingsList.updateValue(id, completionLabel(previous));
-					ctx.ui.notify(`Subagent settings were not saved: ${formatError(error)}`, "error");
-				}
-				tui.requestRender();
-			},
-			() => done(undefined),
-		);
-		container.addChild(settingsList);
-		return {
-			render: (width: number) => container.render(width),
-			invalidate: () => container.invalidate(),
-			handleInput(data: string) {
-				settingsList.handleInput?.(data);
-				tui.requestRender();
-			},
-		};
-	});
+			`- ${requiresReload ? "Reload the extension to apply this tool surface" : "No reload is needed because the active tools already match"}`,
+		].join("\n"),
+	);
 }
 
 function showSubagentStatus(ctx: ExtensionCommandContext, runtime: SubagentSettingsRuntime) {
@@ -835,17 +583,23 @@ function showSubagentStatus(ctx: ExtensionCommandContext, runtime: SubagentSetti
 
 function showSubagentHelp(ctx: ExtensionCommandContext) {
 	if (ctx.mode !== "tui" && !ctx.hasUI) return;
+	ctx.ui.notify(helpLines().join("\n"), "info");
+}
+
+function statusLines(runtime: SubagentSettingsRuntime): string[] {
 	const snapshot = inspectCompletionDeliverySettings();
-	ctx.ui.notify(
-		[
-			"/subagents — choose delegation workflow, manage current agents, and configure agent tools",
-			"/subagents settings — configure async completion behavior",
-			"/subagents status — show current-session and user-setting values",
-			"/subagents help — show this help",
-			`User settings: ${safeTerminalText(snapshot.path)}`,
-		].join("\n"),
-		"info",
-	);
+	return formatStatus(runtime.getRuntimeStatus(), snapshot, runtime).split("\n");
+}
+
+function helpLines(): string[] {
+	const snapshot = inspectCompletionDeliverySettings();
+	return [
+		"/subagents — choose delegation workflow, manage current agents, and configure agent tools",
+		"/subagents settings — configure async completion behavior",
+		"/subagents status — show current-session and user-setting values",
+		"/subagents help — show this help",
+		`User settings: ${safeTerminalText(snapshot.path)}`,
+	];
 }
 
 function formatManagerSummary(
@@ -911,6 +665,10 @@ function currentWorkflow(
 	return "disabled";
 }
 
+function isWorkflow(value: string): value is Exclude<DelegationWorkflow, "disabled"> {
+	return value === "all" || value === "async-only" || value === "blocking-only";
+}
+
 function workflowLabel(value: DelegationWorkflow): string {
 	switch (value) {
 		case "all":