@selesai/code 0.6.2 → 0.7.0

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

@@ -21,13 +21,14 @@ describe("async permission forwarding session identity", () => {
 	it("uses the parent session id for permission forwarding instead of the async status identity", () => {
 		const currentSessionId = path.join("/tmp", "parent-session.jsonl");
 		const built = buildAsyncRunnerSteps("run-abc", {
-			chain: [{ agent: "worker", task: "Do work" }],
-			agents: [makeAgent("worker")],
+			chain: [{ agent: "builder", task: "Do work" }],
+			agents: [makeAgent("builder")],
 			ctx: {
 				pi: {} as never,
 				cwd: "/tmp/project",
 				currentSessionId,
 				parentSessionId: "session-abc123",
+				permissions: { rules: { write: "ask" } },
 			},
 			maxSubagentDepth: 1,
 			asyncDir: "/tmp/async-run",
@@ -37,6 +38,7 @@ describe("async permission forwarding session identity", () => {
 		const step = built.steps[0];
 		assert.ok(step && !("parallel" in step));
 		assert.equal(step.parentSessionId, "session-abc123");
+		assert.deepEqual(step.permissionRules, { write: "ask" });
 	});
 
 	it("consumes bounded dynamic fanout indexes before later static forked steps", () => {
@@ -45,18 +47,18 @@ describe("async permission forwarding session identity", () => {
 				{ agent: "source", task: "produce targets", as: "targets" },
 				{
 					expand: { from: { output: "targets", path: "/items" }, maxItems: 2 },
-					parallel: { agent: "reviewer", task: "Review {item.path}" },
+					parallel: { agent: "commentator", task: "Review {item.path}" },
 					collect: { as: "reviews" },
 				},
-				{ agent: "worker", task: "Use reviews" },
+				{ agent: "builder", task: "Use reviews" },
 			],
-			agents: [makeAgent("source"), makeAgent("reviewer"), { ...makeAgent("worker"), model: "anthropic/claude-sonnet-4-5:high", thinking: "high" }],
+			agents: [makeAgent("source"), makeAgent("commentator"), { ...makeAgent("builder"), model: "anthropic/claude-sonnet-4-5:high", thinking: "high" }],
 			ctx: {
 				pi: {} as never,
 				cwd: "/tmp/project",
 				currentSessionId: "/tmp/parent-session.jsonl",
 			},
-			sessionFilesByFlatIndex: [undefined, "/tmp/dynamic-0.jsonl", "/tmp/dynamic-1.jsonl", "/tmp/static-worker.jsonl"],
+			sessionFilesByFlatIndex: [undefined, "/tmp/dynamic-0.jsonl", "/tmp/dynamic-1.jsonl", "/tmp/static-builder.jsonl"],
 			thinkingOverridesByFlatIndex: [undefined, "off", "off", "off"],
 			maxSubagentDepth: 1,
 			asyncDir: "/tmp/async-run",
@@ -69,15 +71,15 @@ describe("async permission forwarding session identity", () => {
 		assert.deepEqual(dynamic.thinkingOverrides, ["off", "off"]);
 		const staticWorker = built.steps[2];
 		assert.ok(staticWorker && !("parallel" in staticWorker));
-		assert.equal(staticWorker.sessionFile, "/tmp/static-worker.jsonl");
+		assert.equal(staticWorker.sessionFile, "/tmp/static-builder.jsonl");
 		assert.equal(staticWorker.model, "anthropic/claude-sonnet-4-5:off");
 		assert.equal(staticWorker.thinking, "off");
 	});
 
 	it("applies thinking overrides to async fallback candidates", () => {
 		const built = buildAsyncRunnerSteps("run-abc", {
-			chain: [{ agent: "worker", task: "Do work" }],
-			agents: [{ ...makeAgent("worker"), model: "openai/gpt-5-mini:high", fallbackModels: ["anthropic/claude-sonnet-4:low"], thinking: "high" }],
+			chain: [{ agent: "builder", task: "Do work" }],
+			agents: [{ ...makeAgent("builder"), model: "openai/gpt-5-mini:high", fallbackModels: ["anthropic/claude-sonnet-4:low"], thinking: "high" }],
 			ctx: {
 				pi: {} as never,
 				cwd: "/tmp/project",

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

@@ -14,7 +14,7 @@ describe("async recovery descriptor", () => {
 				version: 1,
 				launchContractDigest: digest,
 				sourceRunId: "run-digest",
-				agent: "worker",
+				agent: "builder",
 				cwd: root,
 				systemPromptMode: "replace",
 				inheritProjectContext: false,
@@ -39,7 +39,7 @@ describe("async recovery descriptor", () => {
 				version: 1,
 				launchContractDigest: {},
 				sourceRunId: "run-digest",
-				agent: "worker",
+				agent: "builder",
 				cwd: root,
 				systemPromptMode: "replace",
 				inheritProjectContext: false,

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

@@ -26,14 +26,14 @@ describe("async resume lookup", () => {
 				lastUpdate: 200,
 				cwd: root,
 				sessionFile,
-				steps: [{ agent: "worker", status: "complete" }],
+				steps: [{ agent: "builder", status: "complete" }],
 			});
 
 			const target = resolveAsyncResumeTarget({ id: "run-a" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
 
 			assert.equal(target.kind, "revive");
 			assert.equal(target.runId, "run-abc");
-			assert.equal(target.agent, "worker");
+			assert.equal(target.agent, "builder");
 			assert.equal(target.sessionFile, sessionFile);
 			assert.equal(target.cwd, root);
 		} finally {
@@ -52,7 +52,7 @@ describe("async resume lookup", () => {
 			writeJson(path.join(asyncDir, "status.json"), {
 				runId: "run-ceiling", mode: "single", state: "complete", startedAt: 100, endedAt: 200, lastUpdate: 200, cwd: root,
 				capabilityCeiling: { version: 1, allowedTools: ["read", "write"], denyExtensions: true, sources: ["run"] },
-				steps: [{ agent: "worker", status: "complete", sessionFile, capabilityCeiling: { version: 1, allowedTools: ["read"], denyExtensions: false, sources: ["step"] } }],
+				steps: [{ agent: "builder", status: "complete", sessionFile, capabilityCeiling: { version: 1, allowedTools: ["read"], denyExtensions: false, sources: ["step"] } }],
 			});
 
 			const target = resolveAsyncResumeTarget({ id: "run-ceiling" }, { asyncDirRoot: asyncRoot, resultsDir });
@@ -61,7 +61,7 @@ describe("async resume lookup", () => {
 			writeJson(path.join(asyncDir, "status.json"), {
 				runId: "run-ceiling", mode: "single", state: "complete", startedAt: 100, endedAt: 200, lastUpdate: 200, cwd: root,
 				capabilityCeiling: { version: 2, allowedTools: ["read"], denyExtensions: true, sources: ["run"] },
-				steps: [{ agent: "worker", status: "complete", sessionFile }],
+				steps: [{ agent: "builder", status: "complete", sessionFile }],
 			});
 			assert.throws(() => resolveAsyncResumeTarget({ id: "run-ceiling" }, { asyncDirRoot: asyncRoot, resultsDir }), /capabilityCeiling version/);
 
@@ -69,14 +69,14 @@ describe("async resume lookup", () => {
 			writeJson(path.join(resultsDir, "run-ceiling.json"), {
 				runId: "run-ceiling", mode: "single", state: "complete", success: true, cwd: root,
 				capabilityCeiling: { version: 1, allowedTools: ["read", "grep"], denyExtensions: false, sources: ["result"] },
-				results: [{ agent: "worker", success: true, sessionFile, capabilityCeiling: { version: 1, allowedTools: ["read"], denyExtensions: true, sources: ["result-step"] } }],
+				results: [{ agent: "builder", success: true, sessionFile, capabilityCeiling: { version: 1, allowedTools: ["read"], denyExtensions: true, sources: ["result-step"] } }],
 			});
 			const resultOnly = resolveAsyncResumeTarget({ id: "run-ceiling" }, { asyncDirRoot: asyncRoot, resultsDir });
 			assert.deepEqual(resultOnly.capabilityCeiling, { version: 1, allowedTools: ["read"], denyExtensions: true, sources: ["result", "result-step"] });
 
 			writeJson(path.join(resultsDir, "run-ceiling.json"), {
 				runId: "run-ceiling", mode: "single", state: "complete", success: true, cwd: root,
-				results: [{ agent: "worker", success: true, sessionFile, capabilityCeiling: { version: 1, allowedTools: ["read"], denyExtensions: true } }],
+				results: [{ agent: "builder", success: true, sessionFile, capabilityCeiling: { version: 1, allowedTools: ["read"], denyExtensions: true } }],
 			});
 			assert.throws(() => resolveAsyncResumeTarget({ id: "run-ceiling" }, { asyncDirRoot: asyncRoot, resultsDir }), /capabilityCeiling sources/);
 		} finally {
@@ -94,10 +94,10 @@ describe("async resume lookup", () => {
 			fs.writeFileSync(sessionFile, "", "utf-8");
 			writeJson(path.join(asyncDir, "status.json"), {
 				runId: "run-descriptor", mode: "single", state: "paused", startedAt: 100, lastUpdate: 200, cwd: root,
-				steps: [{ agent: "worker", status: "paused", sessionFile }],
+				steps: [{ agent: "builder", status: "paused", sessionFile }],
 			});
 			const descriptor = {
-				version: 1, sourceRunId: "run-descriptor", agent: "worker", cwd: root, systemPromptMode: "replace",
+				version: 1, sourceRunId: "run-descriptor", agent: "builder", cwd: root, systemPromptMode: "replace",
 				inheritProjectContext: false, inheritSkills: false, outputMode: "inline", maxSubagentDepth: 2, share: false,
 			};
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), { ...descriptor, token: "must-not-be-accepted" });
@@ -121,7 +121,7 @@ describe("async resume lookup", () => {
 			assert.throws(() => resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir }), /different source run/);
 
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), { ...descriptor, agent: "another-agent" });
-			assert.throws(() => resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir }), /not 'worker'/);
+			assert.throws(() => resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir }), /not 'builder'/);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
@@ -137,12 +137,12 @@ describe("async resume lookup", () => {
 			fs.writeFileSync(sessionFile, "", "utf-8");
 			writeJson(path.join(asyncDir, "status.json"), {
 				runId: "run-acceptance", mode: "single", state: "paused", startedAt: 100, lastUpdate: 200, cwd: root,
-				steps: [{ agent: "worker", status: "paused", sessionFile }],
+				steps: [{ agent: "builder", status: "paused", sessionFile }],
 			});
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), {
 				version: 1,
 				sourceRunId: "run-acceptance",
-				agent: "worker",
+				agent: "builder",
 				cwd: root,
 				systemPromptMode: "replace",
 				inheritProjectContext: false,
@@ -186,12 +186,12 @@ describe("async resume lookup", () => {
 			fs.writeFileSync(sessionFile, "", "utf-8");
 			writeJson(path.join(asyncDir, "status.json"), {
 				runId: "run-reviewed-acceptance", mode: "single", state: "paused", startedAt: 100, lastUpdate: 200, cwd: root,
-				steps: [{ agent: "worker", status: "paused", sessionFile }],
+				steps: [{ agent: "builder", status: "paused", sessionFile }],
 			});
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), {
 				version: 1,
 				sourceRunId: "run-reviewed-acceptance",
-				agent: "worker",
+				agent: "builder",
 				cwd: root,
 				systemPromptMode: "replace",
 				inheritProjectContext: false,
@@ -206,7 +206,7 @@ describe("async resume lookup", () => {
 					criteria: ["Return evidence"],
 					evidence: ["validation-output"],
 					verify: [],
-					review: { agent: "reviewer", required: true },
+					review: { agent: "commentator", required: true },
 					stopRules: [],
 				},
 			});
@@ -230,12 +230,12 @@ describe("async resume lookup", () => {
 			fs.writeFileSync(sessionFile, "", "utf-8");
 			writeJson(path.join(asyncDir, "status.json"), {
 				runId: "run-inferred-acceptance", mode: "single", state: "paused", startedAt: 100, lastUpdate: 200, cwd: root,
-				steps: [{ agent: "worker", status: "paused", sessionFile }],
+				steps: [{ agent: "builder", status: "paused", sessionFile }],
 			});
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), {
 				version: 1,
 				sourceRunId: "run-inferred-acceptance",
-				agent: "worker",
+				agent: "builder",
 				cwd: root,
 				systemPromptMode: "replace",
 				inheritProjectContext: false,
@@ -250,7 +250,7 @@ describe("async resume lookup", () => {
 					criteria: [],
 					evidence: [],
 					verify: [],
-					review: { agent: "reviewer", required: true },
+					review: { agent: "commentator", required: true },
 					stopRules: [],
 				},
 			});
@@ -280,7 +280,7 @@ describe("async resume lookup", () => {
 				lastUpdate: 200,
 				cwd: root,
 				sessionFile,
-				steps: [{ agent: "worker", status: "stopped", stopped: true, sessionFile }],
+				steps: [{ agent: "builder", status: "stopped", stopped: true, sessionFile }],
 			});
 
 			assert.throws(
@@ -301,14 +301,14 @@ describe("async resume lookup", () => {
 				mode: "single",
 				state: "running",
 				startedAt: 100,
-				steps: [{ agent: "scout", status: "running" }],
+				steps: [{ agent: "explorer", status: "running" }],
 			});
 			writeJson(path.join(asyncRoot, "run-ab", "status.json"), {
 				runId: "run-ab",
 				mode: "single",
 				state: "running",
 				startedAt: 100,
-				steps: [{ agent: "worker", status: "running" }],
+				steps: [{ agent: "builder", status: "running" }],
 			});
 
 			assert.throws(
@@ -350,7 +350,7 @@ describe("async resume lookup", () => {
 				startedAt: 100,
 				lastUpdate: 200,
 				sessionFile,
-				steps: [{ agent: "worker", status: "complete" }],
+				steps: [{ agent: "builder", status: "complete" }],
 			});
 
 			assert.throws(
@@ -368,10 +368,10 @@ describe("async resume lookup", () => {
 			const resultsDir = path.join(root, "results");
 			writeJson(path.join(resultsDir, "run-result.json"), {
 				id: "run-result",
-				agent: "worker",
+				agent: "builder",
 				success: true,
 				state: "complete",
-				results: [{ agent: "worker", sessionFile: { path: "session.jsonl" } }],
+				results: [{ agent: "builder", sessionFile: { path: "session.jsonl" } }],
 			});
 
 			assert.throws(
@@ -389,10 +389,10 @@ describe("async resume lookup", () => {
 			const resultsDir = path.join(root, "results");
 			writeJson(path.join(resultsDir, "run-result-model.json"), {
 				id: "run-result-model",
-				agent: "worker",
+				agent: "builder",
 				success: true,
 				state: "complete",
-				results: [{ agent: "worker", model: { id: "bad" } }],
+				results: [{ agent: "builder", model: { id: "bad" } }],
 			});
 
 			assert.throws(
@@ -402,10 +402,10 @@ describe("async resume lookup", () => {
 
 			writeJson(path.join(resultsDir, "run-result-model.json"), {
 				id: "run-result-model",
-				agent: "worker",
+				agent: "builder",
 				success: true,
 				state: "complete",
-				results: [{ agent: "worker", thinking: { level: "high" } }],
+				results: [{ agent: "builder", thinking: { level: "high" } }],
 			});
 
 			assert.throws(
@@ -427,7 +427,7 @@ describe("async resume lookup", () => {
 				mode: "single",
 				state: "running",
 				startedAt: 100,
-				steps: [{ agent: "worker", status: "running" }],
+				steps: [{ agent: "builder", status: "running" }],
 			});
 
 			assert.throws(
@@ -448,7 +448,7 @@ describe("async resume lookup", () => {
 				mode: "single",
 				state: "running",
 				startedAt: 100,
-				steps: [{ agent: "worker", status: "running", model: { id: "bad" } }],
+				steps: [{ agent: "builder", status: "running", model: { id: "bad" } }],
 			});
 
 			assert.throws(
@@ -461,7 +461,7 @@ describe("async resume lookup", () => {
 				mode: "single",
 				state: "running",
 				startedAt: 100,
-				steps: [{ agent: "worker", status: "running", thinking: { level: "high" } }],
+				steps: [{ agent: "builder", status: "running", thinking: { level: "high" } }],
 			});
 
 			assert.throws(
@@ -483,7 +483,7 @@ describe("async resume lookup", () => {
 				state: "running",
 				startedAt: 100,
 				lastUpdate: 100,
-				steps: [{ agent: "scout", status: "running", model: "openai/gpt-4.1", thinking: "off" }],
+				steps: [{ agent: "explorer", status: "running", model: "openai/gpt-4.1", thinking: "off" }],
 			});
 
 			const target = resolveAsyncResumeTarget({ id: "run-live" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
@@ -507,19 +507,19 @@ describe("async resume lookup", () => {
 				mode: "single",
 				state: "running",
 				startedAt: 100,
-				steps: [{ agent: "worker", status: "running" }],
+				steps: [{ agent: "builder", status: "running" }],
 			});
 			writeJson(path.join(asyncRoot, "sessionless", "status.json"), {
 				runId: "sessionless",
 				mode: "single",
 				state: "running",
 				startedAt: 100,
-				steps: [{ agent: "worker", status: "running" }],
+				steps: [{ agent: "builder", status: "running" }],
 			});
 			writeJson(path.join(resultsDir, "result-only.json"), {
 				id: "result-only",
 				sessionId: "session-a",
-				agent: "worker",
+				agent: "builder",
 				state: "complete",
 				success: true,
 			});
@@ -529,11 +529,11 @@ describe("async resume lookup", () => {
 				mode: "single",
 				state: "complete",
 				startedAt: 100,
-				steps: [{ agent: "worker", status: "complete" }],
+				steps: [{ agent: "builder", status: "complete" }],
 			});
 			writeJson(path.join(resultsDir, "mixed.json"), {
 				id: "mixed",
-				agent: "worker",
+				agent: "builder",
 				state: "complete",
 				success: true,
 			});
@@ -542,12 +542,12 @@ describe("async resume lookup", () => {
 				mode: "single",
 				state: "complete",
 				startedAt: 100,
-				steps: [{ agent: "worker", status: "complete" }],
+				steps: [{ agent: "builder", status: "complete" }],
 			});
 			writeJson(path.join(resultsDir, "mixed-reverse.json"), {
 				id: "mixed-reverse",
 				sessionId: "session-a",
-				agent: "worker",
+				agent: "builder",
 				state: "complete",
 				success: true,
 			});
@@ -712,14 +712,14 @@ describe("async resume lookup", () => {
 			kind: "revive",
 			runId: "run-old",
 			state: "complete",
-			agent: "worker",
+			agent: "builder",
 			index: 0,
 			sessionFile: "/tmp/session.jsonl",
 		}, "What changed?");
 
 		assert.match(task, /Original run: run-old/);
 		assert.doesNotMatch(task, /async subagent conversation/);
-		assert.match(task, /Original agent: worker/);
+		assert.match(task, /Original agent: builder/);
 		assert.match(task, /Original session file: \/tmp\/session\.jsonl/);
 		assert.match(task, /Follow-up:\nWhat changed\?/);
 	});

package/dist/extensions/pi-subagents/test/unit/authority-policy.test.ts

@@ -0,0 +1,22 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { resolveAuthorityDecision, validateAuthorityPolicy } from "../../src/policy/authority.ts";
+
+describe("authority policy", () => {
+	it("uses conservative cleanup and spawn defaults without obstructing normal control", () => {
+		assert.equal(resolveAuthorityDecision({ action: "discardWorktree" }), "confirm");
+		assert.equal(resolveAuthorityDecision({ action: "destructiveCleanup" }), "confirm");
+		assert.equal(resolveAuthorityDecision({ action: "spawnBudgetGrant" }), "confirm");
+		assert.equal(resolveAuthorityDecision({ action: "scheduleCreate" }), "auto");
+		assert.equal(resolveAuthorityDecision({ action: "stopRun" }), "auto");
+		assert.equal(resolveAuthorityDecision({ action: "steerRun" }), "auto");
+	});
+
+	it("accepts only fixed actions and decisions", () => {
+		const policy = validateAuthorityPolicy({ discardWorktree: "forbid", stopRun: "confirm" });
+		assert.equal(resolveAuthorityDecision({ action: "discardWorktree", policy }), "forbid");
+		assert.equal(resolveAuthorityDecision({ action: "stopRun", policy }), "confirm");
+		assert.throws(() => validateAuthorityPolicy({ mergePullRequest: "auto" }), /unknown/);
+		assert.throws(() => validateAuthorityPolicy({ discardWorktree: "sometimes" }), /auto.*confirm.*forbid/);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/background-work.test.ts

@@ -49,7 +49,7 @@ function writeStatus(root: string, id: string, state: string, sessionId = "sessi
 		startedAt: now,
 		lastUpdate: now,
 		pid: 999999,
-		steps: [{ agent: "worker", status: state }],
+		steps: [{ agent: "builder", status: state }],
 	}));
 }
 

package/dist/extensions/pi-subagents/test/unit/capability-ceiling-agent-allowlist.test.ts

@@ -28,16 +28,16 @@ function agent(name: string): AgentConfig {
 
 describe("capability ceiling agent allowlist", () => {
 	it("parses, round-trips, and intersects allowedAgents", () => {
-		const parsed = parseSubagentCapabilityCeiling({ version: 1, allowedAgents: ["worker", "reviewer", "worker"], denyExtensions: false, sources: ["plan"] });
-		assert.deepEqual(parsed.allowedAgents, ["reviewer", "worker"]);
+		const parsed = parseSubagentCapabilityCeiling({ version: 1, allowedAgents: ["builder", "commentator", "builder"], denyExtensions: false, sources: ["plan"] });
+		assert.deepEqual(parsed.allowedAgents, ["builder", "commentator"]);
 		assert.deepEqual(decodeSubagentCapabilityCeiling(encodeSubagentCapabilityCeiling(parsed)), parsed);
 
 		assert.deepEqual(intersectSubagentCapabilityCeilings(
-			{ version: 1, allowedAgents: ["worker", "reviewer"], denyExtensions: false, sources: ["outer"] },
-			{ version: 1, allowedAgents: ["reviewer", "scout"], denyExtensions: true, sources: ["inner"] },
+			{ version: 1, allowedAgents: ["builder", "commentator"], denyExtensions: false, sources: ["outer"] },
+			{ version: 1, allowedAgents: ["commentator", "explorer"], denyExtensions: true, sources: ["inner"] },
 		), {
 			version: 1,
-			allowedAgents: ["reviewer"],
+			allowedAgents: ["commentator"],
 			denyExtensions: true,
 			sources: ["inner", "outer"],
 		});
@@ -58,40 +58,6 @@ describe("capability ceiling agent allowlist", () => {
 			assert.match(text, /- commentator /);
 			assert.match(text, /Restricted agents \(not executable in this session; capability ceiling: plan-mode\):/);
 			assert.match(text, /- builder /);
-
-			const catalog = (result as { details: { catalog?: unknown } }).details.catalog as
-				| undefined
-				| {
-					version: number;
-					agents: Array<{ name: string; executable: boolean; restrictionSources?: string[]; defaultContext: string }>;
-					capabilityCeilingSources?: string[];
-				};
-			assert.ok(catalog, "list result must include machine catalog metadata");
-			assert.equal(catalog.version, 1);
-			assert.deepEqual(catalog.capabilityCeilingSources, ["plan-mode"]);
-			const commentator = catalog.agents.find((entry) => entry.name === "commentator");
-			const builder = catalog.agents.find((entry) => entry.name === "builder");
-			assert.equal(commentator?.executable, true);
-			assert.equal(commentator?.restrictionSources, undefined);
-			assert.equal(commentator?.defaultContext, "fresh");
-			assert.equal(builder?.executable, false);
-			assert.deepEqual(builder?.restrictionSources, ["plan-mode"]);
-		} finally {
-			handle.dispose();
-		}
-	});
-
-	it("never recommends a capability-restricted writer for implementation list task advice", () => {
-		const sessionId = `allowlist-advice-${Date.now()}-${Math.random()}`;
-		const handle = registerSubagentCapabilityCeiling({ sessionId, source: "plan-mode", ceiling: { allowedAgents: ["commentator"] } });
-		try {
-			const result = handleList({ task: "Implement the fix" }, { cwd: process.cwd(), currentSessionId: sessionId, modelRegistry: { getAvailable: () => [] } });
-			assert.equal(result.isError, false);
-			const text = result.content[0]?.text ?? "";
-			assert.match(text, /Task-aware advisory routing:/);
-			assert.match(text, /- Intent: implementation/);
-			assert.match(text, /- Recommendation: none/);
-			assert.doesNotMatch(text, /- Recommended: /);
 		} finally {
 			handle.dispose();
 		}

package/dist/extensions/pi-subagents/test/unit/chain-append.test.ts

@@ -44,13 +44,13 @@ describe("chain append requests", () => {
 				startedAt: 100,
 				lastUpdate: 100,
 				chainStepCount: 1,
-				steps: [{ agent: "scout", status: "running" }],
+				steps: [{ agent: "explorer", status: "running" }],
 			});
 
 			const result = enqueueChainAppendRequest({
 				asyncDir,
 				runId: "run-a",
-				steps: [runnerStep("worker")],
+				steps: [runnerStep("builder")],
 				now: 200,
 			});
 
@@ -80,15 +80,15 @@ describe("chain append requests", () => {
 				mode: "chain",
 				state: "running",
 				startedAt: 100,
-				steps: [{ agent: "scout", status: "running" }],
+				steps: [{ agent: "explorer", status: "running" }],
 			});
 			enqueueChainAppendRequest({
 				asyncDir,
 				runId: "run-pending",
 				steps: [{
 					parallel: [
-						{ ...runnerStep("worker"), outputName: "draft" },
-						{ ...runnerStep("reviewer"), outputName: "review" },
+						{ ...runnerStep("builder"), outputName: "draft" },
+						{ ...runnerStep("commentator"), outputName: "review" },
 					],
 				}],
 				now: 200,
@@ -113,10 +113,10 @@ describe("chain append requests", () => {
 				mode: "chain",
 				state: "complete",
 				startedAt: 100,
-				steps: [{ agent: "scout", status: "complete" }],
+				steps: [{ agent: "explorer", status: "complete" }],
 			});
 			assert.throws(
-				() => enqueueChainAppendRequest({ asyncDir: completeDir, runId: "complete", steps: [runnerStep("worker")] }),
+				() => enqueueChainAppendRequest({ asyncDir: completeDir, runId: "complete", steps: [runnerStep("builder")] }),
 				/only running chain runs/,
 			);
 
@@ -126,10 +126,10 @@ describe("chain append requests", () => {
 				mode: "parallel",
 				state: "running",
 				startedAt: 100,
-				steps: [{ agent: "scout", status: "running" }],
+				steps: [{ agent: "explorer", status: "running" }],
 			});
 			assert.throws(
-				() => enqueueChainAppendRequest({ asyncDir: parallelDir, runId: "parallel", steps: [runnerStep("worker")] }),
+				() => enqueueChainAppendRequest({ asyncDir: parallelDir, runId: "parallel", steps: [runnerStep("builder")] }),
 				/only active chain runs/,
 			);
 
@@ -139,10 +139,10 @@ describe("chain append requests", () => {
 				mode: "chain",
 				state: "running",
 				startedAt: 100,
-				steps: [{ agent: "scout", status: "complete" }],
+				steps: [{ agent: "explorer", status: "complete" }],
 			});
 			assert.throws(
-				() => enqueueChainAppendRequest({ asyncDir: drainedDir, runId: "drained", steps: [runnerStep("worker")] }),
+				() => enqueueChainAppendRequest({ asyncDir: drainedDir, runId: "drained", steps: [runnerStep("builder")] }),
 				/no running or pending chain steps left/,
 			);
 		} finally {
@@ -158,7 +158,7 @@ describe("chain append requests", () => {
 			startedAt: 100,
 			currentStep: 0,
 			chainStepCount: 1,
-			steps: [{ agent: "scout", status: "complete" }],
+			steps: [{ agent: "explorer", status: "complete" }],
 			parallelGroups: [],
 			workflowGraph: {
 				runId: "run-graph",
@@ -167,8 +167,8 @@ describe("chain append requests", () => {
 				nodes: [{
 					id: "step-0",
 					kind: "step",
-					agent: "scout",
-					label: "scout",
+					agent: "explorer",
+					label: "explorer",
 					status: "completed",
 					flatIndex: 0,
 					stepIndex: 0,
@@ -176,10 +176,10 @@ describe("chain append requests", () => {
 			},
 		};
 		const appended: RunnerStep[] = [
-			runnerStep("worker"),
+			runnerStep("builder"),
 			{
 				parallel: [
-					runnerStep("reviewer"),
+					runnerStep("commentator"),
 					runnerStep("auditor"),
 				],
 				concurrency: 2,
@@ -193,9 +193,9 @@ describe("chain append requests", () => {
 		assert.equal(status.pendingAppends, 0);
 		assert.equal(status.lastUpdate, 300);
 		assert.deepEqual(status.steps?.map((step) => `${step.agent}:${step.status}`), [
-			"scout:complete",
-			"worker:pending",
-			"reviewer:pending",
+			"explorer:complete",
+			"builder:pending",
+			"commentator:pending",
 			"auditor:pending",
 		]);
 		// Appended steps must carry their own bounded task description for fleet display.