@selesai/code 0.6.3 → 0.8.0

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

@@ -43,7 +43,7 @@ function makeChain(name: string, source: ChainConfig["source"]): ChainConfig {
 		description: `${name} chain`,
 		source,
 		filePath: `/tmp/${name}.chain.md`,
-		steps: [{ agent: "worker", task: "Work" }],
+		steps: [{ agent: "builder", task: "Work" }],
 	};
 }
 

package/dist/extensions/pi-subagents/test/unit/dynamic-fanout.test.ts

@@ -16,7 +16,7 @@ const outputs: ChainOutputMap = {
 	targets: {
 		text: "{\"items\":[{\"path\":\"src/a.ts\"},{\"path\":\"src/b.ts\"}]}",
 		structured: { items: [{ path: "src/a.ts" }, { path: "src/b.ts" }] },
-		agent: "scout",
+		agent: "explorer",
 		stepIndex: 0,
 	},
 };
@@ -26,7 +26,7 @@ describe("dynamic fanout helpers", () => {
 		assert.deepEqual(resolveJsonPointer({ items: [1, 2] }, "/items/1", "path"), 2);
 		const step: ChainStep = {
 			expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path", maxItems: 4 },
-			parallel: { agent: "reviewer", task: "Review {target.path}", label: "Review {target.path}" },
+			parallel: { agent: "commentator", task: "Review {target.path}", label: "Review {target.path}" },
 			collect: { as: "reviews" },
 		};
 		const materialized = materializeDynamicParallelStep(step, outputs, 1);
@@ -38,7 +38,7 @@ describe("dynamic fanout helpers", () => {
 	it("rejects missing structured sources, over-limit arrays, duplicate keys, colliding ids, and bad templates", () => {
 		const base: ChainStep = {
 			expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path", maxItems: 4 },
-			parallel: { agent: "reviewer", task: "Review {target.path}" },
+			parallel: { agent: "commentator", task: "Review {target.path}" },
 			collect: { as: "reviews" },
 		};
 		assert.throws(
@@ -46,7 +46,7 @@ describe("dynamic fanout helpers", () => {
 			/exceeding maxItems/,
 		);
 		assert.throws(
-			() => materializeDynamicParallelStep(base, { targets: { text: "plain", agent: "scout", stepIndex: 0 } }, 1),
+			() => materializeDynamicParallelStep(base, { targets: { text: "plain", agent: "explorer", stepIndex: 0 } }, 1),
 			/requires structured output/,
 		);
 		assert.throws(
@@ -58,15 +58,15 @@ describe("dynamic fanout helpers", () => {
 			/colliding item id/,
 		);
 		assert.throws(
-			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "reviewer", task: "Review {other.path}" } }, outputs, 1),
+			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "commentator", task: "Review {other.path}" } }, outputs, 1),
 			/Unsupported template reference/,
 		);
 		assert.throws(
-			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "reviewer", task: "Review {target[path]}" } }, outputs, 1),
+			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "commentator", task: "Review {target[path]}" } }, outputs, 1),
 			/Invalid item reference/,
 		);
 		assert.throws(
-			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "reviewer", task: "Review {target.path" } }, outputs, 1),
+			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "commentator", task: "Review {target.path" } }, outputs, 1),
 			/Invalid item reference/,
 		);
 	});
