@selesai/code 0.8.2 → 0.8.4

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: "builder", status: "complete" }],
+				steps: [{ agent: "worker", 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, "builder");
+			assert.equal(target.agent, "worker");
 			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: "builder", status: "complete", sessionFile, capabilityCeiling: { version: 1, allowedTools: ["read"], denyExtensions: false, sources: ["step"] } }],
+				steps: [{ agent: "worker", 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: "builder", status: "complete", sessionFile }],
+				steps: [{ agent: "worker", 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: "builder", success: true, sessionFile, capabilityCeiling: { version: 1, allowedTools: ["read"], denyExtensions: true, sources: ["result-step"] } }],
+				results: [{ agent: "worker", 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: "builder", success: true, sessionFile, capabilityCeiling: { version: 1, allowedTools: ["read"], denyExtensions: true } }],
+				results: [{ agent: "worker", 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: "builder", status: "paused", sessionFile }],
+				steps: [{ agent: "worker", status: "paused", sessionFile }],
 			});
 			const descriptor = {
-				version: 1, sourceRunId: "run-descriptor", agent: "builder", cwd: root, systemPromptMode: "replace",
+				version: 1, sourceRunId: "run-descriptor", agent: "worker", 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,61 @@ 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 'builder'/);
+			assert.throws(() => resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir }), /not 'worker'/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("normalizes persisted turn-budget state without weakening public input validation", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-turn-budget-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const asyncDir = path.join(asyncRoot, "run-turn-budget");
+			const resultsDir = path.join(root, "results");
+			const sessionFile = path.join(root, "session.jsonl");
+			fs.writeFileSync(sessionFile, "", "utf-8");
+			writeJson(path.join(asyncDir, "status.json"), {
+				runId: "run-turn-budget", mode: "single", state: "paused", startedAt: 100, lastUpdate: 200, cwd: root,
+				steps: [{ agent: "worker", status: "paused", sessionFile }],
+			});
+			const descriptor = {
+				version: 1,
+				sourceRunId: "run-turn-budget",
+				agent: "worker",
+				cwd: root,
+				systemPromptMode: "replace",
+				inheritProjectContext: false,
+				inheritSkills: false,
+				outputMode: "inline",
+				maxSubagentDepth: 2,
+				share: false,
+			};
+			writeJson(path.join(asyncDir, "recovery-descriptor.json"), {
+				...descriptor,
+				initialTurnBudget: {
+					maxTurns: 8,
+					graceTurns: 2,
+					outcome: "within-budget",
+					turnCount: 0,
+					wrapUpRequestedAtTurn: 8,
+					terminationDeferredAtTurn: 10,
+					exceededAtTurn: 11,
+				},
+			});
+
+			const target = resolveAsyncResumeTarget({ id: "run-turn-budget" }, { asyncDirRoot: asyncRoot, resultsDir });
+
+			assert.deepEqual(target.recoveryDescriptor?.initialTurnBudget, { maxTurns: 8, graceTurns: 2 });
+
+			writeJson(path.join(asyncDir, "recovery-descriptor.json"), {
+				...descriptor,
+				initialTurnBudget: { maxTurns: 8, graceTurns: 2, unrelated: true },
+			});
+			assert.throws(
+				() => resolveAsyncResumeTarget({ id: "run-turn-budget" }, { asyncDirRoot: asyncRoot, resultsDir }),
+				/recoveryDescriptor\.initialTurnBudget\.unrelated is not supported/,
+			);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
@@ -137,12 +191,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: "builder", status: "paused", sessionFile }],
+				steps: [{ agent: "worker", status: "paused", sessionFile }],
 			});
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), {
 				version: 1,
 				sourceRunId: "run-acceptance",
-				agent: "builder",
+				agent: "worker",
 				cwd: root,
 				systemPromptMode: "replace",
 				inheritProjectContext: false,
@@ -186,12 +240,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: "builder", status: "paused", sessionFile }],
+				steps: [{ agent: "worker", status: "paused", sessionFile }],
 			});
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), {
 				version: 1,
 				sourceRunId: "run-reviewed-acceptance",
-				agent: "builder",
+				agent: "worker",
 				cwd: root,
 				systemPromptMode: "replace",
 				inheritProjectContext: false,
@@ -206,7 +260,7 @@ describe("async resume lookup", () => {
 					criteria: ["Return evidence"],
 					evidence: ["validation-output"],
 					verify: [],
-					review: { agent: "commentator", required: true },
+					review: { agent: "reviewer", required: true },
 					stopRules: [],
 				},
 			});
