@selesai/code 0.6.2 → 0.7.0

package/dist/extensions/pi-subagents/test/unit/agent-overrides.test.ts

@@ -69,19 +69,19 @@ describe("builtin agent overrides", () => {
 				defaultModel: "deepseek-v4-flash",
 				agentOverrides: {
 					commentator: { model: "deepseek-v4-pro" },
-					builder: { model: false },
+					recapper: { model: false },
 				},
 			},
 		});
 
 		const builtins = discoverAgentsAll(tempProject).builtin;
-		const architect = builtins.find((agent) => agent.name === "architect");
-		assert.equal(architect?.model, "deepseek-v4-flash");
-		assert.equal(architect?.modelSource?.type, "subagents.defaultModel");
-		assert.equal(architect?.modelSource?.scope, "user");
-		assert.equal(builtins.find((agent) => agent.name === "explorer")?.model, "deepseek-v4-flash");
+		const explorer = builtins.find((agent) => agent.name === "explorer");
+		assert.equal(explorer?.model, "deepseek-v4-flash");
+		assert.equal(explorer?.modelSource?.type, "subagents.defaultModel");
+		assert.equal(explorer?.modelSource?.scope, "user");
+		assert.equal(builtins.find((agent) => agent.name === "builder")?.model, "deepseek-v4-flash");
 		assert.equal(builtins.find((agent) => agent.name === "commentator")?.model, "deepseek-v4-pro");
