@selesai/code 0.6.2 → 0.7.0

package/dist/extensions/pi-subagents/test/integration/slash-commands.test.ts

@@ -364,7 +364,7 @@ describe("subagents watchdog slash command", { skip: !available ? "watchdog comm
 				fs.writeFileSync(settingsPath, JSON.stringify({
 					other: true,
 					subagents: {
-						agentOverrides: { scout: { model: "openai/test" } },
+						agentOverrides: { explorer: { model: "openai/test" } },
 						watchdog: { agentEndTimeoutMs: 1234, main: { enabled: false, model: "openai/watchdog" } },
 					},
 				}, null, 2), "utf-8");
@@ -375,7 +375,7 @@ describe("subagents watchdog slash command", { skip: !available ? "watchdog comm
 				await commands.get("subagents-watchdog")!.handler("on", createCommandContext({ cwd: root }));
 				let settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
 				assert.equal(settings.other, true);
-				assert.equal(settings.subagents.agentOverrides.scout.model, "openai/test");
+				assert.equal(settings.subagents.agentOverrides.explorer.model, "openai/test");
 				assert.equal(settings.subagents.watchdog.agentEndTimeoutMs, 1234);
 				assert.equal(settings.subagents.watchdog.enabled, true);
 				assert.equal(settings.subagents.watchdog.main.enabled, true);
@@ -678,1685 +678,44 @@ describe("slash command custom message delivery", { skip: !available ? "slash-co
 		assert.equal((visibleSnapshot.result.content[0] as { text?: string }).text, "Subagent failed");
 	});
 
-	it("/parallel forwards inline output behavior config", async () => {
-		const commands = new Map<string, { handler(args: string, ctx: unknown): Promise<void> }>();
-		const events = createEventBus();
-		let requestedParams: unknown;
-		events.on(SLASH_SUBAGENT_REQUEST_EVENT, (data) => {
-			const payload = data as { requestId: string; params?: unknown };
-			requestedParams = payload.params;
-			events.emit(SLASH_SUBAGENT_STARTED_EVENT, { requestId: payload.requestId });
-			events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, {
-				requestId: payload.requestId,
-				result: {
-					content: [{ type: "text", text: "parallel finished" }],
-					details: { mode: "parallel", results: [] },
-				},
-				isError: false,
-			});
-		});
-
-		const pi = {
-			events,
-			registerCommand(name: string, spec: { handler(args: string, ctx: unknown): Promise<void> }) {
-				commands.set(name, spec);
-			},
-			registerShortcut() {},
-			sendMessage(_message: unknown) {},
-		};
-
-		registerSlashCommands!(pi, createState(process.cwd()));
-		await commands.get("parallel")!.handler("explorer[output=x.md,outputMode=file-only,reads=a.md+b.md,progress] -- Review", createCommandContext());
-
-		assert.deepEqual(requestedParams, {
-			tasks: [{ agent: "explorer", task: "Review", output: "x.md", outputMode: "file-only", reads: ["a.md", "b.md"], progress: true }],
-			clarify: false,
-			agentScope: "both",
-		});
-	});
-
-	it("/parallel no longer hard-blocks runs above the old 8-task limit before the executor responds", async () => {
-		const sent: unknown[] = [];
-		const commands = new Map<string, { handler(args: string, ctx: unknown): Promise<void> }>();
-		const events = createEventBus();
-		let requestedTasks = 0;
-		events.on(SLASH_SUBAGENT_REQUEST_EVENT, (data) => {
-			const payload = data as { requestId: string; params?: { tasks?: unknown[] } };
-			requestedTasks = payload.params?.tasks?.length ?? 0;
-			events.emit(SLASH_SUBAGENT_STARTED_EVENT, { requestId: payload.requestId });
-			events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, {
-				requestId: payload.requestId,
-				result: {
-					content: [{ type: "text", text: "parallel finished" }],
-					details: { mode: "parallel", results: [] },
-				},
-				isError: false,
-			});
-		});
-
-		const pi = {
-			events,
-			registerCommand(name: string, spec: { handler(args: string, ctx: unknown): Promise<void> }) {
-				commands.set(name, spec);
-			},
-			registerShortcut() {},
-			sendMessage(message: unknown) {
-				sent.push(message);
-			},
-		};
-
-		registerSlashCommands!(pi, createState(process.cwd()));
-		const args = Array.from({ length: 9 }, (_, index) => `explorer \"task ${index + 1}\"`).join(" -> ");
-		await commands.get("parallel")!.handler(args, createCommandContext());
-		await new Promise<void>((resolve) => setImmediate(resolve));
-
-		assert.equal(requestedTasks, 9);
-		assert.equal(sent.length, 2);
-		assert.match((sent[1] as { content?: string }).content ?? "", /parallel finished/);
-	});
-});
-
-describe("saved chain slash command", { skip: !available ? "slash-commands.ts not importable" : undefined }, () => {
-	beforeEach(() => {
-		clearSlashSnapshots?.();
-	});
-
-	it("/run and /chain accept dotted packaged runtime agent names", async () => {
+	it("/run accepts dotted packaged runtime agent names", async () => {
 		await withTempProject("pi-packaged-agent-slash-", async (root) => {
-			fs.writeFileSync(path.join(root, ".selesai", "agents", "code-analysis.scout.md"), `---
-name: scout
+			fs.writeFileSync(path.join(root, ".selesai", "agents", "code-analysis.explorer.md"), `---
+name: explorer
 package: code-analysis
 description: Fast recon
 ---
 
 Inspect
 `, "utf-8");
-			fs.writeFileSync(path.join(root, ".selesai", "agents", "documentation.writer.md"), `---
-name: writer
-package: documentation
-description: Writer
----
-
-Write
-`, "utf-8");
-
-			const run = await captureSlashCommandParams("run", "code-analysis.scout Investigate", root);
-			assert.deepEqual(run.params, { agent: "code-analysis.scout", task: "Investigate", clarify: false, agentScope: "both" });
-
-			const chain = await captureSlashCommandParams("chain", "code-analysis.scout \"Scan\" -> documentation.writer", root);
-			assert.deepEqual((chain.params as { chain?: Array<{ agent?: string; task?: string }> }).chain?.map(({ agent, task }) => ({ agent, task })), [
-				{ agent: "code-analysis.scout", task: "Scan" },
-				{ agent: "documentation.writer", task: undefined },
-			]);
-
-			await withIsolatedHome(async () => {
-				const commands = new Map<string, RegisteredSlashCommand>();
-				const pi = {
-					events: createEventBus(),
-					registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
-					registerShortcut() {},
-					sendMessage(_message: unknown) {},
-				};
-				registerSlashCommands!(pi, createState(root));
-				const runCompletions = commands.get("run")!.getArgumentCompletions!("code-") as Array<{ value: string; label: string }>;
-				assert.deepEqual(runCompletions.map((completion) => completion.value), ["code-analysis.scout"]);
-				const chainCompletions = commands.get("chain")!.getArgumentCompletions!("code-analysis.scout \"Scan\" -> doc") as Array<{ value: string; label: string }>;
-				assert.deepEqual(chainCompletions.map((completion) => completion.value), ["code-analysis.scout \"Scan\" -> documentation.writer"]);
-				// Regression: bare group-ish syntax inside a `--` shared task is plain text, not
-				// a group separator, so it must not resume agent completion past the task.
-				const pipeInTask = commands.get("chain")!.getArgumentCompletions!("code-analysis.scout -- do x | doc");
-				assert.equal(pipeInTask, null);
-				const openParenInTask = commands.get("chain")!.getArgumentCompletions!("code-analysis.scout -- do (doc");
-				assert.equal(openParenInTask, null);
-				const closeParenInTask = commands.get("chain")!.getArgumentCompletions!("code-analysis.scout -- do ) doc");
-				assert.equal(closeParenInTask, null);
-				const balancedParenInTask = commands.get("chain")!.getArgumentCompletions!("code-analysis.scout -- do (x) doc");
-				assert.equal(balancedParenInTask, null);
-				// Inside an actual parallel group, `|` still separates tasks and completes agents.
-				const groupCompletions = commands.get("chain")!.getArgumentCompletions!("code-analysis.scout \"Scan\" -> (documentation.writer \"w\" | code") as Array<{ value: string; label: string }>;
-				assert.deepEqual(groupCompletions.map((completion) => completion.value), ["code-analysis.scout \"Scan\" -> (documentation.writer \"w\" | code-analysis.scout"]);
-			});
-		});
-	});
-
-	it("/run-chain launches a saved chain with a shared task", async () => {
-		await withTempProject("pi-run-chain-success-", async (root) => {
-			writeProjectChain(root, "review-flow.chain.md", `---
-name: review-flow
-description: Review flow
----
-
-## scout
-
-Scan {task}
-
-## reviewer
-
-Review {previous}
-`);
-
-			const { params } = await captureSlashCommandParams("run-chain", "review-flow -- Audit the auth flow", root);
-			const runParams = params as {
-				chain?: Array<{ agent?: string; task?: string }>;
-				task?: string;
-				clarify?: boolean;
-				agentScope?: string;
-				async?: unknown;
-				context?: unknown;
-			};
-
-			assert.deepEqual(runParams.chain?.map(({ agent, task }) => ({ agent, task })), [
-				{ agent: "scout", task: "Scan {task}" },
-				{ agent: "reviewer", task: "Review {previous}" },
-			]);
-			assert.equal(runParams.task, "Audit the auth flow");
-			assert.equal(runParams.clarify, false);
-			assert.equal(runParams.agentScope, "both");
-			assert.equal(runParams.async, undefined);
-			assert.equal(runParams.context, undefined);
-		});
-	});
-
-	it("/run-chain returns while its foreground subagent is still running", async () => {
-		await withTempProject("pi-run-chain-nonblocking-", async (root) => {
-			writeProjectChain(root, "slow.chain.md", `---
-name: slow
-description: Slow chain
----
-
-## scout
-
-Think for a long time about {task}
-`);
-			const commands = new Map<string, RegisteredSlashCommand>();
-			const events = createEventBus();
-			let requestId: string | undefined;
-			events.on(SLASH_SUBAGENT_REQUEST_EVENT, (data) => {
-				const payload = data as { requestId: string };
-				requestId = payload.requestId;
-				events.emit(SLASH_SUBAGENT_STARTED_EVENT, { requestId });
-			});
-			const pi = {
-				events,
-				registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
-				registerShortcut() {},
-				sendMessage(_message: unknown) {},
-			};
-			registerSlashCommands!(pi, createState(root));
-
-			const returned = await Promise.race([
-				commands.get("run-chain")!.handler("slow -- test UI responsiveness", createCommandContext({ cwd: root })).then(() => true),
-				new Promise<boolean>((resolve) => setTimeout(() => resolve(false), 25)),
-			]);
-			assert.equal(returned, true, "the slash command should not hold the UI while the child runs");
-			assert.ok(requestId);
-			events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, {
-				requestId,
-				result: { content: [{ type: "text", text: "done" }], details: { mode: "chain", results: [] } },
-				isError: false,
-			});
-		});
-	});
 
-	it("/run-chain launches a saved JSON chain with dynamic fanout", async () => {
-		await withTempProject("pi-run-chain-json-dynamic-", async (root) => {
-			writeProjectChain(root, "dynamic-review.chain.json", JSON.stringify({
-				name: "dynamic-review",
-				description: "Dynamic review flow",
-				chain: [
-					{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
-					{
-						expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path", maxItems: 4 },
-						parallel: { agent: "reviewer", task: "Review {target.path}", outputSchema: { type: "object" } },
-						collect: { as: "reviews" },
-					},
-				],
-			}));
-
-			const { params } = await captureSlashCommandParams("run-chain", "dynamic-review -- Audit", root);
-			const runParams = params as { chain?: Array<Record<string, unknown>>; task?: string; clarify?: boolean; agentScope?: string };
-
-			assert.equal(runParams.task, "Audit");
-			assert.equal(runParams.clarify, false);
-			assert.equal(runParams.agentScope, "both");
-			assert.equal(runParams.chain?.[0]?.agent, "scout");
-			assert.deepEqual(runParams.chain?.[1]?.expand, { from: { output: "targets", path: "/items" }, item: "target", key: "/path", maxItems: 4 });
-			assert.deepEqual(runParams.chain?.[1]?.collect, { as: "reviews" });
-		});
-	});
-
-	it("/run-chain preserves saved JSON chain acceptance contracts", async () => {
-		await withTempProject("pi-run-chain-json-acceptance-", async (root) => {
-			writeProjectChain(root, "verified-flow.chain.json", JSON.stringify({
-				name: "verified-flow",
-				description: "Verified flow",
-				chain: [
-					{
-						agent: "worker",
-						task: "Implement fix",
-						acceptance: {
-							level: "verified",
-							verify: [{ id: "tests", command: "npm test" }],
-						},
-					},
-				],
-			}));
-
-			const { params } = await captureSlashCommandParams("run-chain", "verified-flow -- Audit", root);
-			assert.deepEqual((params as { chain?: Array<{ acceptance?: unknown }> }).chain?.[0]?.acceptance, {
-				level: "verified",
-				verify: [{ id: "tests", command: "npm test" }],
-			});
-		});
-	});
-
-	it("/run-chain launches and completes packaged saved chains by dotted runtime name", async () => {
-		await withTempProject("pi-run-chain-packaged-", async (root) => {
-			writeProjectChain(root, "code-analysis.review-flow.chain.md", `---
-name: review-flow
-package: code-analysis
-description: Review flow
----
-
-## code-analysis.scout
-
-Scan {task}
-`);
-
-			const { params } = await captureSlashCommandParams("run-chain", "code-analysis.review-flow -- Audit", root);
-			assert.equal((params as { task?: string }).task, "Audit");
-			assert.deepEqual((params as { chain?: Array<{ agent?: string; task?: string }> }).chain?.map(({ agent, task }) => ({ agent, task })), [
-				{ agent: "code-analysis.scout", task: "Scan {task}" },
-			]);
+			const run = await captureSlashCommandParams("run", "code-analysis.explorer Investigate", root);
+			assert.deepEqual(run.params, { agent: "code-analysis.explorer", task: "Investigate", clarify: false, agentScope: "both" });
 
 			await withIsolatedHome(async () => {
 				const commands = new Map<string, RegisteredSlashCommand>();
-				const pi = {
+				registerSlashCommands!({
 					events: createEventBus(),
 					registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
 					registerShortcut() {},
-					sendMessage(_message: unknown) {},
-				};
-				registerSlashCommands!(pi, createState(root));
-				const completions = commands.get("run-chain")!.getArgumentCompletions!("code-") as Array<{ value: string; label: string }>;
-				assert.deepEqual(completions.map((completion) => completion.value), ["code-analysis.review-flow"]);
+					sendMessage() {},
+				} as never, createState(root));
+				const completions = commands.get("run")!.getArgumentCompletions!("code-") as Array<{ value: string }>;
+				assert.deepEqual(completions.map(({ value }) => value), ["code-analysis.explorer"]);
 			});
 		});
 	});
 
-	it("/run-chain reports an unknown saved chain without launching", async () => {
-		await withTempProject("pi-run-chain-unknown-", async (root) => {
-			const { params, notifications } = await captureSlashCommandParams("run-chain", "missing -- Do work", root);
-
-			assert.equal(params, undefined);
-			assert.deepEqual(notifications, ["Unknown chain: missing"]);
-		});
-	});
-
-	it("/run-chain suggests saved chain names", async () => {
-		await withTempProject("pi-run-chain-completions-", async (root) => {
-			writeProjectChain(root, "review-flow.chain.md", `---
-name: review-flow
-description: Review flow
----
-
-## scout
-
-Scan
-`);
-			writeProjectChain(root, "release-flow.chain.md", `---
-name: release-flow
-description: Release flow
----
-
-## planner
-
-Plan
-`);
-			writeProjectChain(root, "triage.chain.md", `---
-name: triage
-description: Triage flow
----
-
-## scout
-
-Triage
-`);
-
-			await withIsolatedHome(async () => {
-				const commands = new Map<string, RegisteredSlashCommand>();
-				const pi = {
-					events: createEventBus(),
-					registerCommand(name: string, spec: RegisteredSlashCommand) {
-						commands.set(name, spec);
-					},
-					registerShortcut() {},
-					sendMessage(_message: unknown) {},
-				};
-
-				registerSlashCommands!(pi, createState(root));
-				const completions = commands.get("run-chain")!.getArgumentCompletions!("re") as Array<{ value: string; label: string }>;
-				assert.deepEqual(completions.map((completion) => completion.value).sort(), ["release-flow", "review-flow"]);
-				assert.deepEqual(completions.map((completion) => completion.label).sort(), ["release-flow", "review-flow"]);
-				assert.equal(commands.get("run-chain")!.getArgumentCompletions!("review-flow -- "), null);
-			});
-		});
-	});
-
-	it("/run-chain maps --bg to async execution", async () => {
-		await withTempProject("pi-run-chain-bg-", async (root) => {
-			writeProjectChain(root, "review-flow.chain.md", `---
-name: review-flow
-description: Review flow
----
-
-## scout
-
-Scan
-`);
-
-			const { params } = await captureSlashCommandParams("run-chain", "review-flow -- Audit --bg", root);
-
-			assert.equal((params as { async?: unknown }).async, true);
-			assert.equal((params as { context?: unknown }).context, undefined);
-		});
-	});
-
-	it("/run-chain maps --fork to forked context", async () => {
-		await withTempProject("pi-run-chain-fork-", async (root) => {
-			writeProjectChain(root, "review-flow.chain.md", `---
-name: review-flow
-description: Review flow
----
-
-## scout
-
-Scan
-`);
-
-			const { params } = await captureSlashCommandParams("run-chain", "review-flow -- Audit --fork", root);
-
-			assert.equal((params as { context?: unknown }).context, "fork");
-			assert.equal((params as { async?: unknown }).async, undefined);
-		});
-	});
-
-	it("/run-chain prefers a project saved chain over a same-named user chain", async () => {
-		await withTempProject("pi-run-chain-priority-", async (root) => {
-			writeProjectChain(root, "review-flow.chain.md", `---
-name: review-flow
-description: Project review flow
----
-
-## scout
-
-Project chain task
-`);
-
-			const { params } = await captureSlashCommandParams("run-chain", "review-flow -- Shared task", root, () => {
-				const userChainsDir = path.join(os.homedir(), ".selesai", "agent", "chains");
-				fs.mkdirSync(userChainsDir, { recursive: true });
-				fs.writeFileSync(path.join(userChainsDir, "review-flow.chain.md"), `---
-name: review-flow
-description: User review flow
----
-
-## scout
-
-User chain task
-`, "utf-8");
-			});
-
-			assert.equal((params as { chain?: Array<{ task?: string }> }).chain?.[0]?.task, "Project chain task");
-		});
-	});
-
-	it("/run-chain resolves saved outputSchema files at the command boundary", async () => {
-		await withTempProject("pi-run-chain-schema-", async (root) => {
-			const schemasDir = path.join(root, ".selesai", "chains", "schemas");
-			fs.mkdirSync(schemasDir, { recursive: true });
-			fs.writeFileSync(path.join(schemasDir, "finding.schema.json"), JSON.stringify({ type: "object", properties: { ok: { type: "boolean" } } }), "utf-8");
-			writeProjectChain(root, "schema-flow.chain.md", `---
-name: schema-flow
-description: Schema flow
----
-
-## scout
-outputSchema: ./schemas/finding.schema.json
-
-Gather context
-`);
-
-			const { params } = await captureSlashCommandParams("run-chain", "schema-flow -- Shared task", root);
-
-			assert.deepEqual((params as { chain?: Array<{ outputSchema?: unknown }> }).chain?.[0]?.outputSchema, {
-				type: "object",
-				properties: { ok: { type: "boolean" } },
-			});
-		});
-	});
-
-	it("/run-chain preserves saved step behavior fields", async () => {
-		await withTempProject("pi-run-chain-fields-", async (root) => {
-			writeProjectChain(root, "field-flow.chain.md", `---
-name: field-flow
-description: Field flow
----
-
-## scout
-output: context.md
-outputMode: file-only
-reads: input.md, notes.md
-model: openai/gpt-5.5
-skills: research, audit
-progress: true
-
-Gather context
-`);
-
-			const { params } = await captureSlashCommandParams("run-chain", "field-flow -- Shared task", root);
-
-			assert.deepEqual((params as { chain?: unknown[] }).chain?.[0], {
-				agent: "scout",
-				task: "Gather context",
-				output: "context.md",
-				outputMode: "file-only",
-				reads: ["input.md", "notes.md"],
-				progress: true,
-				skill: ["research", "audit"],
-				model: "openai/gpt-5.5",
-			});
-		});
-	});
-
-	it("/chain parses a parenthesized parallel group into a { parallel: [...] } step", async () => {
-		await withTempProject("pi-chain-group-slash-", async (root) => {
-			for (const name of ["scout", "reviewer", "writer"]) {
-				fs.writeFileSync(path.join(root, ".selesai", "agents", `${name}.md`), `---\nname: ${name}\ndescription: ${name}\n---\n\nBody\n`, "utf-8");
-			}
-
-			const { params, notifications } = await captureSlashCommandParams("chain", 'scout "scan" -> (reviewer "A" | reviewer "B") -> writer "fix"', root);
-			assert.deepEqual(notifications, []);
-			const built = params as { chain?: Array<Record<string, unknown>>; task?: string };
-			assert.equal(built.task, "scan");
-			assert.equal(built.chain?.length, 3);
-			assert.equal(built.chain?.[0]?.agent, "scout");
-			const parallel = built.chain?.[1]?.parallel as Array<{ agent: string; task: string }>;
-			assert.ok(Array.isArray(parallel), "second step should be a parallel group");
-			assert.deepEqual(parallel.map(({ agent, task }) => ({ agent, task })), [
-				{ agent: "reviewer", task: "A" },
-				{ agent: "reviewer", task: "B" },
-			]);
-			assert.equal(built.chain?.[2]?.agent, "writer");
-		});
-	});
-
-	it("/chain reports parallel-group errors as notifications and does not launch", async () => {
-		await withTempProject("pi-chain-group-error-", async (root) => {
-			for (const name of ["scout", "reviewer"]) {
-				fs.writeFileSync(path.join(root, ".selesai", "agents", `${name}.md`), `---\nname: ${name}\ndescription: ${name}\n---\n\nBody\n`, "utf-8");
-			}
-
-			const { params, notifications } = await captureSlashCommandParams("chain", 'scout "scan" -> (reviewer "A")', root);
-			assert.equal(params, undefined);
-			assert.equal(notifications.length, 1);
-			assert.match(notifications[0] ?? "", /at least two/i);
-		});
-	});
-
-	it("/chain carries inline metadata and group options through to params", async () => {
-		await withTempProject("pi-chain-group-meta-", async (root) => {
-			for (const name of ["scout", "reviewer", "writer"]) {
-				fs.writeFileSync(path.join(root, ".selesai", "agents", `${name}.md`), `---\nname: ${name}\ndescription: ${name}\n---\n\nBody\n`, "utf-8");
-			}
-
-			const { params, notifications } = await captureSlashCommandParams(
-				"chain",
-				'scout[as=ctx,phase=recon] "scan" -> (reviewer "A" | writer "B")[concurrency=2,failFast]',
-				root,
-			);
-			assert.deepEqual(notifications, []);
-			const built = params as { chain?: Array<Record<string, unknown>> };
-			assert.equal(built.chain?.[0]?.as, "ctx");
-			assert.equal(built.chain?.[0]?.phase, "recon");
-			const group = built.chain?.[1] as Record<string, unknown>;
-			assert.equal((group.parallel as unknown[]).length, 2);
-			assert.equal(group.concurrency, 2);
-			assert.equal(group.failFast, true);
-		});
-	});
-
-	it("/chain tab-completion works inside parallel groups", async () => {
-		await withTempProject("pi-chain-group-complete-", async (root) => {
-			for (const name of ["scout", "reviewer", "writer"]) {
-				fs.writeFileSync(path.join(root, ".selesai", "agents", `${name}.md`), `---\nname: ${name}\ndescription: ${name}\n---\n\nBody\n`, "utf-8");
-			}
-			await withIsolatedHome(async () => {
-				const commands = new Map<string, RegisteredSlashCommand>();
-				const pi = {
-					events: createEventBus(),
-					registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
-					registerShortcut() {},
-					sendMessage(_message: unknown) {},
-				};
-				registerSlashCommands!(pi, createState(root));
-				const complete = (prefix: string) =>
-					(commands.get("chain")!.getArgumentCompletions!(prefix) as Array<{ value: string }> | null)?.map((c) => c.value) ?? null;
-
-				// after `(`
-				assert.deepEqual(complete('scout "scan" -> (rev'), ['scout "scan" -> (reviewer']);
-				// after `|`
-				assert.deepEqual(complete('scout "scan" -> (reviewer "A" | wr'), ['scout "scan" -> (reviewer "A" | writer']);
-				// after a bare `|` a space is inserted before every suggested agent
-				const barePipe = complete('scout "scan" -> (reviewer "A" |');
-				assert.ok(barePipe && barePipe.length > 0);
-				assert.ok(barePipe.every((v) => v.startsWith('scout "scan" -> (reviewer "A" | ')));
-				assert.ok(barePipe.includes('scout "scan" -> (reviewer "A" | writer'));
-				// inside an open quote: no agent completion
-				assert.equal(complete('scout "scan'), null);
-			});
-		});
-	});
-});
-
-
-describe("subagents-models slash command", { skip: !available ? "slash-commands.ts not importable" : undefined }, () => {
-	beforeEach(() => {
-		clearSlashSnapshots?.();
-	});
-
-	it("routes to the models tool action", async () => {
-		const { params } = await captureSlashCommandParams("subagents-models", "", process.cwd());
-		assert.deepEqual(params, { action: "models" });
-	});
-
-	it("passes an optional builtin filter", async () => {
-		const { params } = await captureSlashCommandParams("subagents-models", "explorer", process.cwd());
-		assert.deepEqual(params, { action: "models", agent: "explorer" });
-	});
-
-	it("rejects invalid builtin filters without launching", async () => {
-		const { params, notifications } = await captureSlashCommandParams("subagents-models", "not-a-builtin", process.cwd());
-		assert.equal(params, undefined);
-		assert.deepEqual(notifications, ["Unknown builtin agent: not-a-builtin"]);
-	});
-
-	it("suggests builtin agent names", async () => {
-		await withIsolatedHome(async () => {
-			const commands = new Map<string, RegisteredSlashCommand>();
-			const pi = {
-				events: createEventBus(),
-				registerCommand(name: string, spec: RegisteredSlashCommand) {
-					commands.set(name, spec);
-				},
-				registerShortcut() {},
-				sendMessage(_message: unknown) {},
-			};
-
-			registerSlashCommands!(pi, createState(process.cwd()));
-			const completions = commands.get("subagents-models")!.getArgumentCompletions!("ex") as Array<{ value: string; label: string }>;
-			assert.deepEqual(completions.map((completion) => completion.value), ["explorer"]);
-		});
-	});
-});
-
-describe("subagent cost slash command", { skip: !available ? "slash-commands.ts not importable" : undefined }, () => {
-	it("reports parent and child usage from the current session branch", async () => {
-		const sent: unknown[] = [];
-		const commands = new Map<string, RegisteredSlashCommand>();
-		const pi = {
-			events: createEventBus(),
-			registerCommand(name: string, spec: RegisteredSlashCommand) {
-				commands.set(name, spec);
-			},
-			registerShortcut() {},
-			sendMessage(message: unknown) { sent.push(message); },
-		};
-		const parentUsage = {
-			input: 100,
-			output: 50,
-			cacheRead: 10,
-			cacheWrite: 5,
-			cost: { input: 0.001, output: 0.002, cacheRead: 0, cacheWrite: 0, total: 0.003 },
-		};
-		const childUsage = { input: 20, output: 10, cacheRead: 2, cacheWrite: 1, cost: 0.004, turns: 1 };
-		const slashChildUsage = { input: 30, output: 15, cacheRead: 0, cacheWrite: 0, cost: 0.005, turns: 2 };
-		registerSlashCommands!(pi, createState(process.cwd()));
-		await commands.get("subagent-cost")!.handler("", createCommandContext({
-			sessionManager: {
-				getBranch: () => [
-					{ type: "message", message: { role: "assistant", usage: parentUsage } },
-					{
-						type: "message",
-						message: {
-							role: "toolResult",
-							toolName: "subagent",
-							details: {
-								mode: "single",
-								results: [{ agent: "worker", task: "fix", exitCode: 0, messages: [], usage: childUsage, sessionFile: "/tmp/worker.jsonl" }],
-							},
-						},
-					},
-					{
-						type: "custom_message",
-						customType: SLASH_RESULT_TYPE,
-						details: {
-							requestId: "slash-1",
-							result: {
-								content: [{ type: "text", text: "done" }],
-								details: {
-									mode: "single",
-									results: [{ agent: "reviewer", task: "review", exitCode: 0, messages: [], usage: slashChildUsage }],
-								},
-							},
-						},
-					},
-				],
-			},
-		}));
-
-		const output = String((sent[0] as { content?: unknown }).content ?? "");
-		assert.match(output, /Parent: ↑100 ↓50 \$0\.0030/);
-		assert.match(output, /Child 1 \(worker\): ↑20 ↓10 \$0\.0040/);
-		assert.match(output, /Session: \/tmp\/worker\.jsonl/);
-		assert.match(output, /Child 2 \(reviewer\): ↑30 ↓15 \$0\.0050/);
-		assert.match(output, /Children: ↑50 ↓25 \$0\.0090/);
-		assert.match(output, /Total: ↑150 ↓75 \$0\.0120/);
-	});
-});
-
-describe("subagent profiles slash commands", { skip: !available ? "slash-commands.ts not importable" : undefined }, () => {
-	it("lists saved profiles", async () => {
-		await withIsolatedHome(async () => {
-			const profilesDir = path.join(process.env.HOME!, ".selesai", "agent", "profiles", "pi-subagents");
-			fs.mkdirSync(profilesDir, { recursive: true });
-			fs.writeFileSync(path.join(profilesDir, "openai-codex.quota.json"), JSON.stringify({ subagents: { agentOverrides: {} } }));
-			fs.writeFileSync(path.join(profilesDir, "openai-codex.quality.json"), JSON.stringify({ subagents: { agentOverrides: {} } }));
-			const sent: unknown[] = [];
-			const commands = new Map<string, RegisteredSlashCommand>();
-			const pi = {
-				events: createEventBus(),
-				registerCommand(name: string, spec: RegisteredSlashCommand) {
-					commands.set(name, spec);
-				},
-				registerShortcut() {},
-				sendMessage(message: unknown) { sent.push(message); },
-			};
-			registerSlashCommands!(pi, createState(process.cwd()));
-			await commands.get("subagents-profiles")!.handler("", createCommandContext());
-			assert.match(String((sent[0] as { content?: unknown }).content ?? ""), /openai-codex\.quota/);
-			assert.match(String((sent[0] as { content?: unknown }).content ?? ""), /openai-codex\.quality/);
-		});
-	});
-
-	it("loads a saved profile into user settings", async () => {
-		await withIsolatedHome(async () => {
-			const profilesDir = path.join(process.env.HOME!, ".selesai", "agent", "profiles", "pi-subagents");
-			fs.mkdirSync(profilesDir, { recursive: true });
-			fs.writeFileSync(path.join(profilesDir, "openai-codex.quota.json"), JSON.stringify({
-				subagents: { agentOverrides: {
-					scout: { model: "openai-codex/gpt-5.3-codex-spark" },
-					worker: { model: "openai-codex/gpt-5.4" },
-				} },
-			}, null, 2));
-			const sent: unknown[] = [];
-			const commands = new Map<string, RegisteredSlashCommand>();
-			const pi = {
-				events: createEventBus(),
-				registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
-				registerShortcut() {},
-				sendMessage(message: unknown) { sent.push(message); },
-			};
-			registerSlashCommands!(pi, createState(process.cwd()));
-			await commands.get("subagents-load-profile")!.handler("openai-codex.quota", createCommandContext());
-			const settings = JSON.parse(fs.readFileSync(path.join(process.env.HOME!, ".selesai", "agent", "settings.json"), "utf-8"));
-			assert.equal(settings.subagents.agentOverrides.scout.model, "openai-codex/gpt-5.3-codex-spark");
-			assert.equal(settings.subagents.agentOverrides.worker.model, "openai-codex/gpt-5.4");
-			assert.doesNotMatch(String((sent[0] as { content?: unknown }).content ?? ""), /run \/reload/);
-		});
-	});
-
-	it("can switch the current session model to the loaded profile worker model", async () => {
-		await withIsolatedHome(async () => {
-			const profilesDir = path.join(process.env.HOME!, ".selesai", "agent", "profiles", "pi-subagents");
-			fs.mkdirSync(profilesDir, { recursive: true });
-			fs.writeFileSync(path.join(profilesDir, "openai-codex.quota.json"), JSON.stringify({
-				subagents: { agentOverrides: { builder: { model: "gpt-5.4:high" } } },
-			}, null, 2));
-			const sent: unknown[] = [];
-			const commands = new Map<string, RegisteredSlashCommand>();
-			let setModelArg: unknown;
-			const resolvedModel = { provider: "openai-codex", id: "gpt-5.4" };
-			const pi = {
-				events: createEventBus(),
-				async setModel(model: unknown) { setModelArg = model; return true; },
-				registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
-				registerShortcut() {},
-				sendMessage(message: unknown) { sent.push(message); },
-			};
-			registerSlashCommands!(pi as never, createState(process.cwd()));
-			await commands.get("subagents-load-profile")!.handler("openai-codex.quota", createCommandContext({
-				confirm: async () => true,
-				modelRegistry: {
-					getAvailable: () => [{ provider: "openai-codex", id: "gpt-5.4" }],
-					find: (provider, id) => provider === "openai-codex" && id === "gpt-5.4" ? resolvedModel : undefined,
-				},
-			}) as never);
-			assert.equal(setModelArg, resolvedModel);
-			assert.match(String((sent[0] as { content?: unknown }).content ?? ""), /Current session model switched to: openai-codex\/gpt-5.4/);
-		});
-	});
-
-	it("refreshes a provider model catalog", async () => {
-		await withIsolatedHome(async () => {
-			const sent: unknown[] = [];
-			const commands = new Map<string, RegisteredSlashCommand>();
-			const pi = {
-				events: createEventBus(),
-				exec: async () => ({ stdout: "OK\n", stderr: "", code: 0, killed: false }),
-				registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
-				registerShortcut() {},
-				sendMessage(message: unknown) { sent.push(message); },
-			};
-			registerSlashCommands!(pi, createState(process.cwd()));
-			await commands.get("subagents-refresh-provider-models")!.handler("openai-codex", createCommandContext({
-				cwd: process.cwd(),
-				modelRegistry: {
-					getAvailable: () => [
-						{ provider: "openai-codex", id: "gpt-5.3-codex-spark", reasoning: true },
-						{ provider: "openai-codex", id: "gpt-5.4-mini", reasoning: true },
-					],
-				},
-			}) as never);
-			assert.match(String((sent[0] as { content?: unknown }).content ?? ""), /Provider: openai-codex/);
-			assert.match(String((sent[0] as { content?: unknown }).content ?? ""), /Warning: 2 models were classified with name heuristics fallback\./);
-			assert.equal(fs.existsSync(path.join(process.env.HOME!, ".selesai", "agent", "profiles", "pi-subagents", "providers", "openai-codex.models.json")), true);
-		});
-	});
-
-	it("generates provider profiles", async () => {
-		await withIsolatedHome(async () => {
-			const sent: unknown[] = [];
-			const commands = new Map<string, RegisteredSlashCommand>();
-			const pi = {
-				events: createEventBus(),
-				exec: async () => ({ stdout: "OK\n", stderr: "", code: 0, killed: false }),
-				registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
-				registerShortcut() {},
-				sendMessage(message: unknown) { sent.push(message); },
-			};
-			registerSlashCommands!(pi, createState(process.cwd()));
-			await commands.get("subagents-generate-profiles")!.handler("openai-codex", createCommandContext({
-				modelRegistry: {
-					getAvailable: () => [
-						{ provider: "openai-codex", id: "gpt-5.3-codex-spark", reasoning: true },
-						{ provider: "openai-codex", id: "gpt-5.4-mini", reasoning: true },
-						{ provider: "openai-codex", id: "gpt-5.4", reasoning: true },
-						{ provider: "openai-codex", id: "gpt-5.5", reasoning: true },
-					],
-				},
-			}) as never);
-			assert.match(String((sent[0] as { content?: unknown }).content ?? ""), /Generated subagent profiles/);
-			assert.match(String((sent[0] as { content?: unknown }).content ?? ""), /Warning: generated profiles depend on heuristic-only classification for 4 selected models\./);
-			assert.equal(fs.existsSync(path.join(process.env.HOME!, ".selesai", "agent", "profiles", "pi-subagents", "openai-codex.quota.json")), true);
-			assert.equal(fs.existsSync(path.join(process.env.HOME!, ".selesai", "agent", "profiles", "pi-subagents", "openai-codex.quality.json")), true);
-		});
-	});
-
-	it("checks a profile", async () => {
-		await withIsolatedHome(async () => {
-			const profilesDir = path.join(process.env.HOME!, ".selesai", "agent", "profiles", "pi-subagents");
-			fs.mkdirSync(profilesDir, { recursive: true });
-			fs.writeFileSync(path.join(profilesDir, "demo.json"), JSON.stringify({
-				subagents: { agentOverrides: { scout: { model: "openai-codex/gpt-5.3-codex-spark" } } },
-			}, null, 2));
-			const sent: unknown[] = [];
-			const commands = new Map<string, RegisteredSlashCommand>();
-			const pi = {
-				events: createEventBus(),
-				exec: async () => ({ stdout: "OK\n", stderr: "", code: 0, killed: false }),
-				registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
-				registerShortcut() {},
-				sendMessage(message: unknown) { sent.push(message); },
-			};
-			registerSlashCommands!(pi, createState(process.cwd()));
-			await commands.get("subagents-check-profile")!.handler("demo", createCommandContext({
-				modelRegistry: { getAvailable: () => [{ provider: "openai-codex", id: "gpt-5.3-codex-spark" }] },
-			}) as never);
-			assert.match(String((sent[0] as { content?: unknown }).content ?? ""), /probe ok/);
-		});
-	});
-
-	it("suggests provider names for refresh and generate commands", async () => {
-		await withIsolatedHome(async () => {
-			const commands = new Map<string, RegisteredSlashCommand>();
-			const pi = {
-				events: createEventBus(),
-				registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
-				registerShortcut() {},
-				sendMessage(_message: unknown) {},
-			};
-			const state = createState(process.cwd());
-			state.lastUiContext = createCommandContext({
-				modelRegistry: {
-					getAvailable: () => [
-						{ provider: "openai-codex", id: "gpt-5.4" },
-						{ provider: "openai", id: "gpt-5" },
-						{ provider: "anthropic", id: "claude-sonnet-4" },
-					],
-				},
-			}) as never;
-			registerSlashCommands!(pi, state);
-			const refresh = commands.get("subagents-refresh-provider-models")!.getArgumentCompletions!("open") as Array<{ value: string; label: string }>;
-			const generate = commands.get("subagents-generate-profiles")!.getArgumentCompletions!("an") as Array<{ value: string; label: string }>;
-			assert.deepEqual(refresh.map((entry) => entry.value), ["openai", "openai-codex"]);
-			assert.deepEqual(generate.map((entry) => entry.value), ["anthropic"]);
-		});
-	});
-});
-
-describe("subagents admin slash command", { skip: !available ? "slash-commands.ts not importable" : undefined }, () => {
-	beforeEach(() => {
-		clearSlashSnapshots?.();
-	});
-
-	function registerAdmin(sent: unknown[]) {
-		const commands = new Map<string, RegisteredSlashCommand>();
-		const pi = {
-			events: createEventBus(),
-			registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
-			registerShortcut() {},
-			sendMessage(message: unknown) { sent.push(message); },
-		};
-		registerSlashCommands!(pi, createState(process.cwd()));
-		return commands;
-	}
-
-	it("registers /subagents", async () => {
-		await withIsolatedHome(async () => {
-			const commands = registerAdmin([]);
-			assert.equal(commands.has("subagents"), true);
-		});
-	});
-
-	it("treats agent and scope selector cancellation as a silent no-op", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-subagents-admin-cancel-", async (root) => {
-				const sent: unknown[] = [];
-				const notifications: string[] = [];
-				const commands = registerAdmin(sent);
-
-				await commands.get("subagents")!.handler("", createCommandContext({
-					cwd: root,
-					hasUI: true,
-					select: async () => undefined,
-					notify: (message) => notifications.push(message),
-				}));
-
-				await commands.get("subagents")!.handler("builder model", createCommandContext({
-					cwd: root,
-					hasUI: true,
-					modelRegistry: { getAvailable: () => [{ provider: "test", id: "new-model", reasoning: true }] },
-					select: async (title) => title.startsWith("Select model") ? "test/new-model" : undefined,
-					notify: (message) => notifications.push(message),
-				}));
-
-				assert.deepEqual(sent, []);
-				assert.deepEqual(notifications, []);
-				assert.equal(fs.existsSync(path.join(root, ".selesai", "settings.json")), false);
-			});
-		});
-	});
-
-	it("reports duplicate names as ambiguous without UI", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-subagents-admin-ambiguous-", async (root) => {
-				fs.writeFileSync(path.join(root, ".selesai", "agents", "builder.md"), "---\nname: builder\ndescription: Project builder\n---\n\nWork.\n", "utf-8");
-				const sent: unknown[] = [];
-				const commands = registerAdmin(sent);
-				await commands.get("subagents")!.handler("builder", createCommandContext({ cwd: root }));
-				assert.equal(sent.length, 1);
-				const content = (sent[0] as { content?: string }).content ?? "";
-				assert.match(content, /Subagent 'builder' is ambiguous/);
-				assert.match(content, /project:/);
-				assert.match(content, /builtin:/);
-			});
-		});
-	});
-
-	it("keeps same-source duplicate agents distinct in interactive pickers", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-subagents-admin-same-source-", async (root) => {
-				const localPath = path.join(process.env.SELESAI_CODING_AGENT_DIR!, "agents", "duplicate-admin-agent.md");
-				const extraDir = path.join(root, "extra-agents");
-				const extraPath = path.join(extraDir, "duplicate-admin-agent.md");
-				fs.mkdirSync(path.dirname(localPath), { recursive: true });
-				fs.mkdirSync(extraDir, { recursive: true });
-				const frontmatter = "---\nname: duplicate-admin-agent\ndescription: Duplicate agent\nmodel: test/model\n---\n\n";
-				fs.writeFileSync(localPath, `${frontmatter}Local prompt.\n`, "utf-8");
-				fs.writeFileSync(extraPath, `${frontmatter}Extra prompt.\n`, "utf-8");
-				const previousExtraDirs = process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS;
-				process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS = extraDir;
-				try {
-					const sent: unknown[] = [];
-					const commands = registerAdmin(sent);
-					await commands.get("subagents")!.handler("duplicate-admin-agent details", createCommandContext({
-						cwd: root,
-						hasUI: true,
-						select: async (_title, choices) => {
-							assert.equal(choices.length, 2);
-							assert.ok(choices.some((choice) => choice.includes(localPath)));
-							assert.ok(choices.some((choice) => choice.includes(extraPath)));
-							return choices.find((choice) => choice.includes(localPath));
-						},
-					}));
-					const content = (sent[0] as { content?: string }).content ?? "";
-					assert.ok(content.split("\n").includes(`Path: ${localPath}`));
-				} finally {
-					if (previousExtraDirs === undefined) delete process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS;
-					else process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS = previousExtraDirs;
-				}
-			});
-		});
-	});
-
-	it("updates a project agent model without dumping metadata first", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-subagents-admin-model-", async (root) => {
-			const agentPath = path.join(root, ".selesai", "agents", "worker.md");
-			fs.writeFileSync(agentPath, `---\nname: worker\ndescription: Test worker\nmodel: anthropic/claude-sonnet-4-6\n---\n\nDo work.\n`, "utf-8");
-			const sent: unknown[] = [];
-			const commands = registerAdmin(sent);
-			let refreshes = 0;
-			await commands.get("subagents")!.handler("worker model", createCommandContext({
-				cwd: root,
-				hasUI: true,
-				modelRegistry: {
-					refresh: () => { refreshes++; },
-					getAvailable: () => [{ provider: "bluebox-azure-openai", id: "gpt-5_6-sol", reasoning: true }],
-				},
-				select: async (_title, choices) => {
-					const projectAgent = choices.find((choice) => choice.startsWith("worker [project]"));
-					if (projectAgent) return projectAgent;
-					assert.ok(choices.includes("bluebox-azure-openai/gpt-5_6-sol"));
-					return "bluebox-azure-openai/gpt-5_6-sol";
-				},
-			}));
-
-			assert.equal(refreshes, 1);
-			assert.match(fs.readFileSync(agentPath, "utf-8"), /^model: bluebox-azure-openai\/gpt-5_6-sol$/m);
-			assert.equal(sent.length, 1, "only the compact confirmation should enter the conversation");
-			assert.match((sent[0] as { content?: string }).content ?? "", /Updated 'worker' model/);
-			});
-		});
-	});
-
-	it("updates a profile-managed user agent through settings instead of pinning frontmatter", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-subagents-admin-profile-", async (root) => {
-				const userAgentDir = path.join(process.env.HOME!, ".selesai", "agent", "agents");
-				fs.mkdirSync(userAgentDir, { recursive: true });
-				const agentPath = path.join(userAgentDir, "worker.md");
-				fs.writeFileSync(agentPath, `---\nname: worker\ndescription: Profile worker\n---\n\nDo work.\n`, "utf-8");
-				const settingsPath = path.join(process.env.HOME!, ".selesai", "agent", "settings.json");
-				fs.writeFileSync(settingsPath, JSON.stringify({
-					subagents: { disableBuiltins: true, agentOverrides: { worker: { model: "anthropic/claude-opus-4-8" } } },
-				}, null, 2));
-
-				const sent: unknown[] = [];
-				const commands = registerAdmin(sent);
-				await commands.get("subagents")!.handler("worker model", createCommandContext({
-					cwd: root,
-					hasUI: true,
-					modelRegistry: { getAvailable: () => [{ provider: "bluebox-azure-openai", id: "gpt-5_6-luna", reasoning: true }] },
-					select: async (_title, choices) =>
-						choices.find((choice) => choice.startsWith("worker [user]"))
-						?? "bluebox-azure-openai/gpt-5_6-luna",
-				}));
-
-				assert.doesNotMatch(fs.readFileSync(agentPath, "utf-8"), /^model:/m);
-				const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
-				assert.equal(settings.subagents.disableBuiltins, true);
-				assert.equal(settings.subagents.agentOverrides.worker.model, "bluebox-azure-openai/gpt-5_6-luna");
-			});
-		});
-	});
-
-	it("does not snapshot global disableThinking into an unrelated builtin override", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-subagents-admin-global-thinking-", async (root) => {
-				const settingsPath = path.join(process.env.SELESAI_CODING_AGENT_DIR!, "settings.json");
-				fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
-				fs.writeFileSync(settingsPath, JSON.stringify({ subagents: { disableThinking: true } }, null, 2), "utf-8");
-				const commands = registerAdmin([]);
-				await commands.get("subagents")!.handler("builder model", createCommandContext({
-					cwd: root,
-					hasUI: true,
-					modelRegistry: { getAvailable: () => [{ provider: "test", id: "new-model", reasoning: true }] },
-					select: async () => "test/new-model",
-				}));
-
-				assert.deepEqual(JSON.parse(fs.readFileSync(settingsPath, "utf-8")).subagents, {
-					disableThinking: true,
-					agentOverrides: { builder: { model: "test/new-model" } },
-				});
-			});
-		});
-	});
-
-	it("offers and saves max thinking only when model metadata declares it", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-subagents-admin-thinking-", async (root) => {
-			const settingsPath = path.join(process.env.SELESAI_CODING_AGENT_DIR!, "settings.json");
-			fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
-			fs.writeFileSync(settingsPath, JSON.stringify({
-				subagents: { agentOverrides: { worker: { model: "anthropic/claude-opus-4-8", thinking: "high" } } },
-			}, null, 2));
-			const agentPath = path.join(root, ".selesai", "agents", "worker.md");
-			fs.writeFileSync(agentPath, `---\nname: worker\ndescription: Test worker\nmodel: bluebox-azure-openai/gpt-5_6-sol\n---\n\nDo work.\n`, "utf-8");
-			const commands = registerAdmin([]);
-			await commands.get("subagents")!.handler("worker thinking", createCommandContext({
-				cwd: root,
-				hasUI: true,
-				modelRegistry: {
-					getAvailable: () => [{
-						provider: "bluebox-azure-openai",
-						id: "gpt-5_6-sol",
-						reasoning: true,
-						thinkingLevelMap: { minimal: null, xhigh: "xhigh", max: "max" },
-					}],
-				},
-				select: async (_title, choices) => {
-					const projectAgent = choices.find((choice) => choice.startsWith("worker [project]"));
-					if (projectAgent) return projectAgent;
-					assert.ok(choices.includes("max"));
-					assert.equal(choices.includes("minimal"), false);
-					return "max";
-				},
-			}));
-				assert.match(fs.readFileSync(agentPath, "utf-8"), /^thinking: max$/m);
-				assert.deepEqual(JSON.parse(fs.readFileSync(settingsPath, "utf-8")).subagents.agentOverrides.worker, {
-					model: "anthropic/claude-opus-4-8",
-					thinking: "high",
-				});
-			});
-		});
-	});
-
-	it("uses the inherited session model's thinking capabilities and warns on refresh failure", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-subagents-admin-inherited-thinking-", async (root) => {
-				fs.writeFileSync(path.join(root, ".selesai", "agents", "auditor.md"), "---\nname: auditor\ndescription: Audit things\n---\n\nAudit.\n", "utf-8");
-				const notifications: Array<{ message: string; type?: string }> = [];
-				const commands = registerAdmin([]);
-				await commands.get("subagents")!.handler("auditor thinking", createCommandContext({
-					cwd: root,
-					hasUI: true,
-					model: { provider: "test", id: "plain-model" },
-					modelRegistry: {
-						refresh: () => { throw new Error("invalid models.json"); },
-						getAvailable: () => [{ provider: "test", id: "plain-model", reasoning: false }],
-					},
-					select: async (title, choices) => {
-						assert.match(title, /Session model: test\/plain-model/);
-						assert.deepEqual(choices, ["Default / inherit session thinking", "off"]);
-						return undefined;
-					},
-					notify: (message, type) => notifications.push({ message, type }),
-				}));
-
-				assert.equal(notifications.length, 1);
-				assert.equal(notifications[0]?.type, "warning");
-				assert.match(notifications[0]?.message ?? "", /using the last loaded choices.*invalid models\.json/);
-			});
-		});
-	});
-
-	it("does not pin inherited settings when editing a project-owned field", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-subagents-admin-cross-scope-", async (root) => {
-				const agentPath = path.join(root, ".selesai", "agents", "worker.md");
-				fs.writeFileSync(agentPath, "---\nname: worker\ndescription: Test worker\n---\n\nDo work.\n", "utf-8");
-				const settingsPath = path.join(process.env.HOME!, ".selesai", "agent", "settings.json");
-				fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
-				fs.writeFileSync(settingsPath, JSON.stringify({
-					subagents: { agentOverrides: { worker: { thinking: "high" } } },
-				}, null, 2));
-
-				const commands = registerAdmin([]);
-				await commands.get("subagents")!.handler("worker model", createCommandContext({
-					cwd: root,
-					hasUI: true,
-					modelRegistry: { getAvailable: () => [{ provider: "bluebox-azure-openai", id: "gpt-5_6-sol", reasoning: true }] },
-					select: async (_title, choices) => {
-						const projectAgent = choices.find((choice) => choice.startsWith("worker [project]"));
-						if (projectAgent) return projectAgent;
-						assert.ok(choices.includes("bluebox-azure-openai/gpt-5_6-sol"));
-						return "bluebox-azure-openai/gpt-5_6-sol";
-					},
-				}));
-
-				const updated = fs.readFileSync(agentPath, "utf-8");
-				assert.match(updated, /^model: bluebox-azure-openai\/gpt-5_6-sol$/m);
-				assert.doesNotMatch(updated, /^thinking:/m);
-				assert.doesNotMatch(updated, /^systemPromptMode:/m);
-				assert.doesNotMatch(updated, /^inheritProjectContext:/m);
-				assert.equal(JSON.parse(fs.readFileSync(settingsPath, "utf-8")).subagents.agentOverrides.worker.thinking, "high");
-			});
-		});
-	});
-
-	it("does not write definitions from SELESAI_SUBAGENT_EXTRA_AGENT_DIRS", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-subagents-admin-extra-", async (root) => {
-				const extraDir = path.join(root, "extra-agents");
-				const agentPath = path.join(extraDir, "worker.md");
-				fs.mkdirSync(extraDir, { recursive: true });
-				const original = "---\nname: worker\ndescription: Read-only worker\nmodel: anthropic/claude-sonnet-4-6\n---\n\nDo work.\n";
-				fs.writeFileSync(agentPath, original, "utf-8");
-				const previousExtraDirs = process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS;
-				process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS = extraDir;
-				try {
-					const commands = registerAdmin([]);
-					await commands.get("subagents")!.handler("worker model", createCommandContext({
-						cwd: root,
-						hasUI: true,
-						modelRegistry: { getAvailable: () => [{ provider: "bluebox-azure-openai", id: "gpt-5_6-sol", reasoning: true }] },
-						select: async (_title, choices) =>
-							choices.find((choice) => choice.startsWith("worker [user]"))
-							?? "bluebox-azure-openai/gpt-5_6-sol",
-					}));
-					assert.equal(fs.readFileSync(agentPath, "utf-8"), original);
-				} finally {
-					if (previousExtraDirs === undefined) delete process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS;
-					else process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS = previousExtraDirs;
-				}
-			});
-		});
-	});
-
-	it("respects package-owned fields and uses settings only for unset package fields", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-subagents-admin-package-", async (root) => {
-				const packageRoot = path.join(root, ".selesai", "npm", "node_modules", "admin-package");
-				const agentPath = path.join(packageRoot, "agents", "package-admin-agent.md");
-				fs.mkdirSync(path.dirname(agentPath), { recursive: true });
-				fs.writeFileSync(path.join(packageRoot, "package.json"), JSON.stringify({
-					name: "admin-package",
-					"pi-subagents": { agents: ["./agents"] },
-				}), "utf-8");
-				const original = "---\nname: package-admin-agent\ndescription: Package agent\nmodel: test/original\n---\n\nPackage prompt.\n";
-				fs.writeFileSync(agentPath, original, "utf-8");
-				const settingsPath = path.join(root, ".selesai", "settings.json");
-				fs.writeFileSync(settingsPath, JSON.stringify({
-					subagents: { agentOverrides: { "package-admin-agent": { thinking: "low" } } },
-				}, null, 2), "utf-8");
-
-				const sent: unknown[] = [];
-				const commands = registerAdmin(sent);
-				await commands.get("subagents")!.handler("package-admin-agent model", createCommandContext({
-					cwd: root,
-					hasUI: true,
-					modelRegistry: { getAvailable: () => [{ provider: "test", id: "replacement", reasoning: true }] },
-					select: async () => "test/replacement",
-				}));
-				await commands.get("subagents")!.handler("package-admin-agent prompt", createCommandContext({
-					cwd: root,
-					hasUI: true,
-				}));
-
-				assert.equal(fs.readFileSync(agentPath, "utf-8"), original);
-				assert.deepEqual(JSON.parse(fs.readFileSync(settingsPath, "utf-8")).subagents.agentOverrides, {
-					"package-admin-agent": { thinking: "low" },
-				});
-				assert.match((sent[0] as { content?: string }).content ?? "", /model.*read-only package definition/);
-				assert.match((sent[1] as { content?: string }).content ?? "", /systemPrompt.*read-only package definition/);
-
-				const configurablePath = path.join(packageRoot, "agents", "configurable-package-agent.md");
-				const configurable = "---\nname: configurable-package-agent\ndescription: Configurable package agent\n---\n\nPackage prompt.\n";
-				fs.writeFileSync(configurablePath, configurable, "utf-8");
-				await commands.get("subagents")!.handler("configurable-package-agent model", createCommandContext({
-					cwd: root,
-					hasUI: true,
-					modelRegistry: { getAvailable: () => [{ provider: "test", id: "replacement", reasoning: true }] },
-					select: async (title) => title.startsWith("Select model") ? "test/replacement" : "project",
-				}));
-				assert.equal(fs.readFileSync(configurablePath, "utf-8"), configurable);
-				assert.deepEqual(JSON.parse(fs.readFileSync(settingsPath, "utf-8")).subagents.agentOverrides, {
-					"package-admin-agent": { thinking: "low" },
-					"configurable-package-agent": { model: "test/replacement" },
-				});
-			});
-		});
-	});
-
-	it("edits a system prompt through Pi's native editor", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-subagents-admin-prompt-", async (root) => {
-				const agentPath = path.join(root, ".selesai", "agents", "worker.md");
-				fs.writeFileSync(agentPath, `---\nname: worker\ndescription: Test worker\n---\n\nOriginal prompt.\n`, "utf-8");
-				const status: Array<[string, string | undefined]> = [];
-				let editorArgs: [string, string] | undefined;
-				const commands = registerAdmin([]);
-				await commands.get("subagents")!.handler("worker prompt", createCommandContext({
-					cwd: root,
-					hasUI: true,
-					select: async (_title, choices) => choices.find((choice) => choice.startsWith("worker [project]")),
-					editor: async (title, prefill) => {
-						editorArgs = [title, prefill];
-						return "Edited prompt.\n";
-					},
-					setStatus: (key, text) => status.push([key, text]),
-				}));
-				assert.deepEqual(editorArgs, ["Edit 'worker' system prompt", "Original prompt."]);
-				assert.match(fs.readFileSync(agentPath, "utf-8"), /Edited prompt\./);
-				assert.deepEqual(status, []);
-			});
-		});
-	});
-
-	it("cancels native system-prompt editing without mutation", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-subagents-admin-prompt-cancel-", async (root) => {
-				const agentPath = path.join(root, ".selesai", "agents", "worker.md");
-				const original = `---\nname: worker\ndescription: Test worker\n---\n\nOriginal prompt.\n`;
-				fs.writeFileSync(agentPath, original, "utf-8");
-				const sent: unknown[] = [];
-				const commands = registerAdmin(sent);
-				await commands.get("subagents")!.handler("worker prompt", createCommandContext({
-					cwd: root,
-					hasUI: true,
-					select: async (_title, choices) => choices.find((choice) => choice.startsWith("worker [project]")),
-					editor: async () => undefined,
-				}));
-				assert.equal(fs.readFileSync(agentPath, "utf-8"), original);
-				assert.deepEqual(sent, []);
-			});
-		});
-	});
-
-	it("reports native-editor failures without rewriting the agent", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-subagents-admin-editor-failure-", async (root) => {
-				const agentPath = path.join(root, ".selesai", "agents", "worker.md");
-				const original = `---\nname: worker\ndescription: Test worker\n---\n\nOriginal prompt.\n`;
-				fs.writeFileSync(agentPath, original, "utf-8");
-				const sent: unknown[] = [];
-				const commands = registerAdmin(sent);
-				await commands.get("subagents")!.handler("worker prompt", createCommandContext({
-					cwd: root,
-					hasUI: true,
-					select: async (_title, choices) => choices.find((choice) => choice.startsWith("worker [project]")),
-					editor: async () => { throw new Error("editor unavailable"); },
-				}));
-				assert.equal(fs.readFileSync(agentPath, "utf-8"), original);
-				assert.match((sent.at(-1) as { content?: string }).content ?? "", /Failed to update 'worker': editor unavailable/);
-			});
-		});
-	});
-
-	it("shows metadata for a named subagent without requiring UI", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-subagents-admin-metadata-", async (root) => {
-			fs.writeFileSync(path.join(root, ".selesai", "agents", "auditor.md"), `---\nname: auditor\ndescription: Audit things\nthinking: false\n---\n\nAudit.\n`, "utf-8");
-			const sent: unknown[] = [];
-			const commands = registerAdmin(sent);
-			await commands.get("subagents")!.handler("auditor", createCommandContext({ cwd: root }));
-			assert.equal(sent.length, 1);
-			const content = (sent[0] as { content?: string }).content ?? "";
-			assert.match(content, /Agent: auditor \(project\)/);
-			assert.match(content, /^Thinking: off$/m);
-			});
-		});
-	});
-});
-
-
-describe("subagents-doctor slash command", { skip: !available ? "slash-commands.ts not importable" : undefined }, () => {
-	beforeEach(() => {
-		clearSlashSnapshots?.();
-	});
-
-	it("routes to the doctor tool action", async () => {
-		const { params } = await captureSlashCommandParams("subagents-doctor", "", process.cwd());
-		assert.deepEqual(params, { action: "doctor" });
-	});
-
-	it("keeps the textual fleet status fallback when no UI is available", async () => {
-		const { params } = await captureSlashCommandParams("subagents-fleet", "", process.cwd());
-		assert.deepEqual(params, { action: "status", view: "fleet" });
-	});
-
-	it("opens the native fleet from both the slash command and direct shortcut", async () => {
-		const commands = new Map<string, RegisteredSlashCommand>();
-		const shortcuts = new Map<string, { description: string; handler(ctx: unknown): Promise<void> }>();
-		let opened = 0;
-		let rendered = "";
-		const custom = async (factory: unknown, options: unknown) => {
-			opened++;
-			const component = (factory as (tui: unknown, theme: unknown, keybindings: unknown, done: (value: undefined) => void) => { render(width: number): string[]; dispose(): void })(
-				{ terminal: { rows: 30, columns: 100 }, requestRender() {} },
-				{ fg: (_name: string, text: string) => text, bold: (text: string) => text },
-				undefined,
-				() => {},
-			);
-			rendered = component.render(100).join("\n");
-			component.dispose();
-			assert.equal(options, undefined);
-			return undefined;
-		};
-		const pi = {
-			events: createEventBus(),
-			registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
-			registerShortcut(key: string, spec: { description: string; handler(ctx: unknown): Promise<void> }) { shortcuts.set(key, spec); },
-			sendMessage(_message: unknown) {},
-		};
-		const state = createState(process.cwd());
-		const ctx = createCommandContext({ hasUI: true, custom });
-		registerSlashCommands!(pi, state);
-
-		await commands.get("subagents-fleet")!.handler("", ctx);
-		assert.equal(shortcuts.size, 1);
-		const shortcut = [...shortcuts.values()][0]!;
-		assert.equal(shortcut.description, "Open subagent fleet inspector");
-		await shortcut.handler(ctx);
-
-		assert.equal(opened, 2);
-		assert.match(rendered, /Subagent fleet/);
-		assert.match(rendered, /live controls/);
-	});
-
-	it("routes subagents-stop with an id directly to the stop action", async () => {
-		const { params } = await captureSlashCommandParams("subagents-stop", "run-123", process.cwd());
-		assert.deepEqual(params, { action: "stop", id: "run-123" });
-	});
-
-	it("detaches the latest active foreground single run without terminating it", async () => {
-		const commands = new Map<string, RegisteredSlashCommand>();
-		const sent: unknown[] = [];
-		const state = createState(process.cwd());
-		let detached = 0;
-		state.foregroundControls.set("foreground-single", {
-			runId: "foreground-single",
-			mode: "single",
-			startedAt: 1,
-			updatedAt: 2,
-			detach: () => { detached++; return true; },
-		});
-		state.foregroundControls.set("newer-parallel", {
-			runId: "newer-parallel",
-			mode: "parallel",
-			startedAt: 2,
-			updatedAt: 3,
-		});
-		state.lastForegroundControlId = "newer-parallel";
+	it("does not register legacy orchestration commands", async () => {
+		const commands = new Map<string, unknown>();
 		registerSlashCommands!({
-			events: createEventBus(),
-			registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
+			registerCommand(name: string, command: unknown) { commands.set(name, command); },
 			registerShortcut() {},
-			sendMessage(message: unknown) { sent.push(message); },
-		}, state);
-
-		await commands.get("subagents-detach")!.handler("", createCommandContext());
-
-		assert.equal(detached, 1);
-		const content = String((sent[0] as { content?: unknown }).content ?? "");
-		assert.match(content, /Detached foreground run foreground-single without terminating its child/);
-		assert.match(content, /does not daemonize the process or guarantee survival across Pi reload\/restart/);
-	});
-
-	it("reports missing and unsupported foreground detach targets", async () => {
-		const commands = new Map<string, RegisteredSlashCommand>();
-		const notifications: string[] = [];
-		const state = createState(process.cwd());
-		state.foregroundControls.set("parallel-run", {
-			runId: "parallel-run",
-			mode: "parallel",
-			startedAt: 1,
-			updatedAt: 1,
-			detach: () => true,
-		});
-		registerSlashCommands!({
 			events: createEventBus(),
-			registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
-			registerShortcut() {},
-			sendMessage() {},
-		}, state);
-		const ctx = createCommandContext({ notify: (message) => notifications.push(message) });
-
-		await commands.get("subagents-detach")!.handler("missing", ctx);
-		await commands.get("subagents-detach")!.handler("parallel", ctx);
-
-		assert.match(notifications[0] ?? "", /No active foreground run found for 'missing'/);
-		assert.match(notifications[1] ?? "", /currently supports single-subagent runs only/);
-	});
-
-	it("prints exact stop commands when subagents-stop has no UI", async () => {
-		await withIsolatedHome(async () => {
-			const runId = `slash-stop-${Date.now().toString(36)}`;
-			const asyncDir = path.join(ASYNC_DIR, runId);
-			fs.mkdirSync(asyncDir, { recursive: true });
-			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
-				runId,
-				sessionId: "session-test",
-				mode: "single",
-				state: "running",
-				pid: process.pid,
-				startedAt: Date.now(),
-				lastUpdate: Date.now(),
-				steps: [{ agent: "worker", status: "running", startedAt: Date.now() }],
-			}, null, 2));
-			try {
-				const sent: unknown[] = [];
-				const commands = new Map<string, RegisteredSlashCommand>();
-				const pi = {
-					events: createEventBus(),
-					registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
-					registerShortcut() {},
-					sendMessage(message: unknown) { sent.push(message); },
-				};
-				const state = createState(process.cwd());
-				state.currentSessionId = "session-test";
-				registerSlashCommands!(pi, state);
-				await commands.get("subagents-stop")!.handler("", createCommandContext({ hasUI: false }));
-
-				const content = String((sent[0] as { content?: unknown }).content ?? "");
-				assert.match(content, new RegExp(`subagent\\({ action: "stop", id: "${runId}" }\\)`));
-				assert.match(content, new RegExp(`/subagents-stop ${runId}`));
-			} finally {
-				fs.rmSync(asyncDir, { recursive: true, force: true });
-			}
-		});
-	});
-
-	it("prints cancel commands for scheduled subagent runs when subagents-stop has no UI", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-slash-stop-scheduled-", async (root) => {
-				const storePath = scheduledRunStorePath(root, "session-test");
-				fs.mkdirSync(path.dirname(storePath), { recursive: true });
-				fs.writeFileSync(storePath, JSON.stringify({
-					version: 1,
-					cwd: root,
-					sessionId: "session-test",
-					jobs: [{
-						id: "job-1",
-						name: "nightly scout",
-						schedule: "+10m",
-						runAt: Date.now() + 600_000,
-						state: "scheduled",
-						createdAt: Date.now(),
-						updatedAt: Date.now(),
-						cwd: root,
-						sessionId: "session-test",
-						params: { agent: "scout", task: "later", async: true },
-					}],
-				}, null, 2));
-				const sent: unknown[] = [];
-				const commands = new Map<string, RegisteredSlashCommand>();
-				const state = createState(root);
-				state.currentSessionId = "session-test";
-				const pi = {
-					events: createEventBus(),
-					registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
-					registerShortcut() {},
-					sendMessage(message: unknown) { sent.push(message); },
-				};
-				registerSlashCommands!(pi, state);
-				await commands.get("subagents-stop")!.handler("", createCommandContext({ cwd: root, hasUI: false }));
-
-				const content = String((sent[0] as { content?: unknown }).content ?? "");
-				assert.match(content, /job-1 · nightly scout/);
-				assert.match(content, /cancel scheduled run: subagent\({ action: "schedule-cancel", id: "job-1" }\)/);
-				assert.doesNotMatch(content, /\/subagents-stop job-1/);
-			});
-		});
+		} as never, { baseCwd: process.cwd() } as never);
+		assert.equal(commands.has("run"), true);
+		assert.equal(commands.has("chain"), false);
+		assert.equal(commands.has("parallel"), false);
+		assert.equal(commands.has("run-chain"), false);
 	});
-
-	it("routes selected scheduled subagents-stop targets through schedule-cancel", async () => {
-		await withIsolatedHome(async () => {
-			await withTempProject("pi-slash-stop-selected-scheduled-", async (root) => {
-				const storePath = scheduledRunStorePath(root, "session-test");
-				fs.mkdirSync(path.dirname(storePath), { recursive: true });
-				fs.writeFileSync(storePath, JSON.stringify({
-					version: 1,
-					cwd: root,
-					sessionId: "session-test",
-					jobs: [{
-						id: "job-1",
-						name: "early scout",
-						schedule: "+5m",
-						runAt: Date.now() + 300_000,
-						state: "scheduled",
-						createdAt: Date.now(),
-						updatedAt: Date.now(),
-						cwd: root,
-						sessionId: "session-test",
-						params: { agent: "scout", task: "soon", async: true },
-					}, {
-						id: "job-2",
-						name: "delayed worker",
-						schedule: "+10m",
-						runAt: Date.now() + 600_000,
-						state: "scheduled",
-						createdAt: Date.now(),
-						updatedAt: Date.now(),
-						cwd: root,
-						sessionId: "session-test",
-						params: { agent: "worker", task: "later", async: true },
-					}],
-				}, null, 2));
-
-				const commands = new Map<string, RegisteredSlashCommand>();
-				const events = createEventBus();
-				let requestedParams: unknown;
-				events.on(SLASH_SUBAGENT_REQUEST_EVENT, (data) => {
-					const payload = data as { requestId: string; params?: unknown };
-					requestedParams = payload.params;
-					events.emit(SLASH_SUBAGENT_STARTED_EVENT, { requestId: payload.requestId });
-					events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, {
-						requestId: payload.requestId,
-						result: { content: [{ type: "text", text: "cancelled" }], details: { mode: "management", results: [] } },
-						isError: false,
-					});
-				});
-				const state = createState(root);
-				state.currentSessionId = "session-test";
-				const pi = {
-					events,
-					registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
-					registerShortcut() {},
-					sendMessage(_message: unknown) {},
-				};
-				registerSlashCommands!(pi, state);
-				await commands.get("subagents-stop")!.handler("", createCommandContext({
-					cwd: root,
-					hasUI: true,
-					custom: async (...args: unknown[]) => new Promise((resolve) => {
-						const factory = args[0] as (
-							tui: { requestRender(): void },
-							theme: { fg(key: string, text: string): string; bold(text: string): string },
-							keybindings: unknown,
-							done: (result: unknown) => void,
-						) => { handleInput(data: string): void; render(width: number): string[] };
-						const component = factory(
-							{ requestRender() {} },
-							{ fg(_key, text) { return text; }, bold(text) { return text; } },
-							{},
-							resolve,
-						);
-						assert.match(component.render(84).join("\n"), /↑↓\/jk select/);
-						component.handleInput("j");
-						assert.ok(component.render(84).some((line) => line.startsWith("›") && line.includes("job-2")));
-						component.handleInput("k");
-						assert.ok(component.render(84).some((line) => line.startsWith("›") && line.includes("job-1")));
-						component.handleInput("j");
-						component.handleInput("\r");
-						component.handleInput("y");
-					}),
-				}));
-
-				assert.deepEqual(requestedParams, { action: "schedule-cancel", id: "job-2" });
-			});
-		});
-	});
-
-	it("prints fallback text instead of opening or enumerating the selector in child-safe fanout mode", async () => {
-		await withIsolatedHome(async () => {
-			const previous = process.env[SUBAGENT_FANOUT_CHILD_ENV];
-			const runId = `slash-stop-child-safe-${Date.now().toString(36)}`;
-			const asyncDir = path.join(ASYNC_DIR, runId);
-			process.env[SUBAGENT_FANOUT_CHILD_ENV] = "1";
-			fs.mkdirSync(asyncDir, { recursive: true });
-			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
-				runId,
-				sessionId: "session-test",
-				mode: "single",
-				state: "running",
-				pid: process.pid,
-				startedAt: Date.now(),
-				lastUpdate: Date.now(),
-				steps: [{ agent: "worker", status: "running", startedAt: Date.now() }],
-			}, null, 2));
-			try {
-				const sent: unknown[] = [];
-				const commands = new Map<string, RegisteredSlashCommand>();
-				const pi = {
-					events: createEventBus(),
-					registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
-					registerShortcut() {},
-					sendMessage(message: unknown) { sent.push(message); },
-				};
-				const state = createState(process.cwd());
-				state.currentSessionId = "session-test";
-				registerSlashCommands!(pi, state);
-				await commands.get("subagents-stop")!.handler("", createCommandContext({ hasUI: true }));
-
-				const content = String((sent[0] as { content?: unknown }).content ?? "");
-				assert.match(content, /Selector unavailable in child-safe fanout mode\./);
-				assert.doesNotMatch(content, new RegExp(runId));
-			} finally {
-				fs.rmSync(asyncDir, { recursive: true, force: true });
-				if (previous === undefined) delete process.env[SUBAGENT_FANOUT_CHILD_ENV];
-				else process.env[SUBAGENT_FANOUT_CHILD_ENV] = previous;
-			}
-		});
-	});
-
-	it("does not register the removed subagents-status overlay command", async () => {
-		await withIsolatedHome(async () => {
-			const commands = new Map<string, RegisteredSlashCommand>();
-			const pi = {
-				events: createEventBus(),
-				registerCommand(name: string, spec: RegisteredSlashCommand) {
-					commands.set(name, spec);
-				},
-				registerShortcut() {},
-				sendMessage(_message: unknown) {},
-			};
-
-			registerSlashCommands!(pi, createState(process.cwd()));
-			assert.equal(commands.has("subagents-status"), false);
-		});
-	});
-
 });