@selesai/code 0.5.19 → 0.5.21

package/dist/extensions/pi-subagents/src/slash/prompt-workflows.ts

@@ -87,7 +87,7 @@ function parseSkill(value: string | undefined): string | string[] | false | unde
 
 function parseAgent(frontmatter: Record<string, string>): string {
 	const subagent = stringField(frontmatter, "subagent");
-	if (!subagent || subagent === "true") return "delegate";
+	if (!subagent || subagent === "true") return "builder";
 	return subagent;
 }
 
@@ -240,7 +240,7 @@ function workflowParams(workflow: PromptWorkflow, args: string[], runtime: Retur
 function workflowChainStep(workflow: PromptWorkflow, args: string[], runtime: ReturnType<typeof parseRuntimeOptions>): ChainStep {
 	const params = workflowParams(workflow, args, runtime);
 	return {
-		agent: params.agent ?? "delegate",
+		agent: params.agent ?? "builder",
 		task: params.task,
 		...(params.model ? { model: params.model } : {}),
 		...(params.skill !== undefined ? { skill: params.skill } : {}),

package/dist/extensions/pi-subagents/src/slash/selector.ts

@@ -0,0 +1,147 @@
+import { DynamicBorder, keyHint, rawKeyHint, type Theme } from "@selesai/code";
+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/dist/extensions/pi-subagents/src/slash/slash-commands.ts

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { keyText, type ExtensionAPI, type ExtensionContext } from "@selesai/code";
-import { Key, matchesKey } from "@earendil-works/pi-tui";
+import { Key, matchesKey, type Component, type TUI } from "@earendil-works/pi-tui";
 import { BUILTIN_AGENT_NAMES, discoverAgents, discoverAgentsAll, type ChainConfig } from "../agents/agents.ts";
 import {
 	DEFAULT_PROVIDER_MODELS_MAX_AGE_DAYS,
@@ -16,11 +16,16 @@ import {
 import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
 import { isDynamicParallelStep, isParallelStep, type ChainStep } from "../shared/settings.ts";
 import { findModelInfo, toModelInfo } from "../shared/model-info.ts";
-import { formatTokens } from "../shared/formatters.ts";
+import { formatTokens, shortenPath } from "../shared/formatters.ts";
+import { listAsyncRuns, formatAsyncRunProgressLabel, type AsyncRunSummary } from "../runs/background/async-status.ts";
+import { scheduledRunStorePath } from "../runs/background/scheduled-runs.ts";
+import { SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/pi-args.ts";
 import { assertJsonSchemaObject } from "../runs/shared/structured-output.ts";
 import { validateAcceptanceInput } from "../runs/shared/acceptance.ts";
 import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.ts";
 import { registerPromptWorkflowCommands } from "./prompt-workflows.ts";
+import { openSubagentsAdmin } from "./subagents-admin.ts";
+import { openSubagentFleet } from "../tui/fleet.ts";
 import {
 	applySlashUpdate,
 	buildSlashInitialResult,
@@ -36,6 +41,7 @@ import {
 	SLASH_SUBAGENT_RESPONSE_EVENT,
 	SLASH_SUBAGENT_STARTED_EVENT,
 	SLASH_SUBAGENT_UPDATE_EVENT,
+	ASYNC_DIR,
 	type Details,
 	type JsonSchemaObject,
 	type SingleResult,
@@ -221,6 +227,160 @@ async function withSlashStatus<T>(
 	}
 }
 
+type Theme = ExtensionContext["ui"]["theme"];
+
+type StopSelectorTarget = {
+	kind: "async" | "scheduled";
+	id: string;
+	label: string;
+	detail: string;
+	actionLabel: string;
+};
+
+type StopSelectorResult = { confirmed: boolean; target?: StopSelectorTarget };
+
+function commandForTarget(target: StopSelectorTarget): string {
+	return target.kind === "scheduled"
+		? `subagent({ action: "schedule-cancel", id: ${JSON.stringify(target.id)} })`
+		: `subagent({ action: "stop", id: ${JSON.stringify(target.id)} })`;
+}
+
+function formatAsyncStopTarget(run: AsyncRunSummary): StopSelectorTarget {
+	const progress = formatAsyncRunProgressLabel(run);
+	const cwd = run.cwd ? shortenPath(run.cwd) : shortenPath(run.asyncDir);
+	return {
+		kind: "async",
+		id: run.id,
+		label: `${run.id} · ${run.mode} · ${progress}`,
+		detail: `${run.state} · ${cwd}`,
+		actionLabel: "stop async run",
+	};
+}
+
+function scheduledStopTargets(ctx: ExtensionContext, state: SubagentState): StopSelectorTarget[] {
+	const sessionId = state.currentSessionId ?? ctx.sessionManager.getSessionId();
+	if (!sessionId) return [];
+	const storePath = scheduledRunStorePath(ctx.cwd, sessionId);
+	if (!fs.existsSync(storePath)) return [];
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(fs.readFileSync(storePath, "utf-8"));
+	} catch {
+		return [];
+	}
+	const jobs = parsed && typeof parsed === "object" && Array.isArray((parsed as { jobs?: unknown }).jobs)
+		? (parsed as { jobs: Array<Record<string, unknown>> }).jobs
+		: [];
+	return jobs
+		.filter((job) => job.state === "scheduled" && typeof job.id === "string" && typeof job.name === "string" && typeof job.runAt === "number")
+		.sort((left, right) => Number(left.runAt) - Number(right.runAt))
+		.map((job) => ({
+			kind: "scheduled" as const,
+			id: String(job.id),
+			label: `${String(job.id)} · ${String(job.name)}`,
+			detail: `scheduled · ${new Date(Number(job.runAt)).toISOString()}`,
+			actionLabel: "cancel scheduled run",
+		}));
+}
+
+function discoverStopTargets(ctx: ExtensionContext, state: SubagentState): StopSelectorTarget[] {
+	const sessionId = state.currentSessionId ?? ctx.sessionManager.getSessionId() ?? undefined;
+	const asyncTargets = listAsyncRuns(ASYNC_DIR, {
+		states: ["queued", "running"],
+		...(sessionId ? { sessionId } : {}),
+	}).map(formatAsyncStopTarget);
+	return [...asyncTargets, ...scheduledStopTargets(ctx, state)];
+}
+
+function stopFallbackText(targets: StopSelectorTarget[]): string {
+	if (targets.length === 0) return "No active current-session async runs or scheduled subagent runs to stop.";
+	const lines = ["Subagent stop targets:", ""];
+	for (const target of targets) {
+		lines.push(`- ${target.label}`);
+		lines.push(`  ${target.detail}`);
+		lines.push(`  ${target.actionLabel}: ${commandForTarget(target)}`);
+		if (target.kind === "async") lines.push(`  slash: /subagents-stop ${target.id}`);
+	}
+	return lines.join("\n");
+}
+
+class SubagentsStopSelector implements Component {
+	readonly width = 84;
+	private selected = 0;
+	private confirming = false;
+	private readonly tui: TUI;
+	private readonly theme: Theme;
+	private readonly targets: StopSelectorTarget[];
+	private readonly done: (result: StopSelectorResult) => void;
+
+	constructor(tui: TUI, theme: Theme, targets: StopSelectorTarget[], done: (result: StopSelectorResult) => void) {
+		this.tui = tui;
+		this.theme = theme;
+		this.targets = targets;
+		this.done = done;
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+			this.done({ confirmed: false });
+			return;
+		}
+		if (this.confirming) {
+			if (matchesKey(data, "return") || data.toLowerCase() === "y") {
+				this.done({ confirmed: true, target: this.targets[this.selected] });
+				return;
+			}
+			if (data.toLowerCase() === "n" || matchesKey(data, "backspace")) {
+				this.confirming = false;
+				this.tui.requestRender();
+			}
+			return;
+		}
+		if (matchesKey(data, "up")) {
+			this.selected = Math.max(0, this.selected - 1);
+			this.tui.requestRender();
+			return;
+		}
+		if (matchesKey(data, "down")) {
+			this.selected = Math.min(this.targets.length - 1, this.selected + 1);
+			this.tui.requestRender();
+			return;
+		}
+		if (matchesKey(data, "return")) {
+			this.confirming = true;
+			this.tui.requestRender();
+		}
+	}
+
+	render(width: number): string[] {
+		const contentWidth = Math.max(40, Math.min(this.width, width || this.width));
+		const lines = [this.theme.bold("Stop subagent run"), this.theme.fg("dim", "Select a current-session async run to stop, or a scheduled run to cancel."), ""];
+		const maxRows = 10;
+		const start = Math.max(0, Math.min(this.selected - maxRows + 1, Math.max(0, this.targets.length - maxRows)));
+		for (let index = start; index < Math.min(this.targets.length, start + maxRows); index++) {
+			const target = this.targets[index]!;
+			const selected = index === this.selected;
+			const marker = selected ? "›" : " ";
+				const actionLabel = target.actionLabel;
+			const action = target.kind === "scheduled" ? this.theme.fg("warning", actionLabel) : this.theme.fg("accent", actionLabel);
+			const labelWidth = Math.max(0, contentWidth - marker.length - actionLabel.length - 2);
+			lines.push(`${marker} ${action} ${target.label.slice(0, labelWidth)}`);
+			if (selected) lines.push(this.theme.fg("dim", `  ${target.detail}`.slice(0, contentWidth)));
+		}
+		if (this.targets.length > maxRows) lines.push(this.theme.fg("dim", `Showing ${start + 1}-${Math.min(this.targets.length, start + maxRows)} of ${this.targets.length}`));
+		lines.push("");
+		if (this.confirming) {
+			const target = this.targets[this.selected]!;
+			lines.push(this.theme.fg("warning", `Confirm: ${target.actionLabel} ${target.id}?`));
+			if (target.kind === "async") lines.push(this.theme.fg("dim", "Stop ends this run; use interrupt for a resumable pause."));
+			lines.push(this.theme.fg("dim", "Enter/Y confirms · N returns · Esc cancels"));
+		} else {
+			lines.push(this.theme.fg("dim", "↑/↓ select · Enter confirm · Esc cancel"));
+		}
+		return lines;
+	}
+}
+
 function emptyUsage(): Usage {
 	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
 }
@@ -334,8 +494,8 @@ function parseSingleRequiredArg(args: string, usage: string): { ok: true; value:
 	return { ok: true, value: parts[0]! };
 }
 
-function getProfileWorkerModel(profile: { subagents?: { agentOverrides?: Record<string, { model?: string }> } }): string | undefined {
-	const model = profile.subagents?.agentOverrides?.worker?.model;
+function getProfileBuilderModel(profile: { subagents?: { agentOverrides?: Record<string, { model?: string }> } }): string | undefined {
+	const model = profile.subagents?.agentOverrides?.builder?.model;
 	return typeof model === "string" && model.trim() ? model.trim() : undefined;
 }
 
@@ -577,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 }
@@ -841,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, verified, or reviewed acceptance contracts.`);
+		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.`);
 	}
 }
 
@@ -977,6 +1144,32 @@ export function registerSlashCommands(
 	pi: ExtensionAPI,
 	state: SubagentState,
 ): void {
+	let fleetOpen = false;
+	const showFleet = async (ctx: ExtensionContext) => {
+		state.lastUiContext = ctx;
+		if (!ctx.hasUI) {
+			await runSlashSubagent(pi, ctx, { action: "status", view: "fleet" });
+			return;
+		}
+		if (fleetOpen) {
+			ctx.ui.notify("Subagent fleet inspector is already open.", "info");
+			return;
+		}
+		fleetOpen = true;
+		try {
+			await openSubagentFleet(ctx, state);
+		} finally {
+			fleetOpen = false;
+		}
+	};
+
+	pi.registerCommand("subagents", {
+		description: "Administer subagents: inspect metadata and update models, thinking, or prompts",
+		handler: async (args, ctx) => {
+			await openSubagentsAdmin(pi, ctx, args);
+		},
+	});
+
 	pi.registerCommand("run", {
 		description: "Run a subagent directly: /run agent[output=file] [task] [--bg] [--fork]",
 		getArgumentCompletions: makeAgentCompletions(state, false),
@@ -1003,12 +1196,12 @@ 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);
 		},
 	});
 
 	pi.registerCommand("chain", {
-		description: "Run agents in sequence: /chain scout \"task\" -> planner [--bg] [--fork]",
+		description: "Run agents in sequence: /chain explorer \"task\" -> architect [--bg] [--fork]",
 		getArgumentCompletions: makeAgentCompletions(state, true),
 		handler: async (args, ctx) => {
 			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
@@ -1017,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);
 		},
 	});
 