@@ -230,12 +284,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: "builder", status: "paused", sessionFile }],
+				steps: [{ agent: "worker", status: "paused", sessionFile }],
 			});
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), {
 				version: 1,
 				sourceRunId: "run-inferred-acceptance",
-				agent: "builder",
+				agent: "worker",
 				cwd: root,
 				systemPromptMode: "replace",
 				inheritProjectContext: false,
@@ -250,7 +304,7 @@ describe("async resume lookup", () => {
 					criteria: [],
 					evidence: [],
 					verify: [],
-					review: { agent: "commentator", required: true },
+					review: { agent: "reviewer", required: true },
 					stopRules: [],
 				},
 			});
@@ -280,7 +334,7 @@ describe("async resume lookup", () => {
 				lastUpdate: 200,
 				cwd: root,
 				sessionFile,
-				steps: [{ agent: "builder", status: "stopped", stopped: true, sessionFile }],
+				steps: [{ agent: "worker", status: "stopped", stopped: true, sessionFile }],
 			});
 
 			assert.throws(
@@ -301,14 +355,14 @@ describe("async resume lookup", () => {
 				mode: "single",
 				state: "running",
 				startedAt: 100,
-				steps: [{ agent: "explorer", status: "running" }],
+				steps: [{ agent: "scout", status: "running" }],
 			});
 			writeJson(path.join(asyncRoot, "run-ab", "status.json"), {
 				runId: "run-ab",
 				mode: "single",
 				state: "running",
 				startedAt: 100,
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			});
 
 			assert.throws(
@@ -350,7 +404,7 @@ describe("async resume lookup", () => {
 				startedAt: 100,
 				lastUpdate: 200,
 				sessionFile,
-				steps: [{ agent: "builder", status: "complete" }],
+				steps: [{ agent: "worker", status: "complete" }],
 			});
 
 			assert.throws(
@@ -368,10 +422,10 @@ describe("async resume lookup", () => {
 			const resultsDir = path.join(root, "results");
 			writeJson(path.join(resultsDir, "run-result.json"), {
 				id: "run-result",
-				agent: "builder",
+				agent: "worker",
 				success: true,
 				state: "complete",
-				results: [{ agent: "builder", sessionFile: { path: "session.jsonl" } }],
+				results: [{ agent: "worker", sessionFile: { path: "session.jsonl" } }],
 			});
 
 			assert.throws(
@@ -389,10 +443,10 @@ describe("async resume lookup", () => {
 			const resultsDir = path.join(root, "results");
 			writeJson(path.join(resultsDir, "run-result-model.json"), {
 				id: "run-result-model",
-				agent: "builder",
+				agent: "worker",
 				success: true,
 				state: "complete",
-				results: [{ agent: "builder", model: { id: "bad" } }],
+				results: [{ agent: "worker", model: { id: "bad" } }],
 			});
 
 			assert.throws(
@@ -402,10 +456,10 @@ describe("async resume lookup", () => {
 
 			writeJson(path.join(resultsDir, "run-result-model.json"), {
 				id: "run-result-model",
-				agent: "builder",
+				agent: "worker",
 				success: true,
 				state: "complete",
-				results: [{ agent: "builder", thinking: { level: "high" } }],
+				results: [{ agent: "worker", thinking: { level: "high" } }],
 			});
 
 			assert.throws(
@@ -427,7 +481,7 @@ describe("async resume lookup", () => {
 				mode: "single",
 				state: "running",
 				startedAt: 100,
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			});
 
 			assert.throws(
@@ -448,7 +502,7 @@ describe("async resume lookup", () => {
 				mode: "single",
 				state: "running",
 				startedAt: 100,
-				steps: [{ agent: "builder", status: "running", model: { id: "bad" } }],
+				steps: [{ agent: "worker", status: "running", model: { id: "bad" } }],
 			});
 
 			assert.throws(
@@ -461,7 +515,7 @@ describe("async resume lookup", () => {
 				mode: "single",
 				state: "running",
 				startedAt: 100,
-				steps: [{ agent: "builder", status: "running", thinking: { level: "high" } }],
+				steps: [{ agent: "worker", status: "running", thinking: { level: "high" } }],
 			});
 
 			assert.throws(
@@ -483,7 +537,7 @@ describe("async resume lookup", () => {
 				state: "running",
 				startedAt: 100,
 				lastUpdate: 100,
-				steps: [{ agent: "explorer", status: "running", model: "openai/gpt-4.1", thinking: "off" }],
+				steps: [{ agent: "scout", status: "running", model: "openai/gpt-4.1", thinking: "off" }],
 			});
 
 			const target = resolveAsyncResumeTarget({ id: "run-live" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
@@ -507,19 +561,19 @@ describe("async resume lookup", () => {
 				mode: "single",
 				state: "running",
 				startedAt: 100,
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			});
 			writeJson(path.join(asyncRoot, "sessionless", "status.json"), {
 				runId: "sessionless",
 				mode: "single",
 				state: "running",
 				startedAt: 100,
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			});
 			writeJson(path.join(resultsDir, "result-only.json"), {
 				id: "result-only",
 				sessionId: "session-a",
-				agent: "builder",
+				agent: "worker",
 				state: "complete",
 				success: true,
 			});
@@ -529,11 +583,11 @@ describe("async resume lookup", () => {
 				mode: "single",
 				state: "complete",
 				startedAt: 100,
-				steps: [{ agent: "builder", status: "complete" }],
+				steps: [{ agent: "worker", status: "complete" }],
 			});
 			writeJson(path.join(resultsDir, "mixed.json"), {
 				id: "mixed",
-				agent: "builder",
+				agent: "worker",
 				state: "complete",
 				success: true,
 			});
@@ -542,12 +596,12 @@ describe("async resume lookup", () => {
 				mode: "single",
 				state: "complete",
 				startedAt: 100,
-				steps: [{ agent: "builder", status: "complete" }],
+				steps: [{ agent: "worker", status: "complete" }],
 			});
 			writeJson(path.join(resultsDir, "mixed-reverse.json"), {
 				id: "mixed-reverse",
 				sessionId: "session-a",
-				agent: "builder",
+				agent: "worker",
 				state: "complete",
 				success: true,
 			});
@@ -712,14 +766,14 @@ describe("async resume lookup", () => {
 			kind: "revive",
 			runId: "run-old",
 			state: "complete",
-			agent: "builder",
+			agent: "worker",
 			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: builder/);
+		assert.match(task, /Original agent: worker/);
 		assert.match(task, /Original session file: \/tmp\/session\.jsonl/);
 		assert.match(task, /Follow-up:\nWhat changed\?/);
 	});

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

@@ -11,8 +11,9 @@ import {
 	snapshotBackgroundWork,
 	type BackgroundWorkSnapshot,
 } from "../../src/api/background-work.ts";
+import { updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
 import { waitForSubagents, type SubagentWaitDeps } from "../../src/runs/background/subagent-wait.ts";
-import type { SubagentState } from "../../src/shared/types.ts";
+import type { AsyncStatus, SubagentState } from "../../src/shared/types.ts";
 
 function clearRegistry(): void {
 	delete (globalThis as Record<PropertyKey, unknown>)[Symbol.for(BACKGROUND_WORK_REGISTRY_KEY)];
@@ -37,7 +38,7 @@ function makeState(sessionId = "session-a"): SubagentState {
 	} as SubagentState;
 }
 
-function writeStatus(root: string, id: string, state: string, sessionId = "session-a"): void {
+function writeStatus(root: string, id: string, state: AsyncStatus["state"], sessionId = "session-a"): void {
 	const dir = path.join(root, id);
 	fs.mkdirSync(dir, { recursive: true });
 	const now = Date.now();
@@ -49,8 +50,9 @@ function writeStatus(root: string, id: string, state: string, sessionId = "sessi
 		startedAt: now,
 		lastUpdate: now,
 		pid: 999999,
-		steps: [{ agent: "builder", status: state }],
+		steps: [{ agent: "worker", status: state }],
 	}));
+	updateActiveRunIndex(dir, state);
 }
 
 function waitDeps(root: string, state: SubagentState, backgroundWork: SubagentWaitDeps["backgroundWork"], sleep: () => Promise<void>): SubagentWaitDeps {

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

@@ -10,7 +10,7 @@ const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "
 const README_PATH = path.join(packageRoot, "README.md");
 const PROMPTING_AND_ROLES_PATH = path.join(packageRoot, "skills", "pi-subagents", "references", "prompting-and-roles.md");
 
-const README_TABLE_HEADING = "## Builtin agents in plain English";
+const README_TABLE_HEADING = "## Builtin agents";
 const PROMPTING_AND_ROLES_TABLE_HEADING = "## Builtin Agents";
 
 /**
@@ -38,10 +38,10 @@ function tableFirstColumnNames(markdown: string, sectionHeading: string): string
 	return names;
 }
 
-function assertExactlySixBuiltins(tablePath: string, heading: string, markdown: string): void {
+function assertExactlyBuiltins(tablePath: string, heading: string, markdown: string): void {
 	const names = tableFirstColumnNames(markdown, heading);
 
-	assert.equal(names.length, 6, `${path.basename(tablePath)}: role table must contain exactly six builtin rows`);
+	assert.equal(names.length, BUILTIN_AGENT_NAMES.length, `${path.basename(tablePath)}: role table must contain exactly ${BUILTIN_AGENT_NAMES.length} builtin rows`);
 	assert.equal(new Set(names).size, names.length, `${path.basename(tablePath)}: role table contains duplicate rows`);
 	assert.deepEqual(
 		[...names].sort(),
@@ -51,13 +51,13 @@ function assertExactlySixBuiltins(tablePath: string, heading: string, markdown:
 }
 
 describe("builtin agent documentation role tables", () => {
-	it("README lists exactly the six canonical builtins once, with no duplicates or aliases", () => {
+	it("README lists exactly the canonical builtins once, with no duplicates or aliases", () => {
 		const markdown = fs.readFileSync(README_PATH, "utf-8");
-		assertExactlySixBuiltins(README_PATH, README_TABLE_HEADING, markdown);
+		assertExactlyBuiltins(README_PATH, README_TABLE_HEADING, markdown);
 	});
 
-	it("prompting-and-roles reference lists exactly the six canonical builtins once, with no duplicates or aliases", () => {
+	it("prompting-and-roles reference lists exactly the canonical builtins once, with no duplicates or aliases", () => {
 		const markdown = fs.readFileSync(PROMPTING_AND_ROLES_PATH, "utf-8");
-		assertExactlySixBuiltins(PROMPTING_AND_ROLES_PATH, PROMPTING_AND_ROLES_TABLE_HEADING, markdown);
+		assertExactlyBuiltins(PROMPTING_AND_ROLES_PATH, PROMPTING_AND_ROLES_TABLE_HEADING, markdown);
 	});
 });

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: ["builder", "commentator", "builder"], denyExtensions: false, sources: ["plan"] });
-		assert.deepEqual(parsed.allowedAgents, ["builder", "commentator"]);
+		const parsed = parseSubagentCapabilityCeiling({ version: 1, allowedAgents: ["worker", "reviewer", "worker"], denyExtensions: false, sources: ["plan"] });
+		assert.deepEqual(parsed.allowedAgents, ["reviewer", "worker"]);
 		assert.deepEqual(decodeSubagentCapabilityCeiling(encodeSubagentCapabilityCeiling(parsed)), parsed);
 
 		assert.deepEqual(intersectSubagentCapabilityCeilings(
-			{ version: 1, allowedAgents: ["builder", "commentator"], denyExtensions: false, sources: ["outer"] },
-			{ version: 1, allowedAgents: ["commentator", "explorer"], denyExtensions: true, sources: ["inner"] },
+			{ version: 1, allowedAgents: ["worker", "reviewer"], denyExtensions: false, sources: ["outer"] },
+			{ version: 1, allowedAgents: ["reviewer", "scout"], denyExtensions: true, sources: ["inner"] },
 		), {
 			version: 1,
-			allowedAgents: ["commentator"],
+			allowedAgents: ["reviewer"],
 			denyExtensions: true,
 			sources: ["inner", "outer"],
 		});
@@ -50,14 +50,14 @@ describe("capability ceiling agent allowlist", () => {
 
 	it("marks non-allowlisted agents as restricted in list output", () => {
 		const sessionId = `allowlist-list-${Date.now()}-${Math.random()}`;
-		const handle = registerSubagentCapabilityCeiling({ sessionId, source: "plan-mode", ceiling: { allowedAgents: ["commentator"] } });
+		const handle = registerSubagentCapabilityCeiling({ sessionId, source: "plan-mode", ceiling: { allowedAgents: ["reviewer"] } });
 		try {
 			const result = handleList({}, { cwd: process.cwd(), currentSessionId: sessionId, modelRegistry: { getAvailable: () => [] } });
 			const text = result.content[0]?.text ?? "";
 			assert.match(text, /Executable agents:/);
-			assert.match(text, /- commentator /);
+			assert.match(text, /- reviewer /);
 			assert.match(text, /Restricted agents \(not executable in this session; capability ceiling: plan-mode\):/);
-			assert.match(text, /- builder /);
+			assert.match(text, /- worker /);
 		} finally {
 			handle.dispose();
 		}
@@ -65,23 +65,23 @@ describe("capability ceiling agent allowlist", () => {
 
 	it("rejects a non-allowlisted agent in preflight launch resolution", async () => {
 		const result = await resolveSubagentLaunchContract({
-			agent: "builder",
+			agent: "worker",
 			cwd: process.cwd(),
-			capabilityCeiling: { version: 1, allowedAgents: ["commentator"], denyExtensions: false, sources: ["plan-mode"] },
+			capabilityCeiling: { version: 1, allowedAgents: ["reviewer"], denyExtensions: false, sources: ["plan-mode"] },
 		});
 		assert.equal(result.ok, false);
 		assert.equal(result.code, "restricted_agent");
-		assert.match(result.message, /does not allow agent 'builder'/);
-		assert.match(result.message, /Allowed agents: commentator/);
+		assert.match(result.message, /does not allow agent 'worker'/);
+		assert.match(result.message, /Allowed agents: reviewer/);
 	});
 
 	it("rejects a non-allowlisted foreground launch before spawning", async () => {
-		const result = await runSync(process.cwd(), [agent("builder"), agent("commentator")], "builder", "Do work", {
-			capabilityCeiling: { version: 1, allowedAgents: ["commentator"], denyExtensions: false, sources: ["plan-mode"] },
+		const result = await runSync(process.cwd(), [agent("worker"), agent("reviewer")], "worker", "Do work", {
+			capabilityCeiling: { version: 1, allowedAgents: ["reviewer"], denyExtensions: false, sources: ["plan-mode"] },
 		});
 		assert.equal(result.exitCode, 1);
-		assert.match(result.error ?? "", /does not allow agent 'builder'/);
-		assert.deepEqual(result.capabilityCeiling?.allowedAgents, ["commentator"]);
+		assert.match(result.error ?? "", /does not allow agent 'worker'/);
+		assert.deepEqual(result.capabilityCeiling?.allowedAgents, ["reviewer"]);
 	});
 
 	it("includes allowedAgents in propagated launch env and audit metadata", () => {
@@ -91,12 +91,12 @@ describe("capability ceiling agent allowlist", () => {
 			sessionEnabled: false,
 			inheritProjectContext: false,
 			inheritSkills: false,
-			childAgentName: "commentator",
-			capabilityCeiling: { version: 1, allowedAgents: ["commentator"], allowedTools: ["read"], denyExtensions: true, sources: ["plan-mode"] },
+			childAgentName: "reviewer",
+			capabilityCeiling: { version: 1, allowedAgents: ["reviewer"], allowedTools: ["read"], denyExtensions: true, sources: ["plan-mode"] },
 		});
 		assert.equal(capabilityAudit?.agentAllowed, true);
 		assert.deepEqual(capabilityAudit?.agentRestrictionSources, ["plan-mode"]);
 		assert.ok(env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1);
-		assert.deepEqual(decodeSubagentCapabilityCeiling(env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1)?.allowedAgents, ["commentator"]);
+		assert.deepEqual(decodeSubagentCapabilityCeiling(env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1)?.allowedAgents, ["reviewer"]);
 	});
 });

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