pi-subagents 0.35.1 → 0.37.0

package/src/slash/prompt-template-bridge.ts

@@ -1,12 +1,16 @@
 import {
 	SUBAGENT_DELEGATION_CANCEL_EVENT,
 	SUBAGENT_DELEGATION_PROTOCOL_VERSION,
+	SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION,
 	SUBAGENT_DELEGATION_REQUEST_EVENT,
 	SUBAGENT_DELEGATION_RESPONSE_EVENT,
 	SUBAGENT_DELEGATION_STARTED_EVENT,
 	SUBAGENT_DELEGATION_UPDATE_EVENT,
 	type SubagentDelegationRequest,
 	type SubagentDelegationResponse,
+	type SubagentDelegationV2InvalidResponse,
+	type SubagentDelegationV2Request,
+	type SubagentDelegationV2Response,
 } from "../api/delegation.ts";
 import { parseSubagentDelegationRequest } from "./delegation-request.ts";
 import {
@@ -17,6 +21,9 @@ import {
 	toSubagentDelegationExecutionParams,
 	toSubagentDelegationResponse,
 	toSubagentDelegationUpdate,
+	toSubagentDelegationV2ExecutionParams,
+	toSubagentDelegationV2Response,
+	toSubagentDelegationV2Update,
 	type DelegatedSubagentExecutionParams,
 	type PromptTemplateBridgeResult,
 	type PromptTemplateDelegationRequest,
@@ -44,6 +51,17 @@ interface PromptTemplateBridgeOptions<Ctx extends { cwd?: string }> {
 		ctx: Ctx,
 		onUpdate: (result: PromptTemplateBridgeResult) => void,
 	) => Promise<PromptTemplateBridgeResult>;
+	/**
+	 * Concurrent-safe executor for strict versioned delegation requests.
+	 * Non-versioned prompt-template requests retain the ordinary single-dispatch guard.
+	 */
+	executeVersioned?: (
+		requestId: string,
+		params: DelegatedSubagentExecutionParams,
+		signal: AbortSignal,
+		ctx: Ctx,
+		onUpdate: (result: PromptTemplateBridgeResult) => void,
+	) => Promise<PromptTemplateBridgeResult>;
 }
 
 export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: string }>(
@@ -52,10 +70,17 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 	cancelAll: () => void;
 	dispose: () => void;
 } {
+	// Legacy and V1 retain requestId-only correlation. V2 attempts are isolated by
+	// their complete wire identity, while logical-node ownership is tracked separately.
 	const controllers = new Map<string, AbortController>();
 	const pendingCancels = new Map<string, true>();
+	const v2Controllers = new Map<string, AbortController>();
+	const pendingV2Cancels = new Map<string, true>();
+	const activeV2Nodes = new Map<string, { attemptKey: string; controller: AbortController }>();
+	const settledV2Attempts = new Map<string, true>();
 	const subscriptions: Array<() => void> = [];
 	let disposed = false;
+	let v2IdentitySaturated = false;
 
 	const subscribe = (event: string, handler: (data: unknown) => void): void => {
 		const unsubscribe = options.events.on(event, handler);
@@ -63,25 +88,63 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 	};
 	const ownsRequest = (requestId: string, controller: AbortController): boolean =>
 		!disposed && controllers.get(requestId) === controller;
-	const rememberPendingCancel = (requestId: string): void => {
-		pendingCancels.delete(requestId);
-		pendingCancels.set(requestId, true);
-		while (pendingCancels.size > 256) {
-			const oldest = pendingCancels.keys().next().value;
+	const ownsV2Attempt = (attemptKey: string, controller: AbortController): boolean =>
+		!disposed && v2Controllers.get(attemptKey) === controller;
+	const boundedRemember = (map: Map<string, true>, key: string): void => {
+		map.delete(key);
+		map.set(key, true);
+		while (map.size > 256) {
+			const oldest = map.keys().next().value;
 			if (typeof oldest !== "string") break;
-			pendingCancels.delete(oldest);
+			map.delete(oldest);
+		}
+	};
+	const rememberV2Identity = (map: Map<string, true>, key: string): void => {
+		if (map.has(key) || v2IdentitySaturated) return;
+		if (map.size >= 8_192) {
+			v2IdentitySaturated = true;
+			return;
+		}
+		map.set(key, true);
+		if (map.size === 8_192) {
+			// V2 identity facts are security state, not an LRU cache. Saturate as
+			// soon as the bounded history fills so no later untracked attempt can
+			// start, rather than evicting a cancellation or settled-attempt fact.
+			v2IdentitySaturated = true;
 		}
 	};
+	const v2NodeKey = (ownerRunId: string, nodeId: string): string => JSON.stringify([ownerRunId, nodeId]);
+	const v2AttemptKey = (requestId: string, ownerRunId: string, nodeId: string): string => JSON.stringify([requestId, ownerRunId, nodeId]);
+	const rememberPendingCancel = (requestId: string): void => {
+		boundedRemember(pendingCancels, requestId);
+	};
+	const emitV2Terminal = (attemptKey: string, payload: SubagentDelegationV2Response): void => {
+		if (disposed || settledV2Attempts.has(attemptKey)) return;
+		rememberV2Identity(settledV2Attempts, attemptKey);
+		options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, payload);
+	};
 
 	subscribe(PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT, (data) => {
 		if (!data || typeof data !== "object" || Array.isArray(data)) return;
-		if (Object.hasOwn(data, "version")) {
-			const value = data as Record<string, unknown>;
+		const value = data as Record<string, unknown>;
+		const requestId = value.requestId;
+		if (typeof requestId !== "string" || !requestId.trim() || requestId.length > 256 || /[\r\n]/.test(requestId)) return;
+		if (Object.hasOwn(value, "version")) {
+			if (value.version === SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION) {
+				if (Object.keys(value).some((key) => key !== "version" && key !== "requestId" && key !== "ownerRunId" && key !== "nodeId")) return;
+				const ownerRunId = value.ownerRunId;
+				const nodeId = value.nodeId;
+				if (typeof ownerRunId !== "string" || !ownerRunId.trim() || ownerRunId.length > 256 || /[\r\n]/.test(ownerRunId)) return;
+				if (typeof nodeId !== "string" || !nodeId.trim() || nodeId.length > 256 || /[\r\n]/.test(nodeId)) return;
+				const attemptKey = v2AttemptKey(requestId, ownerRunId, nodeId);
+				const controller = v2Controllers.get(attemptKey);
+				if (controller) controller.abort();
+				else rememberV2Identity(pendingV2Cancels, attemptKey);
+				return;
+			}
 			if (value.version !== SUBAGENT_DELEGATION_PROTOCOL_VERSION) return;
 			if (Object.keys(value).some((key) => key !== "version" && key !== "requestId")) return;
 		}
-		const requestId = (data as { requestId?: unknown }).requestId;
-		if (typeof requestId !== "string" || !requestId.trim() || requestId.length > 256 || /[\r\n]/.test(requestId)) return;
 		const controller = controllers.get(requestId);
 		if (controller) {
 			controller.abort();
@@ -94,25 +157,50 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 		const isVersioned = !!data && typeof data === "object" && Object.hasOwn(data, "version");
 		let requestId: string;
 		let params: DelegatedSubagentExecutionParams;
-		let versionedRequest: SubagentDelegationRequest | undefined;
+		let versionedRequest: SubagentDelegationRequest | SubagentDelegationV2Request | undefined;
+		let v2Request: SubagentDelegationV2Request | undefined;
+		let v2Key: string | undefined;
 		let legacyRequest: PromptTemplateDelegationRequest | undefined;
 
 		if (isVersioned) {
 			const parsed = parseSubagentDelegationRequest(data);
 			if (parsed.ok === false) {
-				if (!disposed && parsed.requestId && !controllers.has(parsed.requestId)) {
-					options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, {
-						version: SUBAGENT_DELEGATION_PROTOCOL_VERSION,
-						requestId: parsed.requestId,
-						status: "invalid_request",
-						error: parsed.error,
-					} satisfies SubagentDelegationResponse);
+				if (!disposed && parsed.requestId) {
+					if (parsed.version === SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION) {
+						const payload = {
+							version: SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION,
+							requestId: parsed.requestId,
+							...(parsed.ownerRunId ? { ownerRunId: parsed.ownerRunId } : {}),
+							...(parsed.nodeId ? { nodeId: parsed.nodeId } : {}),
+							status: "invalid_request",
+							error: parsed.error,
+						} satisfies SubagentDelegationV2InvalidResponse;
+						if (parsed.ownerRunId && parsed.nodeId) {
+							const attemptKey = v2AttemptKey(parsed.requestId, parsed.ownerRunId, parsed.nodeId);
+							if (!v2Controllers.has(attemptKey)) emitV2Terminal(attemptKey, payload);
+						} else {
+							options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, payload);
+						}
+					} else if (!controllers.has(parsed.requestId)) {
+						options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, {
+							version: SUBAGENT_DELEGATION_PROTOCOL_VERSION,
+							requestId: parsed.requestId,
+							status: "invalid_request",
+							error: parsed.error,
+						} satisfies SubagentDelegationResponse);
+					}
 				}
 				return;
 			}
 			versionedRequest = parsed.request;
 			requestId = parsed.request.requestId;
-			params = toSubagentDelegationExecutionParams(parsed.request);
+			if (parsed.request.version === SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION) {
+				v2Request = parsed.request;
+				v2Key = v2AttemptKey(requestId, parsed.request.ownerRunId, parsed.request.nodeId);
+				params = toSubagentDelegationV2ExecutionParams(parsed.request);
+			} else {
+				params = toSubagentDelegationExecutionParams(parsed.request);
+			}
 		} else {
 			legacyRequest = parsePromptTemplateRequest(data);
 			if (!legacyRequest) return;
@@ -120,12 +208,56 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 			params = toLegacyExecutionParams(legacyRequest);
 		}
 
-		// The first request owns its correlation ID until it settles. A duplicate
-		// cannot receive a terminal response without stealing the original caller's.
-		if (controllers.has(requestId)) return;
+		// Legacy and V1 keep requestId-only ownership. V2 retransmission and terminal
+		// suppression use the full tuple, independently from logical-node ownership.
+		if (!v2Request && controllers.has(requestId)) return;
+		if (v2Request && v2Key) {
+			if (v2Controllers.has(v2Key) || settledV2Attempts.has(v2Key)) return;
+			if (pendingV2Cancels.delete(v2Key)) {
+				emitV2Terminal(v2Key, {
+					version: SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION,
+					requestId,
+					ownerRunId: v2Request.ownerRunId,
+					nodeId: v2Request.nodeId,
+					status: "cancelled",
+				});
+				return;
+			}
+			if (v2IdentitySaturated) {
+				options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, {
+					version: SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION,
+					requestId,
+					ownerRunId: v2Request.ownerRunId,
+					nodeId: v2Request.nodeId,
+					status: "unavailable_context",
+					error: "Delegation v2 identity capacity is exhausted for this extension context.",
+				} satisfies SubagentDelegationV2Response);
+				return;
+			}
+			const active = activeV2Nodes.get(v2NodeKey(v2Request.ownerRunId, v2Request.nodeId));
+			if (active) {
+				emitV2Terminal(v2Key, {
+					version: SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION,
+					requestId,
+					ownerRunId: v2Request.ownerRunId,
+					nodeId: v2Request.nodeId,
+					status: "duplicate_node",
+				});
+				return;
+			}
+		}
 		const ctx = options.getContext();
 		if (!ctx) {
-			if (versionedRequest) {
+			if (v2Request && v2Key) {
+				emitV2Terminal(v2Key, {
+					version: SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION,
+					requestId,
+					ownerRunId: v2Request.ownerRunId,
+					nodeId: v2Request.nodeId,
+					status: "unavailable_context",
+					error: "No active extension context for delegated subagent execution.",
+				});
+			} else if (versionedRequest) {
 				options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, {
 					version: SUBAGENT_DELEGATION_PROTOCOL_VERSION,
 					requestId,
@@ -144,10 +276,24 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 		}
 
 		const controller = new AbortController();
-		controllers.set(requestId, controller);
-		if (pendingCancels.delete(requestId)) controller.abort();
+		if (v2Request && v2Key) {
+			v2Controllers.set(v2Key, controller);
+			activeV2Nodes.set(v2NodeKey(v2Request.ownerRunId, v2Request.nodeId), { attemptKey: v2Key, controller });
+		} else {
+			controllers.set(requestId, controller);
+			if (pendingCancels.delete(requestId)) controller.abort();
+		}
 		if (controller.signal.aborted) {
-			if (versionedRequest) {
+			if (v2Request && v2Key) {
+				emitV2Terminal(v2Key, {
+					version: SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION,
+					requestId,
+					ownerRunId: v2Request.ownerRunId,
+					nodeId: v2Request.nodeId,
+					status: "cancelled",
+				});
+				activeV2Nodes.delete(v2NodeKey(v2Request.ownerRunId, v2Request.nodeId));
+			} else if (versionedRequest) {
 				options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, {
 					version: SUBAGENT_DELEGATION_PROTOCOL_VERSION,
 					requestId,
@@ -161,25 +307,36 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 					errorText: "Delegated prompt cancelled.",
 				} satisfies PromptTemplateDelegationResponse);
 			}
-			controllers.delete(requestId);
+			if (v2Key) v2Controllers.delete(v2Key);
+			else controllers.delete(requestId);
 			return;
 		}
 
 		options.events.emit(
 			versionedRequest ? SUBAGENT_DELEGATION_STARTED_EVENT : PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT,
-			versionedRequest
-				? { version: SUBAGENT_DELEGATION_PROTOCOL_VERSION, requestId }
-				: { requestId },
+			v2Request
+				? { version: SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION, requestId, ownerRunId: v2Request.ownerRunId, nodeId: v2Request.nodeId }
+				: versionedRequest
+					? { version: SUBAGENT_DELEGATION_PROTOCOL_VERSION, requestId }
+					: { requestId },
 		);
 
 		try {
-			const result = await options.execute(
+			const executeRequest = versionedRequest && options.executeVersioned
+				? options.executeVersioned
+				: options.execute;
+			const result = await executeRequest(
 				requestId,
 				params,
 				controller.signal,
 				ctx,
 				(update) => {
-					if (!ownsRequest(requestId, controller)) return;
+					if (v2Key ? !ownsV2Attempt(v2Key, controller) : !ownsRequest(requestId, controller)) return;
+					if (v2Request) {
+						const payload = toSubagentDelegationV2Update(v2Request, update);
+						if (payload) options.events.emit(SUBAGENT_DELEGATION_UPDATE_EVENT, payload);
+						return;
+					}
 					if (versionedRequest) {
 						const payload = toSubagentDelegationUpdate(requestId, update);
 						if (payload) options.events.emit(SUBAGENT_DELEGATION_UPDATE_EVENT, payload);
@@ -189,8 +346,10 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 					if (payload) options.events.emit(PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT, payload);
 				},
 			);
-			if (!ownsRequest(requestId, controller)) return;
-			if (versionedRequest) {
+			if (v2Key ? !ownsV2Attempt(v2Key, controller) : !ownsRequest(requestId, controller)) return;
+			if (v2Request && v2Key) {
+				emitV2Terminal(v2Key, toSubagentDelegationV2Response(v2Request, result, controller.signal.aborted));
+			} else if (versionedRequest) {
 				options.events.emit(
 					SUBAGENT_DELEGATION_RESPONSE_EVENT,
 					toSubagentDelegationResponse(requestId, result, controller.signal.aborted),
@@ -204,8 +363,17 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 				);
 			}
 		} catch (error) {
-			if (!ownsRequest(requestId, controller)) return;
-			if (versionedRequest) {
+			if (v2Key ? !ownsV2Attempt(v2Key, controller) : !ownsRequest(requestId, controller)) return;
+			if (v2Request && v2Key) {
+				emitV2Terminal(v2Key, {
+					version: SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION,
+					requestId,
+					ownerRunId: v2Request.ownerRunId,
+					nodeId: v2Request.nodeId,
+					status: controller.signal.aborted ? "cancelled" : "failed",
+					...(controller.signal.aborted ? {} : { error: error instanceof Error ? error.message : String(error) }),
+				});
+			} else if (versionedRequest) {
 				options.events.emit(SUBAGENT_DELEGATION_RESPONSE_EVENT, {
 					version: SUBAGENT_DELEGATION_PROTOCOL_VERSION,
 					requestId,
@@ -221,23 +389,40 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 				} satisfies PromptTemplateDelegationResponse);
 			}
 		} finally {
-			if (controllers.get(requestId) === controller) controllers.delete(requestId);
+			if (v2Key) {
+				if (v2Controllers.get(v2Key) === controller) v2Controllers.delete(v2Key);
+			} else if (controllers.get(requestId) === controller) controllers.delete(requestId);
+			if (v2Request) {
+				const key = v2NodeKey(v2Request.ownerRunId, v2Request.nodeId);
+				if (activeV2Nodes.get(key)?.controller === controller) activeV2Nodes.delete(key);
+			}
 		}
 	});
 
 	return {
 		cancelAll: () => {
 			for (const controller of controllers.values()) controller.abort();
+			for (const controller of v2Controllers.values()) controller.abort();
 			controllers.clear();
+			v2Controllers.clear();
 			pendingCancels.clear();
+			pendingV2Cancels.clear();
+			activeV2Nodes.clear();
+			settledV2Attempts.clear();
+			v2IdentitySaturated = false;
 		},
 		dispose: () => {
 			disposed = true;
 			for (const controller of controllers.values()) controller.abort();
+			for (const controller of v2Controllers.values()) controller.abort();
 			controllers.clear();
+			v2Controllers.clear();
 			for (const unsubscribe of subscriptions) unsubscribe();
 			subscriptions.length = 0;
 			pendingCancels.clear();
+			pendingV2Cancels.clear();
+			activeV2Nodes.clear();
+			settledV2Attempts.clear();
 		},
 	};
 }

package/src/slash/selector.ts

@@ -0,0 +1,147 @@
+import { DynamicBorder, keyHint, rawKeyHint, type Theme } from "@earendil-works/pi-coding-agent";
+import { Container, fuzzyFilter, Input, type KeybindingsManager, Spacer, Text, type TUI } from "@earendil-works/pi-tui";
+
+/** A single selectable row. `value` is returned on confirm; `label` is the primary text. */
+export interface SelectorItem {
+	value: string;
+	label: string;
+	/** Optional dimmed badge shown after the label (e.g. a provider name). */
+	badge?: string;
+	/** Marks the current selection (rendered with a ✓ checkmark). */
+	current?: boolean;
+}
+
+export interface SelectorResult {
+	confirmed: boolean;
+	value?: string;
+}
+
+export interface SelectorOptions {
+	title: string;
+	/** Optional dimmed hint line under the title (e.g. the current value). */
+	subtitle?: string;
+	items: SelectorItem[];
+	done: (result: SelectorResult) => void;
+}
+
+const MAX_VISIBLE = 10;
+
+/**
+ * A single-select list with a search field and a bounded scroll window that keeps the
+ * highlighted row on screen with an `(n/total)` indicator, so the selection never scrolls
+ * out of view when the option list is long. Composed from pi's own TUI primitives so it
+ * matches the built-in `/model` picker.
+ *
+ * Colors come from the `theme` passed to the factory: the module-level `theme` singleton
+ * is undefined under the extension's jiti module cache.
+ */
+export class SelectorComponent extends Container {
+	private readonly tui: TUI;
+	private readonly theme: Theme;
+	private readonly keybindings: KeybindingsManager;
+	private readonly items: SelectorItem[];
+	private readonly done: (result: SelectorResult) => void;
+
+	private readonly searchInput: Input;
+	private readonly listContainer: Container;
+	private filtered: SelectorItem[];
+	private selectedIndex = 0;
+
+	constructor(tui: TUI, theme: Theme, keybindings: KeybindingsManager, options: SelectorOptions) {
+		super();
+		this.tui = tui;
+		this.theme = theme;
+		this.keybindings = keybindings;
+		this.items = options.items;
+		this.done = options.done;
+		this.filtered = [...this.items];
+
+		const border = () => new DynamicBorder((str) => theme.fg("border", str));
+		this.addChild(border());
+		this.addChild(new Spacer(1));
+		this.addChild(new Text(theme.fg("accent", theme.bold(options.title)), 0, 0));
+		if (options.subtitle) this.addChild(new Text(theme.fg("muted", options.subtitle), 0, 0));
+		this.addChild(new Spacer(1));
+
+		this.searchInput = new Input();
+		this.searchInput.focused = true;
+		this.searchInput.onSubmit = () => this.confirmSelection();
+		this.addChild(this.searchInput);
+		this.addChild(new Spacer(1));
+
+		this.listContainer = new Container();
+		this.addChild(this.listContainer);
+		this.addChild(new Spacer(1));
+
+		this.addChild(new Text(rawKeyHint("↑↓", "navigate") + "  " + keyHint("tui.select.confirm", "select") + "  " + keyHint("tui.select.cancel", "cancel"), 0, 0));
+		this.addChild(new Spacer(1));
+		this.addChild(border());
+
+		const currentIndex = this.filtered.findIndex((item) => item.current);
+		if (currentIndex >= 0) this.selectedIndex = currentIndex;
+		this.updateList();
+	}
+
+	private applyFilter(query: string): void {
+		const previous = this.filtered[this.selectedIndex]?.value;
+		this.filtered = query
+			? fuzzyFilter(this.items, query, (item) => `${item.label} ${item.value} ${item.badge ?? ""}`)
+			: [...this.items];
+		const keepIndex = this.filtered.findIndex((item) => item.value === previous);
+		this.selectedIndex = keepIndex >= 0 ? keepIndex : Math.min(this.selectedIndex, Math.max(0, this.filtered.length - 1));
+		this.updateList();
+	}
+
+	private updateList(): void {
+		const th = this.theme;
+		this.listContainer.clear();
+		const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(MAX_VISIBLE / 2), this.filtered.length - MAX_VISIBLE));
+		const endIndex = Math.min(startIndex + MAX_VISIBLE, this.filtered.length);
+
+		for (let i = startIndex; i < endIndex; i++) {
+			const item = this.filtered[i]!;
+			const isSelected = i === this.selectedIndex;
+			const badge = item.badge ? ` ${th.fg("muted", `[${item.badge}]`)}` : "";
+			const checkmark = item.current ? th.fg("success", " ✓") : "";
+			const line = isSelected
+				? `${th.fg("accent", "→ ")}${th.fg("accent", item.label)}${badge}${checkmark}`
+				: `  ${item.label}${badge}${checkmark}`;
+			this.listContainer.addChild(new Text(line, 0, 0));
+		}
+
+		if (startIndex > 0 || endIndex < this.filtered.length) {
+			this.listContainer.addChild(new Text(th.fg("muted", `  (${this.selectedIndex + 1}/${this.filtered.length})`), 0, 0));
+		}
+		if (this.filtered.length === 0) {
+			this.listContainer.addChild(new Text(th.fg("muted", "  No matching entries"), 0, 0));
+		}
+	}
+
+	private confirmSelection(): void {
+		const selected = this.filtered[this.selectedIndex];
+		this.done(selected ? { confirmed: true, value: selected.value } : { confirmed: false });
+	}
+
+	handleInput(keyData: string): void {
+		const kb = this.keybindings;
+		if (kb.matches(keyData, "tui.select.up")) {
+			if (this.filtered.length === 0) return;
+			this.selectedIndex = this.selectedIndex === 0 ? this.filtered.length - 1 : this.selectedIndex - 1;
+			this.updateList();
+			this.tui.requestRender();
+		} else if (kb.matches(keyData, "tui.select.down")) {
+			if (this.filtered.length === 0) return;
+			this.selectedIndex = this.selectedIndex === this.filtered.length - 1 ? 0 : this.selectedIndex + 1;
+			this.updateList();
+			this.tui.requestRender();
+		} else if (kb.matches(keyData, "tui.select.confirm")) {
+			this.confirmSelection();
+		} else if (kb.matches(keyData, "tui.select.cancel")) {
+			this.done({ confirmed: false });
+		} else {
+			this.searchInput.handleInput(keyData);
+			this.applyFilter(this.searchInput.getValue());
+			this.tui.requestRender();
+		}
+	}
+}

package/src/slash/slash-commands.ts

@@ -737,6 +737,13 @@ async function runSlashSubagent(
 	}
 }
 
+function launchSlashSubagent(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	params: SubagentParamsLike,
+): void {
+	void runSlashSubagent(pi, ctx, params);
+}
 
 export interface GroupConfig { concurrency?: number; failFast?: boolean; worktree?: boolean }
 export interface ParsedStep { kind: "step"; name: string; config: InlineConfig; task?: string }
@@ -1001,7 +1008,7 @@ function validateInlineAcceptanceInput(value: string, agent: string): void {
 	const errors = validateAcceptanceInput(value, `acceptance for step '${agent}'`);
 	if (errors.length > 0) throw new SlashParseError(errors[0]!);
 	if (!INLINE_ACCEPTANCE_LEVELS.has(value)) {
-		throw new SlashParseError(`Inline acceptance for step '${agent}' supports auto, attested, or checked. Use the subagent tool API or a saved .chain.json file for none or verified acceptance contracts; reviewed is inferred-only.`);
+		throw new SlashParseError(`Inline acceptance for step '${agent}' supports auto, attested, or checked. Use the subagent tool API or a saved .chain.json file for none, verified, or review requirements; reviewed is an achieved status, not an input level.`);
 	}
 }
 
@@ -1189,7 +1196,7 @@ export function registerSlashCommands(
 			if (inline.model) params.model = inline.model;
 			if (bg) params.async = true;
 			if (fork) params.context = "fork";
-			await runSlashSubagent(pi, ctx, params);
+			launchSlashSubagent(pi, ctx, params);
 		},
 	});
 
@@ -1203,7 +1210,7 @@ export function registerSlashCommands(
 			const params: SubagentParamsLike = { chain: built.chain, task: built.task, clarify: false, agentScope: "both" };
 			if (bg) params.async = true;
 			if (fork) params.context = "fork";
-			await runSlashSubagent(pi, ctx, params);
+			launchSlashSubagent(pi, ctx, params);
 		},
 	});
 