@@ -74,13 +74,13 @@ describe("dynamic fanout helpers", () => {
 	it("allows config maxItems defaults and handles empty arrays deterministically", () => {
 		const base: ChainStep = {
 			expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path" },
-			parallel: { agent: "reviewer", task: "Review {target.path}" },
+			parallel: { agent: "commentator", task: "Review {target.path}" },
 			collect: { as: "reviews" },
 		};
 		const materialized = materializeDynamicParallelStep(base, outputs, 1, { maxItems: 4 });
 		assert.equal(materialized.parallel.length, 2);
 		assert.doesNotThrow(() => validateChainOutputBindings([
-			{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+			{ agent: "explorer", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
 			base,
 		], { maxItems: 4 }));
 		const empty = materializeDynamicParallelStep(base, { targets: { ...outputs.targets, structured: { items: [] } } }, 1, { maxItems: 4 });
@@ -95,29 +95,29 @@ describe("dynamic fanout helpers", () => {
 		const malformed = [
 			{
 				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: [{ agent: "reviewer", task: "Review" }],
+				parallel: [{ agent: "commentator", task: "Review" }],
 				collect: { as: "reviews" },
 			},
 			{
 				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: { agent: "reviewer", task: "Review {item.path}" },
+				parallel: { agent: "commentator", task: "Review {item.path}" },
 			},
 			{
 				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: { agent: "reviewer", task: "Review {item.path}" },
+				parallel: { agent: "commentator", task: "Review {item.path}" },
 				collect: { as: "reviews" },
 				when: "later",
 			},
 			{
 				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: { agent: "reviewer", task: "Review {item.path}", as: "child" },
+				parallel: { agent: "commentator", task: "Review {item.path}", as: "child" },
 				collect: { as: "reviews" },
 			},
 		] as ChainStep[];
 
 		for (const step of malformed) {
 			assert.throws(
-				() => validateChainOutputBindings([{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } }, step]),
+				() => validateChainOutputBindings([{ agent: "explorer", task: "Return targets", as: "targets", outputSchema: { type: "object" } }, step]),
 				ChainOutputValidationError,
 			);
 		}
@@ -129,7 +129,7 @@ describe("dynamic fanout helpers", () => {
 		// (allowRunnerFields) without leaking into the user-facing dynamic field whitelist.
 		const runnerStep = {
 			expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-			parallel: { agent: "reviewer", task: "Review {item.path}", parentSessionId: "session-parent" },
+			parallel: { agent: "commentator", task: "Review {item.path}", parentSessionId: "session-parent" },
 			collect: { as: "reviews" },
 		} as unknown as Parameters<typeof validateDynamicStepShape>[0];
 		assert.doesNotThrow(() => validateDynamicStepShape(runnerStep, 1, { allowRunnerFields: true }));
@@ -142,7 +142,7 @@ describe("dynamic fanout helpers", () => {
 	it("accepts toolBudget on dynamic parallel templates", () => {
 		const step = {
 			expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-			parallel: { agent: "reviewer", task: "Review {item.path}", toolBudget: { hard: 3 } },
+			parallel: { agent: "commentator", task: "Review {item.path}", toolBudget: { hard: 3 } },
 			collect: { as: "reviews" },
 		} as unknown as Parameters<typeof validateDynamicStepShape>[0];
 
@@ -151,10 +151,10 @@ describe("dynamic fanout helpers", () => {
 
 	it("validates source ordering and collect name collisions", () => {
 		const chain: ChainStep[] = [
-			{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+			{ agent: "explorer", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
 			{
 				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: { agent: "reviewer", task: "Review {item.path}" },
+				parallel: { agent: "commentator", task: "Review {item.path}" },
 				collect: { as: "targets" },
 			},
 		];
@@ -167,24 +167,24 @@ describe("dynamic fanout helpers", () => {
 
 	it("validates appended steps against prior and reserved output names", () => {
 		assert.doesNotThrow(() => validateChainOutputBindingsWithContext([
-			{ agent: "worker", task: "Use {outputs.targets}", as: "summary" },
+			{ agent: "builder", task: "Use {outputs.targets}", as: "summary" },
 		], {}, { priorOutputNames: ["targets"], startStepIndex: 2 }));
 		assert.throws(
 			() => validateChainOutputBindingsWithContext([
-				{ agent: "worker", task: "Use {outputs.missing}" },
+				{ agent: "builder", task: "Use {outputs.missing}" },
 			], {}, { priorOutputNames: ["targets"], startStepIndex: 2 }),
 			/Unknown chain output reference '\{outputs\.missing\}' at step 3/,
 		);
 		assert.throws(
 			() => validateChainOutputBindingsWithContext([
-				{ agent: "worker", task: "Use {previous}", as: "targets" },
+				{ agent: "builder", task: "Use {previous}", as: "targets" },
 			], {}, { priorOutputNames: ["targets"], startStepIndex: 2 }),
 			/Duplicate chain output name 'targets'/,
 		);
 		assert.doesNotThrow(() => validateChainOutputBindingsWithContext([
 			{
 				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: { agent: "reviewer", task: "Review {item.path}" },
+				parallel: { agent: "commentator", task: "Review {item.path}" },
 				collect: { as: "reviews" },
 			},
 		], {}, { priorOutputNames: ["targets"], startStepIndex: 2 }));
@@ -193,7 +193,7 @@ describe("dynamic fanout helpers", () => {
 	it("collects ordered child result records and validates aggregate schema", async () => {
 		const step: ChainStep = {
 			expand: { from: { output: "targets", path: "/items" }, key: "/path", maxItems: 4 },
-			parallel: { agent: "reviewer", task: "Review {item.path}" },
+			parallel: { agent: "commentator", task: "Review {item.path}" },
 			collect: { as: "reviews" },
 		};
 		const materialized = materializeDynamicParallelStep(step, outputs, 1);
@@ -207,8 +207,8 @@ describe("dynamic fanout helpers", () => {
 			finalOutput: "ok",
 			structuredOutput,
 		});
-		const timedOut = { ...result("reviewer", { ok: "b" }), exitCode: 1, error: "Subagent timed out after 300ms.", timedOut: true };
-		const collected = collectDynamicResults(step, materialized.items, [result("reviewer", { ok: "a" }), timedOut]);
+		const timedOut = { ...result("commentator", { ok: "b" }), exitCode: 1, error: "Subagent timed out after 300ms.", timedOut: true };
+		const collected = collectDynamicResults(step, materialized.items, [result("commentator", { ok: "a" }), timedOut]);
 		assert.deepEqual(collected.map((item) => item.key), ["src/a.ts", "src/b.ts"]);
 		assert.deepEqual(collected.map((item) => item.structured), [{ ok: "a" }, { ok: "b" }]);
 		assert.equal(collected[1]?.timedOut, true);

package/dist/extensions/pi-subagents/test/unit/ensure-accessible-dir.test.ts

@@ -0,0 +1,125 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import { ensureAccessibleDir } from "../../src/shared/accessible-dir.ts";
+import { DIRS } from "../../src/shared/types.ts";
+
+class FakeFs {
+	created: string[] = [];
+	blockedMkdir = new Set<string>();
+	blockedAccess = new Set<string>();
+
+	mkdirSync(dirPath: string): void {
+		if (this.blockedMkdir.has(dirPath)) {
+			const error = new Error("mkdir blocked") as NodeJS.ErrnoException;
+			error.code = "EPERM";
+			throw error;
+		}
+		this.created.push(dirPath);
+	}
+
+	accessSync(dirPath: string): void {
+		if (this.blockedAccess.has(dirPath)) {
+			const error = new Error("access blocked") as NodeJS.ErrnoException;
+			error.code = "EPERM";
+			throw error;
+		}
+	}
+}
+
+function fakeOptions(fakeFs: FakeFs) {
+	return {
+		fs: fakeFs,
+		pid: 12345,
+		retryDirectoryErrors: true,
+		retryDelaysMs: [] as readonly number[],
+		wait: () => {},
+	};
+}
+
+describe("ensureAccessibleDir", () => {
+	it("returns the requested path when it is usable", () => {
+		const fakeFs = new FakeFs();
+		const dirPath = "/tmp/pi-subagents-ok/results";
+
+		const result = ensureAccessibleDir(dirPath, fakeOptions(fakeFs));
+
+		assert.equal(result, dirPath);
+		assert.deepEqual(fakeFs.created, [dirPath]);
+	});
+
+	it("falls back to a pid-scoped sibling when mkdir is persistently blocked", () => {
+		const fakeFs = new FakeFs();
+		const dirPath = "/tmp/pi-subagents-mkdir-eperm/results";
+		fakeFs.blockedMkdir.add(dirPath);
+
+		const result = ensureAccessibleDir(dirPath, fakeOptions(fakeFs));
+
+		assert.equal(result, `${dirPath}-12345`);
+		assert.deepEqual(fakeFs.created, [`${dirPath}-12345`]);
+	});
+
+	it("falls back to a pid-scoped sibling when access is persistently blocked", () => {
+		const fakeFs = new FakeFs();
+		const dirPath = "/tmp/pi-subagents-access-eperm/results";
+		fakeFs.blockedAccess.add(dirPath);
+
+		const result = ensureAccessibleDir(dirPath, fakeOptions(fakeFs));
+
+		assert.equal(result, `${dirPath}-12345`);
+		assert.deepEqual(fakeFs.created, [dirPath, `${dirPath}-12345`]);
+	});
+
+	it("does not delete existing primary directory contents when falling back", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-accessible-dir-"));
+		try {
+			const dirPath = path.join(root, "async-subagent-runs");
+			const statusPath = path.join(dirPath, "run-1", "status.json");
+			fs.mkdirSync(path.dirname(statusPath), { recursive: true });
+			fs.writeFileSync(statusPath, "{}", "utf-8");
+
+			const fsImpl = {
+				mkdirSync: fs.mkdirSync,
+				accessSync(target: string, mode?: number): void {
+					if (target === dirPath) {
+						const error = new Error("access blocked") as NodeJS.ErrnoException;
+						error.code = "EPERM";
+						throw error;
+					}
+					fs.accessSync(target, mode);
+				},
+			};
+
+			const result = ensureAccessibleDir(dirPath, {
+				fs: fsImpl,
+				pid: 12345,
+				retryDirectoryErrors: true,
+				retryDelaysMs: [] as readonly number[],
+				wait: () => {},
+			});
+
+			assert.equal(result, `${dirPath}-12345`);
+			assert.equal(fs.readFileSync(statusPath, "utf-8"), "{}");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("DIRS", () => {
+	it("allows runtime reassignment for live async and results paths", () => {
+		const originalResults = DIRS.results;
+		const originalAsync = DIRS.async;
+		try {
+			DIRS.results = "/tmp/fallback-results";
+			DIRS.async = "/tmp/fallback-async";
+			assert.equal(DIRS.results, "/tmp/fallback-results");
+			assert.equal(DIRS.async, "/tmp/fallback-async");
+		} finally {
+			DIRS.results = originalResults;
+			DIRS.async = originalAsync;
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/external-cli-runner.test.ts

@@ -0,0 +1,94 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, describe, it } from "node:test";
+import { buildExternalCliPrompt, runExternalCli } from "../../src/runs/shared/external-cli-runner.ts";
+
+const tempDirs: string[] = [];
+function tempDir(): string {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-external-cli-"));
+	tempDirs.push(dir);
+	return dir;
+}
+afterEach(() => {
+	for (const dir of tempDirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
+});
+
+describe("external CLI runner", () => {
+	it("delivers the combined prompt only through stdin and preserves argv", async () => {
+		const dir = tempDir();
+		const prompt = buildExternalCliPrompt("Follow exactly.", "Review $HOME; echo nope");
+		const result = await runExternalCli({
+			command: process.execPath,
+			args: ["-e", "let s='';process.stdin.on('data',c=>s+=c);process.stdin.on('end',()=>process.stdout.write(JSON.stringify({argv:process.argv.slice(1),stdin:s})))", "argument with spaces", "$NOT_EXPANDED"],
+			cwd: dir,
+			prompt,
+			asyncDir: dir,
+			stepIndex: 0,
+		});
+		assert.equal(result.exitCode, 0);
+		assert.deepEqual(JSON.parse(result.output), { argv: ["argument with spaces", "$NOT_EXPANDED"], stdin: prompt });
+		assert.equal(fs.readFileSync(result.externalProcess.stdoutPath, "utf-8"), result.output);
+	});
+
+	it("flushes both full logs before returning while retaining a bounded stdout tail", async () => {
+		const dir = tempDir();
+		const stdout = "x".repeat(2 * 1024 * 1024) + "STDOUT_TAIL";
+		const stderr = "y".repeat(2 * 1024 * 1024) + "STDERR_TAIL";
+		const scriptPath = path.join(dir, "large-output.mjs");
+		fs.writeFileSync(scriptPath, `process.stdout.write(${JSON.stringify(stdout)});process.stderr.write(${JSON.stringify(stderr)})`);
+		const result = await runExternalCli({ command: process.execPath, args: [scriptPath], cwd: dir, prompt: "x", asyncDir: dir, stepIndex: 1 });
+		assert.equal(result.exitCode, 0);
+		assert.equal(result.output.length, 64 * 1024);
+		assert.match(result.output, /STDOUT_TAIL$/);
+		assert.equal(fs.readFileSync(result.externalProcess.stdoutPath, "utf-8"), stdout);
+		assert.equal(fs.readFileSync(result.externalProcess.stderrPath, "utf-8"), stderr);
+	});
+
+	it("rejects when a log stream cannot be written", async () => {
+		const dir = tempDir();
+		fs.mkdirSync(path.join(dir, "external-2.stdout.log"));
+		await assert.rejects(
+			runExternalCli({ command: process.execPath, args: ["-e", "process.stdout.write('output')"], cwd: dir, prompt: "x", asyncDir: dir, stepIndex: 2 }),
+			/EISDIR|illegal operation on a directory/i,
+		);
+	});
+
+	it("returns stderr for a nonzero exit", async () => {
+		const dir = tempDir();
+		const result = await runExternalCli({ command: process.execPath, args: ["-e", "console.error('specific failure');process.exit(7)"], cwd: dir, prompt: "x", asyncDir: dir, stepIndex: 1 });
+		assert.equal(result.exitCode, 7);
+		assert.equal(result.error, "specific failure");
+		assert.match(fs.readFileSync(result.externalProcess.stderrPath, "utf-8"), /specific failure/);
+	});
+
+	it("reports a missing executable without retrying", async () => {
+		const dir = tempDir();
+		const result = await runExternalCli({ command: path.join(dir, "does-not-exist"), cwd: dir, prompt: "x", asyncDir: dir, stepIndex: 2 });
+		assert.equal(result.exitCode, 1);
+		assert.match(result.error ?? "", /ENOENT|not found/i);
+	});
+
+	it("terminates on timeout", async () => {
+		const dir = tempDir();
+		let timeout: (() => void) | undefined;
+		const pending = runExternalCli({ command: process.execPath, args: ["-e", "setInterval(()=>{},1000)"], cwd: dir, prompt: "x", asyncDir: dir, stepIndex: 3, registerTimeout: (handler) => { timeout = handler; }, timeoutMessage: "timed out for test" });
+		await new Promise((resolve) => setTimeout(resolve, 50));
+		timeout?.();
+		const result = await pending;
+		assert.equal(result.timedOut, true);
+		assert.equal(result.error, "timed out for test");
+	});
+
+	it("terminates on stop", async () => {
+		const dir = tempDir();
+		let stop: (() => void) | undefined;
+		const pending = runExternalCli({ command: process.execPath, args: ["-e", "setInterval(()=>{},1000)"], cwd: dir, prompt: "x", asyncDir: dir, stepIndex: 4, registerStop: (handler) => { stop = handler; }, stopMessage: "stopped for test" });
+		await new Promise((resolve) => setTimeout(resolve, 50));
+		stop?.();
+		const result = await pending;
+		assert.equal(result.stopped, true);
+		assert.equal(result.error, "stopped for test");
+	});
+});

package/dist/extensions/pi-subagents/test/unit/external-runs.test.ts

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+	EXTERNAL_RUN_REGISTRY_KEY,
+	registerExternalRunProvider,
+	snapshotExternalRuns,
+} from "../../src/api/external-runs.ts";
+
+function clearRegistry(): void {
+	delete (globalThis as Record<PropertyKey, unknown>)[Symbol.for(EXTERNAL_RUN_REGISTRY_KEY)];
+}
+
+test("external-run providers expose scoped observational records without controls", () => {
+	clearRegistry();
+	const dispose = registerExternalRunProvider({
+		name: "interactive-shell",
+		listExternalRuns: () => [{
+			id: "review-794",
+			sessionId: "session-a",
+			source: "interactive_shell",
+			state: "completed",
+			completionReason: "auto-close-quiet",
+			cwd: "/tmp/review",
+			reportPath: "/tmp/review.md",
+			exitCode: null,
+			residualRisks: ["The terminal runtime owns process control."],
+		}],
+	});
+	assert.deepEqual(snapshotExternalRuns("session-a"), [{
+		provider: "interactive-shell",
+		id: "review-794",
+		sessionId: "session-a",
+		source: "interactive_shell",
+		state: "completed",
+		completionReason: "auto-close-quiet",
+		cwd: "/tmp/review",
+		reportPath: "/tmp/review.md",
+		exitCode: null,
+		residualRisks: ["The terminal runtime owns process control."],
+	}]);
+	assert.deepEqual(snapshotExternalRuns("session-b"), []);
+	dispose();
+	clearRegistry();
+});
+
+test("external-run providers reject malformed and duplicate records", () => {
+	clearRegistry();
+	assert.throws(() => registerExternalRunProvider({ name: " bad", listExternalRuns: () => [] }), /trimmed/);
+	registerExternalRunProvider({
+		name: "interactive-shell",
+		listExternalRuns: () => [
+			{ id: "run", sessionId: "session-a", source: "interactive_shell", state: "running", extra: true },
+		] as never,
+	});
+	assert.throws(() => snapshotExternalRuns("session-a"), /unknown fields: extra/);
+	clearRegistry();
+	registerExternalRunProvider({
+		name: "interactive-shell",
+		listExternalRuns: () => [
+			{ id: "run", sessionId: "session-a", source: "interactive_shell", state: "running" },
+			{ id: "run", sessionId: "session-a", source: "interactive_shell", state: "running" },
+		],
+	});
+	assert.throws(() => snapshotExternalRuns("session-a"), /duplicate run 'run'/);
+	clearRegistry();
+});

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

@@ -44,16 +44,16 @@ describe("SELESAI_SUBAGENT_EXTRA_AGENT_DIRS discovery", () => {
 
 	it("discovers agents from the env-provided dirs as a 'user' source", () => {
 		const bundledDir = path.join(tempDir, "store", "agents");
-		const bundledAgent = writeAgent(bundledDir, "bundled-reviewer");
+		const bundledAgent = writeAgent(bundledDir, "bundled-commentator");
 		process.env[EXTRA_AGENT_DIRS_ENV] = bundledDir;
 
 		const scoped = discoverAgents(cwd, "user");
-		const found = scoped.agents.find((agent) => agent.name === "bundled-reviewer");
+		const found = scoped.agents.find((agent) => agent.name === "bundled-commentator");
 		assert.ok(found, "expected bundled agent under 'user' scope");
 		assert.equal(found?.filePath, bundledAgent);
 
 		const all = discoverAgentsAll(cwd);
-		assert.ok(all.user.find((agent) => agent.name === "bundled-reviewer" && agent.filePath === bundledAgent));
+		assert.ok(all.user.find((agent) => agent.name === "bundled-commentator" && agent.filePath === bundledAgent));
 	});
 
 	it("scans every directory listed (PATH-style delimiter)", () => {