@selesai/code 0.5.20 → 0.5.21

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

@@ -68,20 +68,20 @@ describe("builtin agent overrides", () => {
 			subagents: {
 				defaultModel: "deepseek-v4-flash",
 				agentOverrides: {
-					oracle: { model: "deepseek-v4-pro" },
-					reviewer: { model: false },
+					commentator: { model: "deepseek-v4-pro" },
+					builder: { model: false },
 				},
 			},
 		});
 
 		const builtins = discoverAgentsAll(tempProject).builtin;
-		const scout = builtins.find((agent) => agent.name === "scout");
-		assert.equal(scout?.model, "deepseek-v4-flash");
-		assert.equal(scout?.modelSource?.type, "subagents.defaultModel");
-		assert.equal(scout?.modelSource?.scope, "user");
-		assert.equal(builtins.find((agent) => agent.name === "worker")?.model, "deepseek-v4-flash");
-		assert.equal(builtins.find((agent) => agent.name === "oracle")?.model, "deepseek-v4-pro");
-		assert.equal(builtins.find((agent) => agent.name === "reviewer")?.model, undefined);
+		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");
+		assert.equal(builtins.find((agent) => agent.name === "commentator")?.model, "deepseek-v4-pro");
+		assert.equal(builtins.find((agent) => agent.name === "builder")?.model, undefined);
 	});
 
 	it("prefers project subagents.defaultModel over user defaultModel", () => {
@@ -93,9 +93,70 @@ describe("builtin agent overrides", () => {
 			subagents: { defaultModel: "deepseek-v4-pro" },
 		});
 
-		const worker = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "worker");
-		assert.ok(worker);
-		assert.equal(worker.model, "deepseek-v4-pro");
+		const explorer = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "explorer");
+		assert.ok(explorer);
+		assert.equal(explorer.model, "deepseek-v4-pro");
+	});
+
+	it("applies subagents.defaultThinking only when thinking is unset", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: {
+				defaultThinking: " low ",
+				agentOverrides: {
+					recapper: { thinking: "xhigh" },
+				},
+			},
+		});
+		writeUserAgent(tempHome, "user-default", `---\nname: user-default\ndescription: User agent\n---\n\nUse the default.\n`);
+		writeProjectAgent(tempProject, "project-default", `---\nname: project-default\ndescription: Project agent\n---\n\nUse the default.\n`);
+		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.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);
+	});
+
+	it("prefers project subagents.defaultThinking over user defaultThinking", () => {
+		fs.mkdirSync(path.join(tempProject, ".selesai"), { recursive: true });
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: { defaultThinking: "low" },
+		});
+		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
+			subagents: { defaultThinking: "high" },
+		});
+
+		const recapper = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "recapper");
+		assert.ok(recapper);
+		assert.equal(recapper.thinking, "high");
+	});
+
+	it("preserves custom-agent thinking when disableThinking clears builtin defaults", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: { defaultThinking: "low", disableThinking: true },
+		});
+		writeProjectAgent(tempProject, "custom-default", `---\nname: custom-default\ndescription: Custom default\n---\n\nUse the default.\n`);
+		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.project.find((agent) => agent.name === "custom-default")?.thinking, "low");
+		assert.equal(discovered.project.find((agent) => agent.name === "custom-explicit")?.thinking, "high");
+	});
+
+	it("surfaces malformed defaultThinking settings", () => {
+		const settingsPath = path.join(tempHome, ".selesai", "agent", "settings.json");
+		for (const defaultThinking of ["", 42]) {
+			writeJson(settingsPath, { subagents: { defaultThinking } });
+			assert.throws(
+				() => discoverAgents(tempProject, "both"),
+				(error: unknown) => error instanceof Error
+					&& error.message.includes(settingsPath)
+					&& error.message.includes("defaultThinking"),
+			);
+		}
 	});
 
 	it("applies subagents.defaultModel to custom agents without a frontmatter model", () => {
@@ -109,24 +170,25 @@ 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, "scout-copy", `---\nname: scout-copy\ndescription: Scout code\n---\n\nScout the code.\n`);
+		writeProjectAgent(tempProject, "architect-copy", `---\nname: architect-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 === "scout-copy")?.model, "deepseek-v4-flash");
+		assert.equal(agents.find((agent) => agent.name === "architect-copy")?.model, "deepseek-v4-flash");
 	});
 
 	it("applies user settings overrides to builtin agents", () => {
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
 			subagents: {
 				agentOverrides: {
-					reviewer: {
+					builder: {
 						model: "openai/gpt-5.4",
 						thinking: "xhigh",
 						systemPromptMode: "replace",
 						inheritProjectContext: true,
 						inheritSkills: true,
+						acceptanceRole: "writer",
 						subagentOnlyExtensions: ["./tools/child-review.ts"],
 						completionGuard: false,
 					},
@@ -134,18 +196,19 @@ describe("builtin agent overrides", () => {
 			},
 		});
 
-		const reviewer = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "reviewer");
-		assert.ok(reviewer);
-		assert.equal(reviewer.source, "builtin");
-		assert.equal(reviewer.model, "openai/gpt-5.4");
-		assert.equal(reviewer.thinking, "xhigh");
-		assert.equal(reviewer.systemPromptMode, "replace");
-		assert.equal(reviewer.inheritProjectContext, true);
-		assert.equal(reviewer.inheritSkills, true);
-		assert.deepEqual(reviewer.subagentOnlyExtensions, ["./tools/child-review.ts"]);
-		assert.equal(reviewer.completionGuard, false);
-		assert.equal(reviewer.override?.scope, "user");
-		assert.equal(reviewer.override?.path, path.join(tempHome, ".selesai", "agent", "settings.json"));
+		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"));
 	});
 
 	it("globally disables builtin thinking suffix defaults from user settings", () => {
@@ -156,7 +219,7 @@ describe("builtin agent overrides", () => {
 		});
 
 		const builtins = discoverAgentsAll(tempProject).builtin;
-		assert.ok(builtins.some((agent) => agent.name === "reviewer"));
+		assert.ok(builtins.some((agent) => agent.name === "builder"));
 		assert.deepEqual(
 			builtins
 				.filter((agent) => agent.thinking !== undefined)
@@ -164,7 +227,7 @@ describe("builtin agent overrides", () => {
 			[],
 		);
 		assert.equal(
-			builtins.find((agent) => agent.name === "reviewer")?.override?.path,
+			builtins.find((agent) => agent.name === "builder")?.override?.path,
 			path.join(tempHome, ".selesai", "agent", "settings.json"),
 		);
 	});
@@ -174,7 +237,7 @@ describe("builtin agent overrides", () => {
 			subagents: {
 				disableThinking: true,
 				agentOverrides: {
-					reviewer: {
+					builder: {
 						thinking: "high",
 					},
 				},
@@ -182,12 +245,12 @@ describe("builtin agent overrides", () => {
 		});
 
 		const agents = discoverAgents(tempProject, "both").agents;
-		const reviewer = agents.find((agent) => agent.name === "reviewer");
-		const worker = agents.find((agent) => agent.name === "worker");
-		assert.ok(reviewer);
-		assert.ok(worker);
-		assert.equal(reviewer.thinking, "high");
-		assert.equal(worker.thinking, undefined);
+		const builder = agents.find((agent) => agent.name === "builder");
+		const explorer = agents.find((agent) => agent.name === "explorer");
+		assert.ok(builder);
+		assert.ok(explorer);
+		assert.equal(builder.thinking, "high");
+		assert.equal(explorer.thinking, undefined);
 	});
 
 	it("lets project settings disable builtin thinking even when user overrides request it", () => {
@@ -195,7 +258,7 @@ describe("builtin agent overrides", () => {
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
 			subagents: {
 				agentOverrides: {
-					reviewer: {
+					builder: {
 						thinking: "xhigh",
 					},
 				},
@@ -207,9 +270,9 @@ describe("builtin agent overrides", () => {
 			},
 		});
 
-		const reviewer = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "reviewer");
-		assert.ok(reviewer);
-		assert.equal(reviewer.thinking, undefined);
+		const builder = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "builder");
+		assert.ok(builder);
+		assert.equal(builder.thinking, undefined);
 	});
 
 	it("surfaces malformed subagent default model settings", () => {
@@ -247,45 +310,74 @@ 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: { reviewer: { model: "openai/gpt-5.4" } } },
+			subagents: { agentOverrides: { builder: { model: "openai/gpt-5.4" } } },
+		});
+		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
+			subagents: { agentOverrides: { builder: { 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"));
+	});
+
+	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" },
+					implementer: { acceptanceRole: "read-only" },
+				},
+			},
 		});
+		fs.mkdirSync(path.join(tempProject, ".selesai"), { recursive: true });
 		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
-			subagents: { agentOverrides: { reviewer: { model: "openai-codex/gpt-5.4-mini", thinking: "high" } } },
+			subagents: {
+				agentOverrides: {
+					builder: { acceptanceRole: "writer" },
+					architect: { acceptanceRole: false },
+					implementer: { acceptanceRole: false },
+				},
+			},
 		});
+		writeProjectAgent(tempProject, "implementer", `---\nname: implementer\ndescription: TDD implementer\n---\n\nDrive the failing test first.\n`);
 
-		const reviewer = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "reviewer");
-		assert.ok(reviewer);
-		assert.equal(reviewer.model, "openai-codex/gpt-5.4-mini");
-		assert.equal(reviewer.thinking, "high");
-		assert.equal(reviewer.override?.scope, "project");
-		assert.equal(reviewer.override?.path, path.join(tempProject, ".selesai", "settings.json"));
+		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 === "implementer")?.acceptanceRole, undefined);
+		assert.equal(agents.find((agent) => agent.name === "implementer")?.override?.scope, "project");
 	});
 
 	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: { reviewer: { model: "openai/gpt-5.4" } } },
+			subagents: { agentOverrides: { builder: { model: "openai/gpt-5.4" } } },
 		});
 		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
-			subagents: { agentOverrides: { reviewer: { model: "openai-codex/gpt-5.4-mini" } } },
+			subagents: { agentOverrides: { builder: { model: "openai-codex/gpt-5.4-mini" } } },
 		});
 
-		const reviewer = discoverAgents(tempProject, "user").agents.find((agent) => agent.name === "reviewer");
-		assert.ok(reviewer);
-		assert.equal(reviewer.model, "openai/gpt-5.4");
-		assert.equal(reviewer.override?.scope, "user");
+		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");
 	});
 
 	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: { reviewer: { model: "openai/gpt-5.4" } } },
+			subagents: { agentOverrides: { builder: { model: "openai/gpt-5.4" } } },
 		});
 
-		const reviewer = discoverAgents(tempProject, "project").agents.find((agent) => agent.name === "reviewer");
-		assert.ok(reviewer);
-		assert.notEqual(reviewer.model, "openai/gpt-5.4");
-		assert.equal(reviewer.override, undefined);
+		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);
 	});
 
 	it("does not read malformed out-of-scope settings files", () => {
@@ -293,27 +385,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: { reviewer: { model: "openai-codex/gpt-5.4-mini" } } },
+			subagents: { agentOverrides: { builder: { model: "openai-codex/gpt-5.4-mini" } } },
 		});
 
-		const reviewer = discoverAgents(tempProject, "project").agents.find((agent) => agent.name === "reviewer");
-		assert.ok(reviewer);
-		assert.equal(reviewer.model, "openai-codex/gpt-5.4-mini");
-		assert.equal(reviewer.override?.scope, "project");
+		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");
 	});
 
 	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: { reviewer: { model: "openai/gpt-5.4" } } },
+			subagents: { agentOverrides: { builder: { model: "openai/gpt-5.4" } } },
 		});
-		writeProjectAgent(tempProject, "reviewer", `---\nname: reviewer\ndescription: Project reviewer\nmodel: google/gemini-3-pro\n---\n\nUse the project reviewer.\n`);
+		writeProjectAgent(tempProject, "builder", `---\nname: builder\ndescription: Project builder\nmodel: google/gemini-3-pro\n---\n\nUse the project builder.\n`);
 
-		const reviewer = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "reviewer");
-		assert.ok(reviewer);
-		assert.equal(reviewer.source, "project");
-		assert.equal(reviewer.model, "google/gemini-3-pro");
-		assert.equal(reviewer.override, undefined);
+		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);
 	});
 
 	it("fills in unset fields on a custom project agent from project agentOverrides", () => {
@@ -329,6 +421,7 @@ describe("builtin agent overrides", () => {
 						inheritProjectContext: true,
 						inheritSkills: true,
 						defaultContext: "fork",
+						acceptanceRole: "writer",
 						tools: ["bash", "mcp:xcodebuild_list_sims"],
 						skills: ["tdd"],
 						subagentOnlyExtensions: ["./tools/child-review.ts"],
@@ -349,6 +442,7 @@ describe("builtin agent overrides", () => {
 		assert.equal(implementer.inheritProjectContext, true);
 		assert.equal(implementer.inheritSkills, true);
 		assert.equal(implementer.defaultContext, "fork");
+		assert.equal(implementer.acceptanceRole, "writer");
 		assert.deepEqual(implementer.tools, ["bash"]);
 		assert.deepEqual(implementer.mcpDirectTools, ["xcodebuild_list_sims"]);
 		assert.deepEqual(implementer.skills, ["tdd"]);
@@ -412,12 +506,13 @@ describe("builtin agent overrides", () => {
 						skills: ["override-skill"],
 						inheritProjectContext: true,
 						defaultContext: "fork",
+						acceptanceRole: "writer",
 						completionGuard: true,
 					},
 				},
 			},
 		});
-		writeProjectAgent(tempProject, "implementer", `---\nname: implementer\ndescription: TDD implementer\nmodel: google/gemini-3-pro\nthinking: medium\ntools: read, mcp:local_tool\nskills: agent-skill\ninheritProjectContext: false\ndefaultContext: fresh\ncompletionGuard: false\n---\n\nDrive the failing test first.\n`);
+		writeProjectAgent(tempProject, "implementer", `---\nname: implementer\ndescription: TDD implementer\nmodel: google/gemini-3-pro\nthinking: medium\ntools: read, mcp:local_tool\nskills: agent-skill\ninheritProjectContext: false\ndefaultContext: fresh\nacceptanceRole: read-only\ncompletionGuard: false\n---\n\nDrive the failing test first.\n`);
 
 		const implementer = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "implementer");
 		assert.ok(implementer);
@@ -428,13 +523,14 @@ describe("builtin agent overrides", () => {
 		assert.deepEqual(implementer.skills, ["agent-skill"]);
 		assert.equal(implementer.inheritProjectContext, false);
 		assert.equal(implementer.defaultContext, "fresh");
+		assert.equal(implementer.acceptanceRole, "read-only");
 		assert.equal(implementer.completionGuard, false);
 		assert.equal(implementer.override, undefined);
 	});
 
 	it("leaves a custom agent untouched when no agentOverrides entry matches its name", () => {
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
-			subagents: { agentOverrides: { reviewer: { model: "openai/gpt-5.4" } } },
+			subagents: { agentOverrides: { builder: { model: "openai/gpt-5.4" } } },
 		});
 		writeProjectAgent(tempProject, "implementer", `---\nname: implementer\ndescription: TDD implementer\n---\n\nDrive the failing test first.\n`);
 
@@ -458,7 +554,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, "reviewer", "user");
+		removeBuiltinAgentOverride(tempProject, "builder", "user");
 		assert.equal(fs.existsSync(settingsPath), false);
 	});
 
@@ -492,7 +588,7 @@ describe("builtin agent overrides", () => {
 		writeJson(settingsPath, {
 			subagents: {
 				agentOverrides: {
-					reviewer: {
+					builder: {
 						inheritProjectContext: "true",
 					},
 				},
@@ -503,17 +599,38 @@ describe("builtin agent overrides", () => {
 			() => discoverAgents(tempProject, "both"),
 			(error: unknown) => error instanceof Error
 				&& error.message.includes(settingsPath)
-				&& error.message.includes("reviewer")
+				&& error.message.includes("builder")
 				&& error.message.includes("inheritProjectContext"),
 		);
 	});
 
+	it("surfaces malformed acceptance role override values", () => {
+		const settingsPath = path.join(tempHome, ".selesai", "agent", "settings.json");
+		writeJson(settingsPath, {
+			subagents: {
+				agentOverrides: {
+					builder: {
+						acceptanceRole: "observer",
+					},
+				},
+			},
+		});
+
+		assert.throws(
+			() => discoverAgents(tempProject, "both"),
+			(error: unknown) => error instanceof Error
+				&& error.message.includes(settingsPath)
+				&& error.message.includes("builder")
+				&& error.message.includes("acceptanceRole"),
+		);
+	});
+
 	it("surfaces malformed completion guard override values", () => {
 		const settingsPath = path.join(tempHome, ".selesai", "agent", "settings.json");
 		writeJson(settingsPath, {
 			subagents: {
 				agentOverrides: {
-					reviewer: {
+					builder: {
 						completionGuard: "false",
 					},
 				},
@@ -524,7 +641,7 @@ describe("builtin agent overrides", () => {
 			() => discoverAgents(tempProject, "both"),
 			(error: unknown) => error instanceof Error
 				&& error.message.includes(settingsPath)
-				&& error.message.includes("reviewer")
+				&& error.message.includes("builder")
 				&& error.message.includes("completionGuard"),
 		);
 	});
@@ -539,6 +656,7 @@ describe("builtin agent overrides", () => {
 				inheritProjectContext: true,
 				inheritSkills: false,
 				defaultContext: "fork",
+				acceptanceRole: "read-only",
 				systemPrompt: "Base prompt",
 				skills: ["safe-bash"],
 				tools: ["bash"],
@@ -554,6 +672,7 @@ describe("builtin agent overrides", () => {
 				inheritProjectContext: false,
 				inheritSkills: false,
 				defaultContext: undefined,
+				acceptanceRole: undefined,
 				systemPrompt: "Base prompt",
 				skills: undefined,
 				tools: undefined,
@@ -570,6 +689,7 @@ describe("builtin agent overrides", () => {
 			systemPromptMode: "replace",
 			inheritProjectContext: false,
 			defaultContext: false,
+			acceptanceRole: false,
 			skills: false,
 			tools: false,
 			subagentOnlyExtensions: false,

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

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import * as path from "node:path";
 import { describe, it } from "node:test";
-import { buildAsyncRunnerSteps, resolveAsyncRunnerLogPaths } from "../../src/runs/background/async-execution.ts";
+import { buildAsyncRunnerSteps, formatAsyncStartedMessage, resolveAsyncRunnerLogPaths } from "../../src/runs/background/async-execution.ts";
 import type { AgentConfig } from "../../src/agents/agents.ts";
 
 const agent = (name: string, toolBudget?: AgentConfig["toolBudget"]): AgentConfig => ({
@@ -25,6 +25,18 @@ const ctx = {
 };
 
 describe("async runner execution", () => {
+	it("formats interactive yield and headless auto-drain guidance separately", () => {
+		const interactive = formatAsyncStartedMessage("Async: worker [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);
+		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);
+	});
+
 	it("places detached runner stdio logs in the async run directory", () => {
 		const asyncDir = path.join("tmp", "async-run");
 		assert.deepEqual(resolveAsyncRunnerLogPaths({ asyncDir }), {
@@ -47,12 +59,14 @@ describe("async runner execution", () => {
 			ctx,
 			asyncDir: path.join(process.cwd(), ".tmp-async-test"),
 			maxSubagentDepth: 2,
+			waitToolEnabled: false,
 			toolBudget: { hard: 3, block: ["find"] },
 			configToolBudget: { hard: 5, block: ["ls"] },
 		});
 
 		assert.ok("steps" in result, "expected successful step build");
 		assert.deepEqual(result.steps[0]?.toolBudget, { hard: 3, block: ["find"] });
+		assert.equal(result.steps[0]?.waitToolEnabled, false);
 		assert.deepEqual(result.steps[1]?.toolBudget, { hard: 2, block: ["grep"] });
 	});