@@ -1047,12 +1240,12 @@ 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);
 		},
 	});
 
 	pi.registerCommand("parallel", {
-		description: "Run agents in parallel: /parallel scout \"task1\" -> reviewer \"task2\" [--bg] [--fork]",
+		description: "Run agents in parallel: /parallel explorer \"task1\" -> commentator \"task2\" [--bg] [--fork]",
 		getArgumentCompletions: makeAgentCompletions(state, true),
 		handler: async (args, ctx) => {
 			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
@@ -1071,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);
 		},
 	});
 
@@ -1090,15 +1283,64 @@ export function registerSlashCommands(
 	});
 
 	pi.registerCommand("subagents-fleet", {
-		description: "Show active subagent fleet status and transcript commands",
-		handler: async (_args, ctx) => {
-			await runSlashSubagent(pi, ctx, { action: "status", view: "fleet" });
+		description: "Open the live, inspection-only subagent fleet",
+		handler: async (_args, ctx) => showFleet(ctx),
+	});
+
+	pi.registerShortcut(Key.ctrlAlt("f"), {
+		description: "Open subagent fleet inspector",
+		handler: async (ctx) => showFleet(ctx),
+	});
+
+	pi.registerCommand("subagents-stop", {
+		description: "Stop a current-session async subagent run",
+		handler: async (args, ctx) => {
+			const id = args.trim();
+			if (id) {
+				await runSlashSubagent(pi, ctx, { action: "stop", id });
+				return;
+			}
+
+			if (process.env[SUBAGENT_FANOUT_CHILD_ENV] === "1") {
+				sendSlashText(pi, "Selector unavailable in child-safe fanout mode. Pass an explicit current-session top-level async run id, for example `/subagents-stop <run-id>` or `subagent({ action: \"stop\", id: \"<run-id>\" })`.");
+				return;
+			}
+
+			let targets: StopSelectorTarget[];
+			try {
+				targets = discoverStopTargets(ctx, state);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				ctx.ui.notify(message, "error");
+				return;
+			}
+			if (!ctx.hasUI) {
+				sendSlashText(pi, stopFallbackText(targets));
+				return;
+			}
+			if (targets.length === 0) {
+				ctx.ui.notify("No active current-session async runs or scheduled subagent runs to stop.", "info");
+				return;
+			}
+
+			const result = await ctx.ui.custom<StopSelectorResult>(
+				(tui, theme, _kb, done) => new SubagentsStopSelector(tui, theme, targets, done),
+				{ overlay: true, overlayOptions: { anchor: "center", width: 88, maxHeight: "80%" } },
+			);
+			if (!result?.confirmed || !result.target) return;
+			if (result.target.kind === "scheduled") {
+				await runSlashSubagent(pi, ctx, { action: "schedule-cancel", id: result.target.id });
+				return;
+			}
+			await runSlashSubagent(pi, ctx, { action: "stop", id: result.target.id });
 		},
 	});
 
 	registerPromptWorkflowCommands({
 		pi,
-		run: (params, ctx) => runSlashSubagent(pi, ctx, params),
+		run: async (params, ctx) => {
+			launchSlashSubagent(pi, ctx, params);
+		},
 	});
 
 	pi.registerCommand("subagents-models", {
@@ -1153,7 +1395,7 @@ export function registerSlashCommands(
 			try {
 				await withSlashStatus(ctx, `Loading profile ${parsed.value}…`, async () => {
 					const { profile } = readSubagentProfile(parsed.value);
-					const workerModel = getProfileWorkerModel(profile);
+					const builderModel = getProfileBuilderModel(profile);
 					const result = applySubagentProfile(parsed.value);
 					const lines = [
 						`Loaded subagent profile: ${parsed.value}`,
@@ -1161,24 +1403,24 @@ export function registerSlashCommands(
 						`Updated: ${result.settingsPath}`,
 					];
 
-					if (workerModel && typeof pi.setModel === "function" && typeof ctx.modelRegistry?.find === "function" && typeof ctx.modelRegistry?.getAvailable === "function") {
+					if (builderModel && typeof pi.setModel === "function" && typeof ctx.modelRegistry?.find === "function" && typeof ctx.modelRegistry?.getAvailable === "function") {
 						const shouldSwitch = await ctx.ui.confirm(
 							"",
-							`Profile loaded. Also switch this session to the profile worker model?\n\n${workerModel}`,
+							`Profile loaded. Also switch this session to the profile builder model?\n\n${builderModel}`,
 						);
 						if (shouldSwitch) {
-							const modelInfo = findModelInfo(workerModel, ctx.modelRegistry.getAvailable().map(toModelInfo));
+							const modelInfo = findModelInfo(builderModel, ctx.modelRegistry.getAvailable().map(toModelInfo));
 							const model = modelInfo ? ctx.modelRegistry.find(modelInfo.provider, modelInfo.id) : undefined;
 							if (!modelInfo || !model) {
-								lines.push(`Could not switch current session model: '${workerModel}' is not available in the current model registry.`);
+								lines.push(`Could not switch current session model: '${builderModel}' is not available in the current model registry.`);
 							} else {
 								const success = await pi.setModel(model);
 								if (success) lines.push(`Current session model switched to: ${modelInfo.fullId}`);
-								else lines.push(`Could not switch current session model to '${workerModel}': no API key or provider access is available.`);
+								else lines.push(`Could not switch current session model to '${builderModel}': no API key or provider access is available.`);
 							}
 						}
-					} else if (workerModel) {
-						lines.push(`Profile worker model: ${workerModel}`);
+					} else if (builderModel) {
+						lines.push(`Profile builder model: ${builderModel}`);
 					}
 
 					sendSlashText(pi, lines.join("\n"));

package/dist/extensions/pi-subagents/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;
 	});