-		assert.equal(builtins.find((agent) => agent.name === "builder")?.model, undefined);
+		assert.equal(builtins.find((agent) => agent.name === "recapper")?.model, undefined);
 	});
 
 	it("prefers project subagents.defaultModel over user defaultModel", () => {
@@ -93,9 +93,9 @@ describe("builtin agent overrides", () => {
 			subagents: { defaultModel: "deepseek-v4-pro" },
 		});
 
-		const explorer = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "explorer");
-		assert.ok(explorer);
-		assert.equal(explorer.model, "deepseek-v4-pro");
+		const builder = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "builder");
+		assert.ok(builder);
+		assert.equal(builder.model, "deepseek-v4-pro");
 	});
 
 	it("applies subagents.defaultThinking only when thinking is unset", () => {
@@ -103,7 +103,7 @@ describe("builtin agent overrides", () => {
 			subagents: {
 				defaultThinking: " low ",
 				agentOverrides: {
-					recapper: { thinking: "xhigh" },
+					explorer: { thinking: "xhigh" },
 				},
 			},
 		});
@@ -112,8 +112,8 @@ describe("builtin agent overrides", () => {
 		writeProjectAgent(tempProject, "explicit-off", `---\nname: explicit-off\ndescription: Explicitly disabled\nthinking: false\n---\n\nStay off.\n`);
 
 		const discovered = discoverAgentsAll(tempProject);
-		assert.equal(discovered.builtin.find((agent) => agent.name === "recapper")?.thinking, "xhigh");
-		assert.equal(discovered.builtin.find((agent) => agent.name === "builder")?.thinking, "high");
+		assert.equal(discovered.builtin.find((agent) => agent.name === "explorer")?.thinking, "xhigh");
+		assert.equal(discovered.builtin.find((agent) => agent.name === "commentator")?.thinking, "high");
 		assert.equal(discovered.user.find((agent) => agent.name === "user-default")?.thinking, "low");
 		assert.equal(discovered.project.find((agent) => agent.name === "project-default")?.thinking, "low");
 		assert.equal(discovered.project.find((agent) => agent.name === "explicit-off")?.thinking, false);
@@ -128,9 +128,9 @@ describe("builtin agent overrides", () => {
 			subagents: { defaultThinking: "high" },
 		});
 
-		const recapper = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "recapper");
-		assert.ok(recapper);
-		assert.equal(recapper.thinking, "high");
+		const explorer = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "explorer");
+		assert.ok(explorer);
+		assert.equal(explorer.thinking, "high");
 	});
 
 	it("preserves custom-agent thinking when disableThinking clears builtin defaults", () => {
@@ -141,7 +141,7 @@ describe("builtin agent overrides", () => {
 		writeProjectAgent(tempProject, "custom-explicit", `---\nname: custom-explicit\ndescription: Custom explicit\nthinking: high\n---\n\nUse the explicit level.\n`);
 
 		const discovered = discoverAgentsAll(tempProject);
-		assert.equal(discovered.builtin.find((agent) => agent.name === "builder")?.thinking, undefined);
+		assert.equal(discovered.builtin.find((agent) => agent.name === "commentator")?.thinking, undefined);
 		assert.equal(discovered.project.find((agent) => agent.name === "custom-default")?.thinking, "low");
 		assert.equal(discovered.project.find((agent) => agent.name === "custom-explicit")?.thinking, "high");
 	});
@@ -170,12 +170,12 @@ describe("builtin agent overrides", () => {
 		});
 		writeProjectAgent(tempProject, "implementer", `---\nname: implementer\ndescription: TDD implementer\n---\n\nDrive the failing test first.\n`);
 		writeProjectAgent(tempProject, "auditor", `---\nname: auditor\ndescription: Audit code\nmodel: google/gemini-3-pro\n---\n\nAudit the code.\n`);
-		writeProjectAgent(tempProject, "architect-copy", `---\nname: architect-copy\ndescription: Scout code\n---\n\nScout the code.\n`);
+		writeProjectAgent(tempProject, "explorer-copy", `---\nname: explorer-copy\ndescription: Scout code\n---\n\nScout the code.\n`);
 
 		const agents = discoverAgents(tempProject, "both").agents;
 		assert.equal(agents.find((agent) => agent.name === "implementer")?.model, "deepseek-v4-pro");
 		assert.equal(agents.find((agent) => agent.name === "auditor")?.model, "google/gemini-3-pro");
-		assert.equal(agents.find((agent) => agent.name === "architect-copy")?.model, "deepseek-v4-flash");
+		assert.equal(agents.find((agent) => agent.name === "explorer-copy")?.model, "deepseek-v4-flash");
 	});
 
 	it("overrides builtin and custom agent descriptions from settings", () => {
@@ -198,7 +198,7 @@ describe("builtin agent overrides", () => {
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
 			subagents: {
 				agentOverrides: {
-					builder: {
+					commentator: {
 						model: "openai/gpt-5.4",
 						thinking: "xhigh",
 						systemPromptMode: "replace",
@@ -212,19 +212,19 @@ describe("builtin agent overrides", () => {
 			},
 		});
 
-		const builder = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "builder");
-		assert.ok(builder);
-		assert.equal(builder.source, "builtin");
-		assert.equal(builder.model, "openai/gpt-5.4");
-		assert.equal(builder.thinking, "xhigh");
-		assert.equal(builder.systemPromptMode, "replace");
-		assert.equal(builder.inheritProjectContext, true);
-		assert.equal(builder.inheritSkills, true);
-		assert.equal(builder.acceptanceRole, "writer");
-		assert.deepEqual(builder.subagentOnlyExtensions, ["./tools/child-review.ts"]);
-		assert.equal(builder.completionGuard, false);
-		assert.equal(builder.override?.scope, "user");
-		assert.equal(builder.override?.path, path.join(tempHome, ".selesai", "agent", "settings.json"));
+		const commentator = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "commentator");
+		assert.ok(commentator);
+		assert.equal(commentator.source, "builtin");
+		assert.equal(commentator.model, "openai/gpt-5.4");
+		assert.equal(commentator.thinking, "xhigh");
+		assert.equal(commentator.systemPromptMode, "replace");
+		assert.equal(commentator.inheritProjectContext, true);
+		assert.equal(commentator.inheritSkills, true);
+		assert.equal(commentator.acceptanceRole, "writer");
+		assert.deepEqual(commentator.subagentOnlyExtensions, ["./tools/child-review.ts"]);
+		assert.equal(commentator.completionGuard, false);
+		assert.equal(commentator.override?.scope, "user");
+		assert.equal(commentator.override?.path, path.join(tempHome, ".selesai", "agent", "settings.json"));
 	});
 
 	it("globally disables builtin thinking suffix defaults from user settings", () => {
@@ -235,7 +235,7 @@ describe("builtin agent overrides", () => {
 		});
 
 		const builtins = discoverAgentsAll(tempProject).builtin;
-		assert.ok(builtins.some((agent) => agent.name === "builder"));
+		assert.ok(builtins.some((agent) => agent.name === "commentator"));
 		assert.deepEqual(
 			builtins
 				.filter((agent) => agent.thinking !== undefined)
@@ -243,7 +243,7 @@ describe("builtin agent overrides", () => {
 			[],
 		);
 		assert.equal(
-			builtins.find((agent) => agent.name === "builder")?.override?.path,
+			builtins.find((agent) => agent.name === "commentator")?.override?.path,
 			path.join(tempHome, ".selesai", "agent", "settings.json"),
 		);
 	});
@@ -253,7 +253,7 @@ describe("builtin agent overrides", () => {
 			subagents: {
 				disableThinking: true,
 				agentOverrides: {
-					builder: {
+					commentator: {
 						thinking: "high",
 					},
 				},
@@ -261,12 +261,12 @@ describe("builtin agent overrides", () => {
 		});
 
 		const agents = discoverAgents(tempProject, "both").agents;
+		const commentator = agents.find((agent) => agent.name === "commentator");
 		const builder = agents.find((agent) => agent.name === "builder");
-		const explorer = agents.find((agent) => agent.name === "explorer");
+		assert.ok(commentator);
 		assert.ok(builder);
-		assert.ok(explorer);
-		assert.equal(builder.thinking, "high");
-		assert.equal(explorer.thinking, undefined);
+		assert.equal(commentator.thinking, "high");
+		assert.equal(builder.thinking, undefined);
 	});
 
 	it("lets project settings disable builtin thinking even when user overrides request it", () => {
@@ -274,7 +274,7 @@ describe("builtin agent overrides", () => {
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
 			subagents: {
 				agentOverrides: {
-					builder: {
+					commentator: {
 						thinking: "xhigh",
 					},
 				},
@@ -286,9 +286,9 @@ describe("builtin agent overrides", () => {
 			},
 		});
 
-		const builder = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "builder");
-		assert.ok(builder);
-		assert.equal(builder.thinking, undefined);
+		const commentator = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "commentator");
+		assert.ok(commentator);
+		assert.equal(commentator.thinking, undefined);
 	});
 
 	it("surfaces malformed subagent default model settings", () => {
@@ -326,26 +326,26 @@ describe("builtin agent overrides", () => {
 	it("prefers project settings overrides over user settings overrides", () => {
 		fs.mkdirSync(path.join(tempProject, ".selesai"), { recursive: true });
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
-			subagents: { agentOverrides: { builder: { model: "openai/gpt-5.4" } } },
+			subagents: { agentOverrides: { commentator: { model: "openai/gpt-5.4" } } },
 		});
 		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
-			subagents: { agentOverrides: { builder: { model: "openai-codex/gpt-5.4-mini", thinking: "high" } } },
+			subagents: { agentOverrides: { commentator: { model: "openai-codex/gpt-5.4-mini", thinking: "high" } } },
 		});
 
-		const builder = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "builder");
-		assert.ok(builder);
-		assert.equal(builder.model, "openai-codex/gpt-5.4-mini");
-		assert.equal(builder.thinking, "high");
-		assert.equal(builder.override?.scope, "project");
-		assert.equal(builder.override?.path, path.join(tempProject, ".selesai", "settings.json"));
+		const commentator = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "commentator");
+		assert.ok(commentator);
+		assert.equal(commentator.model, "openai-codex/gpt-5.4-mini");
+		assert.equal(commentator.thinking, "high");
+		assert.equal(commentator.override?.scope, "project");
+		assert.equal(commentator.override?.path, path.join(tempProject, ".selesai", "settings.json"));
 	});
 
 	it("applies acceptance role precedence and false clearing to builtin and custom agents", () => {
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
 			subagents: {
 				agentOverrides: {
-					builder: { acceptanceRole: "read-only" },
-					architect: { acceptanceRole: "read-only" },
+					commentator: { acceptanceRole: "read-only" },
+					explorer: { acceptanceRole: "read-only" },
 					implementer: { acceptanceRole: "read-only" },
 				},
 			},
@@ -354,8 +354,8 @@ describe("builtin agent overrides", () => {
 		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
 			subagents: {
 				agentOverrides: {
-					builder: { acceptanceRole: "writer" },
-					architect: { acceptanceRole: false },
+					commentator: { acceptanceRole: "writer" },
+					explorer: { acceptanceRole: false },
 					implementer: { acceptanceRole: false },
 				},
 			},
@@ -363,8 +363,8 @@ describe("builtin agent overrides", () => {
 		writeProjectAgent(tempProject, "implementer", `---\nname: implementer\ndescription: TDD implementer\n---\n\nDrive the failing test first.\n`);
 
 		const agents = discoverAgents(tempProject, "both").agents;
-		assert.equal(agents.find((agent) => agent.name === "builder")?.acceptanceRole, "writer");
-		assert.equal(agents.find((agent) => agent.name === "architect")?.acceptanceRole, undefined);
+		assert.equal(agents.find((agent) => agent.name === "commentator")?.acceptanceRole, "writer");
+		assert.equal(agents.find((agent) => agent.name === "explorer")?.acceptanceRole, undefined);
 		assert.equal(agents.find((agent) => agent.name === "implementer")?.acceptanceRole, undefined);
 		assert.equal(agents.find((agent) => agent.name === "implementer")?.override?.scope, "project");
 	});
@@ -372,28 +372,28 @@ describe("builtin agent overrides", () => {
 	it("does not apply project settings overrides when scope is user", () => {
 		fs.mkdirSync(path.join(tempProject, ".selesai"), { recursive: true });
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
-			subagents: { agentOverrides: { builder: { model: "openai/gpt-5.4" } } },
+			subagents: { agentOverrides: { commentator: { model: "openai/gpt-5.4" } } },
 		});
 		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
-			subagents: { agentOverrides: { builder: { model: "openai-codex/gpt-5.4-mini" } } },
+			subagents: { agentOverrides: { commentator: { model: "openai-codex/gpt-5.4-mini" } } },
 		});
 
-		const builder = discoverAgents(tempProject, "user").agents.find((agent) => agent.name === "builder");
-		assert.ok(builder);
-		assert.equal(builder.model, "openai/gpt-5.4");
-		assert.equal(builder.override?.scope, "user");
+		const commentator = discoverAgents(tempProject, "user").agents.find((agent) => agent.name === "commentator");
+		assert.ok(commentator);
+		assert.equal(commentator.model, "openai/gpt-5.4");
+		assert.equal(commentator.override?.scope, "user");
 	});
 
 	it("does not apply user settings overrides when scope is project", () => {
 		fs.mkdirSync(path.join(tempProject, ".selesai"), { recursive: true });
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
-			subagents: { agentOverrides: { builder: { model: "openai/gpt-5.4" } } },
+			subagents: { agentOverrides: { commentator: { model: "openai/gpt-5.4" } } },
 		});
 
-		const builder = discoverAgents(tempProject, "project").agents.find((agent) => agent.name === "builder");
-		assert.ok(builder);
-		assert.notEqual(builder.model, "openai/gpt-5.4");
-		assert.equal(builder.override, undefined);
+		const commentator = discoverAgents(tempProject, "project").agents.find((agent) => agent.name === "commentator");
+		assert.ok(commentator);
+		assert.notEqual(commentator.model, "openai/gpt-5.4");
+		assert.equal(commentator.override, undefined);
 	});
 
 	it("does not read malformed out-of-scope settings files", () => {
@@ -401,27 +401,27 @@ describe("builtin agent overrides", () => {
 		fs.mkdirSync(path.join(tempHome, ".selesai", "agent"), { recursive: true });
 		fs.writeFileSync(path.join(tempHome, ".selesai", "agent", "settings.json"), '{"subagents":', "utf-8");
 		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
-			subagents: { agentOverrides: { builder: { model: "openai-codex/gpt-5.4-mini" } } },
+			subagents: { agentOverrides: { commentator: { model: "openai-codex/gpt-5.4-mini" } } },
 		});
 
-		const builder = discoverAgents(tempProject, "project").agents.find((agent) => agent.name === "builder");
-		assert.ok(builder);
-		assert.equal(builder.model, "openai-codex/gpt-5.4-mini");
-		assert.equal(builder.override?.scope, "project");
+		const commentator = discoverAgents(tempProject, "project").agents.find((agent) => agent.name === "commentator");
+		assert.ok(commentator);
+		assert.equal(commentator.model, "openai-codex/gpt-5.4-mini");
+		assert.equal(commentator.override?.scope, "project");
 	});
 
 	it("frontmatter wins per-field over agentOverrides for a shadowing project agent", () => {
 		fs.mkdirSync(path.join(tempProject, ".selesai"), { recursive: true });
 		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
-			subagents: { agentOverrides: { builder: { model: "openai/gpt-5.4" } } },
+			subagents: { agentOverrides: { commentator: { model: "openai/gpt-5.4" } } },
 		});
-		writeProjectAgent(tempProject, "builder", `---\nname: builder\ndescription: Project builder\nmodel: google/gemini-3-pro\n---\n\nUse the project builder.\n`);
+		writeProjectAgent(tempProject, "commentator", `---\nname: commentator\ndescription: Project commentator\nmodel: google/gemini-3-pro\n---\n\nUse the project commentator.\n`);
 
-		const builder = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "builder");
-		assert.ok(builder);
-		assert.equal(builder.source, "project");
-		assert.equal(builder.model, "google/gemini-3-pro");
-		assert.equal(builder.override, undefined);
+		const commentator = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "commentator");
+		assert.ok(commentator);
+		assert.equal(commentator.source, "project");
+		assert.equal(commentator.model, "google/gemini-3-pro");
+		assert.equal(commentator.override, undefined);
 	});
 
 	it("fills in unset fields on a custom project agent from project agentOverrides", () => {
@@ -546,7 +546,7 @@ describe("builtin agent overrides", () => {
 
 	it("leaves a custom agent untouched when no agentOverrides entry matches its name", () => {
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
-			subagents: { agentOverrides: { builder: { model: "openai/gpt-5.4" } } },
+			subagents: { agentOverrides: { commentator: { model: "openai/gpt-5.4" } } },
 		});
 		writeProjectAgent(tempProject, "implementer", `---\nname: implementer\ndescription: TDD implementer\n---\n\nDrive the failing test first.\n`);
 
@@ -570,7 +570,7 @@ describe("builtin agent overrides", () => {
 	it("does not create a settings file when removing a non-existent override", () => {
 		const settingsPath = path.join(tempHome, ".selesai", "agent", "settings.json");
 		assert.equal(fs.existsSync(settingsPath), false);
-		removeBuiltinAgentOverride(tempProject, "builder", "user");
+		removeBuiltinAgentOverride(tempProject, "commentator", "user");
 		assert.equal(fs.existsSync(settingsPath), false);
 	});
 
@@ -604,7 +604,7 @@ describe("builtin agent overrides", () => {
 		writeJson(settingsPath, {
 			subagents: {
 				agentOverrides: {
-					builder: {
+					commentator: {
 						inheritProjectContext: "true",
 					},
 				},
@@ -615,7 +615,7 @@ describe("builtin agent overrides", () => {
 			() => discoverAgents(tempProject, "both"),
 			(error: unknown) => error instanceof Error
 				&& error.message.includes(settingsPath)
-				&& error.message.includes("builder")
+				&& error.message.includes("commentator")
 				&& error.message.includes("inheritProjectContext"),
 		);
 	});
@@ -625,7 +625,7 @@ describe("builtin agent overrides", () => {
 		writeJson(settingsPath, {
 			subagents: {
 				agentOverrides: {
-					builder: {
+					commentator: {
 						acceptanceRole: "observer",
 					},
 				},
@@ -636,7 +636,7 @@ describe("builtin agent overrides", () => {
 			() => discoverAgents(tempProject, "both"),
 			(error: unknown) => error instanceof Error
 				&& error.message.includes(settingsPath)
-				&& error.message.includes("builder")
+				&& error.message.includes("commentator")
 				&& error.message.includes("acceptanceRole"),
 		);
 	});
@@ -662,7 +662,7 @@ describe("builtin agent overrides", () => {
 		writeJson(settingsPath, {
 			subagents: {
 				agentOverrides: {
-					builder: {
+					commentator: {
 						completionGuard: "false",
 					},
 				},
@@ -673,7 +673,7 @@ describe("builtin agent overrides", () => {
 			() => discoverAgents(tempProject, "both"),
 			(error: unknown) => error instanceof Error
 				&& error.message.includes(settingsPath)
-				&& error.message.includes("builder")
+				&& error.message.includes("commentator")
 				&& error.message.includes("completionGuard"),
 		);
 	});

package/dist/extensions/pi-subagents/test/unit/agent-selection.test.ts

@@ -52,15 +52,15 @@ describe("mergeAgentsForScope", () => {
 	});
 
 	it("includes builtin agents when no user or project override exists", () => {
-		const builtinAgents = [makeAgent("scout", "builtin", "builtin prompt")];
+		const builtinAgents = [makeAgent("explorer", "builtin", "builtin prompt")];
 		const result = mergeAgentsForScope("both", [], [], builtinAgents);
 		assert.equal(result.length, 1);
 		assert.equal(result[0]?.source, "builtin");
 	});
 
 	it("user agents override builtins with the same name", () => {
-		const builtinAgents = [makeAgent("scout", "builtin", "builtin prompt")];
-		const userAgents = [makeAgent("scout", "user", "custom prompt")];
+		const builtinAgents = [makeAgent("explorer", "builtin", "builtin prompt")];
+		const userAgents = [makeAgent("explorer", "user", "custom prompt")];
 		const result = mergeAgentsForScope("both", userAgents, [], builtinAgents);
 		assert.equal(result.length, 1);
 		assert.equal(result[0]?.source, "user");
@@ -68,10 +68,10 @@ describe("mergeAgentsForScope", () => {
 	});
 
 	it("package agents override builtins but not user or project agents", () => {
-		const builtinAgents = [makeAgent("scout", "builtin", "builtin prompt")];
-		const packageAgents = [makeAgent("scout", "package", "package prompt")];
-		const userAgents = [makeAgent("scout", "user", "user prompt")];
-		const projectAgents = [makeAgent("scout", "project", "project prompt")];
+		const builtinAgents = [makeAgent("explorer", "builtin", "builtin prompt")];
+		const packageAgents = [makeAgent("explorer", "package", "package prompt")];
+		const userAgents = [makeAgent("explorer", "user", "user prompt")];
+		const projectAgents = [makeAgent("explorer", "project", "project prompt")];
 
 		assert.equal(mergeAgentsForScope("both", [], [], builtinAgents, packageAgents)[0]?.source, "package");
 		assert.equal(mergeAgentsForScope("user", userAgents, [], builtinAgents, packageAgents)[0]?.source, "user");
@@ -79,8 +79,8 @@ describe("mergeAgentsForScope", () => {
 	});
 
 	it("project agents override builtins with the same name", () => {
-		const builtinAgents = [makeAgent("scout", "builtin", "builtin prompt")];
-		const projectAgents = [makeAgent("scout", "project", "project prompt")];
+		const builtinAgents = [makeAgent("explorer", "builtin", "builtin prompt")];
+		const projectAgents = [makeAgent("explorer", "project", "project prompt")];
 		const result = mergeAgentsForScope("both", [], projectAgents, builtinAgents);
 		assert.equal(result.length, 1);
 		assert.equal(result[0]?.source, "project");

package/dist/extensions/pi-subagents/test/unit/artifacts.test.ts

@@ -3,10 +3,12 @@ import * as path from "node:path";
 import { describe, it } from "node:test";
 import {
 	getArtifactsDir,
+	getChainRunsDir,
 	getProjectArtifactsDir,
 	getProjectChainRunsDir,
 	getProjectSubagentsDir,
 } from "../../src/shared/artifacts.ts";
+import { CHAIN_RUNS_DIR } from "../../src/shared/types.ts";
 
 describe("project-local artifact paths", () => {
 	it("places generated subagent files under .pi-subagents for a project cwd", () => {
@@ -17,6 +19,14 @@ describe("project-local artifact paths", () => {
 		assert.equal(getArtifactsDir(null, cwd), path.join(cwd, ".pi-subagents", "artifacts"));
 	});
 
+	it("routes chain scratch files according to the artifact preference", () => {
+		const cwd = path.join("tmp", "repo");
+		assert.equal(getChainRunsDir(cwd), getProjectChainRunsDir(cwd));
+		assert.equal(getChainRunsDir(cwd, "project"), getProjectChainRunsDir(cwd));
+		assert.equal(getChainRunsDir(cwd, "session"), CHAIN_RUNS_DIR);
+		assert.equal(getChainRunsDir(cwd, "temp"), CHAIN_RUNS_DIR);
+	});
+
 	it("keeps the session artifact fallback when no project cwd is available", () => {
 		const sessionFile = path.join("tmp", "sessions", "parent.jsonl");
 		assert.equal(getArtifactsDir(sessionFile), path.join("tmp", "sessions", "subagent-artifacts"));

package/dist/extensions/pi-subagents/test/unit/async-execution.test.ts

@@ -26,12 +26,12 @@ const ctx = {
 
 describe("async runner execution", () => {
 	it("formats interactive yield and headless auto-drain guidance separately", () => {
-		const interactive = formatAsyncStartedMessage("Async: worker [interactive]", true);
+		const interactive = formatAsyncStartedMessage("Async: builder [interactive]", true);
 		assert.match(interactive, /interactive session[\s\S]*return control/i);
 		assert.match(interactive, /do not call subagent_wait\(\) merely to wait/i);
 		assert.doesNotMatch(interactive, /auto-drains current-session background work/i);
 
-		const headless = formatAsyncStartedMessage("Async: worker [headless]", false);
+		const headless = formatAsyncStartedMessage("Async: builder [headless]", false);
 		assert.match(headless, /non-interactive run.*auto-drains current-session background work at agent_end/i);
 		assert.match(headless, /call subagent_wait\(\).*results before it ends/i);
 		assert.doesNotMatch(headless, /By default, return control to the user/i);
@@ -52,10 +52,10 @@ describe("async runner execution", () => {
 	it("resolves async step tool budgets with step over run over agent over config precedence", () => {
 		const result = buildAsyncRunnerSteps("run-1", {
 			chain: [
-				{ agent: "worker", task: "agent beats config" },
-				{ agent: "worker", task: "step beats run", toolBudget: { hard: 2, block: ["grep"] } },
+				{ agent: "builder", task: "agent beats config" },
+				{ agent: "builder", task: "step beats run", toolBudget: { hard: 2, block: ["grep"] } },
 			],
-			agents: [agent("worker", { hard: 4, block: ["read"] })],
+			agents: [agent("builder", { hard: 4, block: ["read"] })],
 			ctx,
 			asyncDir: path.join(process.cwd(), ".tmp-async-test"),
 			maxSubagentDepth: 2,
@@ -72,8 +72,8 @@ describe("async runner execution", () => {
 
 	it("uses agent tool budget before config default when no run override exists", () => {
 		const result = buildAsyncRunnerSteps("run-2", {
-			chain: [{ agent: "worker", task: "agent beats config" }],
-			agents: [agent("worker", { hard: 4, block: ["read"] })],
+			chain: [{ agent: "builder", task: "agent beats config" }],
+			agents: [agent("builder", { hard: 4, block: ["read"] })],
 			ctx,
 			asyncDir: path.join(process.cwd(), ".tmp-async-test"),
 			maxSubagentDepth: 2,
@@ -84,10 +84,34 @@ describe("async runner execution", () => {
 		assert.deepEqual(result.steps[0]?.toolBudget, { hard: 4, block: ["read"] });
 	});
 
+	it("attaches external runner config and rejects unsupported Pi-only overrides", () => {
+		const external = agent("external");
+		external.runner = { type: "external-cli", command: process.execPath, args: ["fake.mjs"] };
+		const built = buildAsyncRunnerSteps("external-run", {
+			chain: [{ agent: "external", task: "review" }],
+			agents: [external],
+			ctx,
+			asyncDir: path.join(process.cwd(), ".tmp-external-test"),
+			maxSubagentDepth: 2,
+		});
+		assert.ok("steps" in built);
+		assert.deepEqual(built.steps[0]?.runner, external.runner);
+		assert.equal(built.steps[0]?.model, undefined);
+
+		const rejected = buildAsyncRunnerSteps("external-rejected", {
+			chain: [{ agent: "external", task: "review", model: "provider/model" }],
+			agents: [external],
+			ctx,
+			asyncDir: path.join(process.cwd(), ".tmp-external-test"),
+			maxSubagentDepth: 2,
+		});
+		assert.deepEqual(rejected, { error: "Agent 'external' uses runner.type='external-cli' and does not support: model override." });
+	});
+
 	it("uses config default when no step, run, or agent budget exists", () => {
 		const result = buildAsyncRunnerSteps("run-3", {
-			chain: [{ agent: "worker", task: "config default" }],
-			agents: [agent("worker")],
+			chain: [{ agent: "builder", task: "config default" }],
+			agents: [agent("builder")],
 			ctx,
 			asyncDir: path.join(process.cwd(), ".tmp-async-test"),
 			maxSubagentDepth: 2,

package/dist/extensions/pi-subagents/test/unit/async-interrupt-action.test.ts

@@ -43,7 +43,7 @@ function createRunningAsync(state: SubagentState, runId: string, options: { trac
 		cwd: os.tmpdir(),
 		startedAt: 100,
 		lastUpdate: Date.now(),
-		steps: [{ agent: "worker", status: "running", startedAt: 100 }],
+		steps: [{ agent: "builder", status: "running", startedAt: 100 }],
 	});
 	if (options.track !== false) {
 		state.asyncJobs.set(runId, {
@@ -51,7 +51,7 @@ function createRunningAsync(state: SubagentState, runId: string, options: { trac
 			asyncDir,
 			status: "running",
 			pid: 12345,
-			agents: ["worker"],
+			agents: ["builder"],
 			updatedAt: 100,
 		});
 	}
@@ -200,6 +200,28 @@ describe("async interrupt action", () => {
 		}
 	});
 
+	it("rejects interrupt for a running external CLI run without writing a pause request", async () => {
+		const state = createState();
+		const runId = `interrupt-external-${Date.now().toString(36)}`;
+		const asyncDir = createRunningAsync(state, runId, { track: false });
+		const statusPath = path.join(asyncDir, "status.json");
+		const status = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
+		status.steps[0].runner = { type: "external-cli" };
+		fs.writeFileSync(statusPath, JSON.stringify(status), "utf-8");
+		try {
+			const result = await executorWithKill(state, () => {
+				throw new Error("external interrupt should not signal the runner");
+			}).execute("interrupt", { action: "interrupt", id: runId }, new AbortController().signal, undefined, ctx());
+
+			assert.equal(result.isError, true);
+			assert.match(text(result), /Interrupt is unsupported for one-shot external CLI async run/);
+			assert.equal(fs.existsSync(path.join(asyncDir, "control", "interrupt.json")), false);
+			assert.equal(JSON.parse(fs.readFileSync(statusPath, "utf-8")).state, "running");
+		} finally {
+			cleanup(runId, asyncDir);
+		}
+	});
+
 	it("reports success and writes the portable request when the signal is unavailable", async () => {
 		const state = createState();
 		const runId = `interrupt-enosys-${Date.now().toString(36)}`;