@@ -1233,7 +1240,7 @@ export function registerSlashCommands(
 			const params: SubagentParamsLike = { chain: mapSavedChainSteps(chain), task, clarify: false, agentScope: "both" };
 			if (bg) params.async = true;
 			if (fork) params.context = "fork";
-			await runSlashSubagent(pi, ctx, params);
+			launchSlashSubagent(pi, ctx, params);
 		},
 	});
 
@@ -1257,7 +1264,7 @@ export function registerSlashCommands(
 			const params: SubagentParamsLike = { tasks, clarify: false, agentScope: "both" };
 			if (bg) params.async = true;
 			if (fork) params.context = "fork";
-			await runSlashSubagent(pi, ctx, params);
+			launchSlashSubagent(pi, ctx, params);
 		},
 	});
 
@@ -1331,7 +1338,9 @@ export function registerSlashCommands(
 
 	registerPromptWorkflowCommands({
 		pi,
-		run: (params, ctx) => runSlashSubagent(pi, ctx, params),
+		run: async (params, ctx) => {
+			launchSlashSubagent(pi, ctx, params);
+		},
 	});
 
 	pi.registerCommand("subagents-models", {

package/src/slash/slash-live-state.ts

@@ -193,8 +193,8 @@ function cloneResultsWithProgress(
 	progress: NonNullable<Details["progress"]> | undefined,
 ): SingleResult[] {
 	return results.map((result, index) => {
-		const nextProgress = progress?.find((entry) => entry.index === index)
-			?? progress?.[index]
+		const nextProgress = progress?.find((entry) => entry.index === index
+			|| (entry.index === undefined && entry.agent === result.agent))
 			?? result.progress;
 		return nextProgress ? { ...result, progress: nextProgress } : result;
 	});