@selesai/code 0.8.2 → 0.8.4

package/dist/extensions/pi-subagents/test/unit/completion-replay.test.ts

@@ -0,0 +1,187 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import { createRequire, syncBuiltinESMExports } from "node:module";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import { cleanupCompletionReplay, completionArchivePath, readCompletionArchive, readCompletionReplay, writeCompletionArchive } from "../../src/runs/background/completion-replay.ts";
+import { utf8Tail } from "../../src/shared/utf8.ts";
+import { collectWaitCompletions, recordWaitCompletion } from "../../src/runs/background/wait-completions.ts";
+import type { AsyncRunSummary } from "../../src/runs/background/async-status.ts";
+import type { SubagentState } from "../../src/shared/types.ts";
+
+const require = createRequire(import.meta.url);
+const fsCjs = require("node:fs") as typeof fs;
+
+function makeState(): SubagentState {
+	return {
+		baseCwd: "",
+		currentSessionId: "session-a",
+		asyncJobs: new Map(),
+		foregroundControls: new Map(),
+		lastForegroundControlId: null,
+		cleanupTimers: new Map(),
+		lastUiContext: null,
+		poller: null,
+		completionSeen: new Map(),
+		watcher: null,
+		watcherRestartTimer: null,
+		resultFileCoalescer: { schedule: () => false, clear: () => {} },
+	} as SubagentState;
+}
+
+describe("completion replay", () => {
+	it("surfaces a consumed completion after in-memory watcher state is lost", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-completion-replay-"));
+		try {
+			const now = Date.now();
+			recordWaitCompletion(makeState(), "run-a", {
+				agent: "worker",
+				mode: "single",
+				state: "complete",
+				success: true,
+				results: [{ agent: "worker", success: true, outputState: "present", output: "finished output" }],
+			}, now, 60_000, { resultsDir, sessionId: "session-a" });
+
+			const replay = readCompletionReplay(resultsDir, "run-a", { sessionId: "session-a", now: now + 1 });
+			assert.equal(replay?.version, 1);
+			assert.equal(replay?.completion.archivePath, replay?.archivePath);
+			assert.equal(readCompletionArchive(replay!.archivePath)?.entries[0]?.text, "[worker]\nfinished output");
+
+			const terminal = [{ id: "run-a", sessionId: "session-a" }] as AsyncRunSummary[];
+			const completions = collectWaitCompletions(terminal, makeState(), resultsDir);
+			assert.equal(completions?.[0]?.runId, "run-a");
+			assert.equal(completions?.[0]?.results?.[0]?.agent, "worker");
+			assert.equal(completions?.[0]?.archivePath, replay?.archivePath);
+		} finally {
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps UTF-8 tails valid at multibyte boundaries", () => {
+		const bounded = utf8Tail(`start-${"é".repeat(10)}-tail`, 9);
+		assert.equal(bounded.truncated, true);
+		assert.equal(bounded.text, "éé-tail");
+	});
+
+	it("does not delete untrusted or cross-run archive paths from replay records", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-completion-replay-untrusted-"));
+		try {
+			const resultsDir = path.join(root, "results");
+			const replayDir = path.join(resultsDir, "completion-replay");
+			fs.mkdirSync(replayDir, { recursive: true });
+			const victim = path.join(root, "victim.txt");
+			fs.writeFileSync(victim, "keep", "utf-8");
+			fs.writeFileSync(path.join(replayDir, `${encodeURIComponent("run-c")}.json`), JSON.stringify({
+				version: 1,
+				runId: "run-c",
+				sessionId: "session-a",
+				completedAt: 1,
+				expiresAt: 2,
+				archivePath: victim,
+				completion: { runId: "run-c", archivePath: victim },
+			}), "utf-8");
+
+			const replayPath = path.join(replayDir, `${encodeURIComponent("run-c")}.json`);
+			assert.equal(readCompletionReplay(resultsDir, "run-c", { sessionId: "session-a", now: 1 }), undefined);
+			assert.equal(fs.readFileSync(victim, "utf-8"), "keep");
+			assert.equal(fs.existsSync(replayPath), false);
+
+			fs.writeFileSync(replayPath, JSON.stringify({
+				version: 1,
+				runId: "run-c",
+				sessionId: "session-a",
+				completedAt: 1,
+				expiresAt: 2,
+				archivePath: victim,
+				completion: { runId: "run-c", archivePath: victim },
+			}), "utf-8");
+			cleanupCompletionReplay(resultsDir, 3, 60_000);
+			assert.equal(fs.readFileSync(victim, "utf-8"), "keep");
+			assert.equal(fs.existsSync(replayPath), false);
+
+			const victimArchive = completionArchivePath(resultsDir, "run-a");
+			fs.mkdirSync(path.dirname(victimArchive), { recursive: true });
+			fs.writeFileSync(victimArchive, "keep", "utf-8");
+			fs.writeFileSync(replayPath, JSON.stringify({
+				version: 1,
+				runId: "run-a",
+				sessionId: "session-a",
+				completedAt: 1,
+				expiresAt: 2,
+				archivePath: victimArchive,
+				completion: { runId: "run-a", archivePath: victimArchive },
+			}), "utf-8");
+			cleanupCompletionReplay(resultsDir, 3, 60_000);
+			assert.equal(fs.readFileSync(victimArchive, "utf-8"), "keep");
+			assert.equal(fs.existsSync(replayPath), false);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("treats replay read deletion failures as best-effort cleanup", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-completion-replay-rm-failure-"));
+		const originalRmSync = fsCjs.rmSync;
+		try {
+			const resultsDir = path.join(root, "results");
+			const replayDir = path.join(resultsDir, "completion-replay");
+			const replayPath = path.join(replayDir, `${encodeURIComponent("run-d")}.json`);
+			const archivePath = completionArchivePath(resultsDir, "run-d");
+			fs.mkdirSync(replayDir, { recursive: true });
+			fs.mkdirSync(path.dirname(archivePath), { recursive: true });
+			fs.writeFileSync(archivePath, "archive", "utf-8");
+			fs.writeFileSync(replayPath, JSON.stringify({
+				version: 1,
+				runId: "run-d",
+				sessionId: "session-a",
+				completedAt: 1,
+				expiresAt: 2,
+				archivePath,
+				completion: { runId: "run-d", archivePath },
+			}), "utf-8");
+
+			fsCjs.rmSync = ((target: Parameters<typeof fs.rmSync>[0], options?: Parameters<typeof fs.rmSync>[1]) => {
+				if (String(target) === replayPath || String(target) === archivePath) {
+					const error = new Error("busy") as NodeJS.ErrnoException;
+					error.code = "EPERM";
+					throw error;
+				}
+				return originalRmSync(target, options);
+			}) as typeof fs.rmSync;
+			syncBuiltinESMExports();
+
+			assert.equal(readCompletionReplay(resultsDir, "run-d", { sessionId: "session-a", now: 3 }), undefined);
+			assert.equal(fs.existsSync(replayPath), true);
+			assert.equal(fs.existsSync(archivePath), true);
+		} finally {
+			fsCjs.rmSync = originalRmSync;
+			syncBuiltinESMExports();
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("prefers saved outputs and bounds fallback output tails", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-completion-archive-"));
+		try {
+			const savedOutput = path.join(root, "saved-output.md");
+			fs.writeFileSync(savedOutput, "saved", "utf-8");
+			const archivePath = writeCompletionArchive(root, "run-b", {
+				results: [
+					{ agent: "saved", output: "duplicate text", artifactPaths: { outputPath: savedOutput } },
+					{ agent: "fallback", output: `start-${"x".repeat(70 * 1024)}-tail` },
+				],
+			}, Date.now());
+			const archive = readCompletionArchive(archivePath);
+			assert.deepEqual(archive?.entries[0], { agent: "saved", source: "output-artifact", path: savedOutput });
+			const fallback = archive?.entries[1];
+			assert.equal(fallback?.source, "result-tail");
+			assert.equal(fallback?.truncated, true);
+			assert.ok(Buffer.byteLength(fallback?.text ?? "", "utf-8") <= 64 * 1024);
+			assert.match(fallback?.text ?? "", /-tail$/);
+			assert.equal((fallback?.text ?? "").includes("duplicate text"), false);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/control-channel.test.ts

@@ -13,6 +13,9 @@ import {
 	deliverInterruptRequest,
 	enqueueStepSteer,
 	interruptRequestPath,
+	MAX_STEER_QUEUE_SIZE,
+	queueRevivalBrief,
+	readRevivalBriefs,
 	requestAsyncInterrupt,
 	requestAsyncSteer,
 	requestAsyncStop,
@@ -108,13 +111,13 @@ describe("control channel: request file", () => {
 	it("writes and consumes ordered steer requests", () => {
 		const asyncDir = tmpAsyncDir("pi-control-steer-");
 		try {
-			requestAsyncSteer(asyncDir, { message: "  later guidance  ", targetIndex: 1, id: "b", ts: 200, source: "test" });
+			requestAsyncSteer(asyncDir, { message: "  later guidance  ", mode: "follow_up", targetIndex: 1, id: "b", ts: 200, source: "test" });
 			requestAsyncSteer(asyncDir, { message: "first guidance", targetIndexes: [0, 2], id: "a", ts: 100 });
 			assert.equal(fs.readdirSync(steerRequestsDir(asyncDir)).length, 2);
 
 			assert.deepEqual(consumeSteerRequests(asyncDir), [
 				{ type: "steer", id: "a", ts: 100, message: "first guidance", targetIndexes: [0, 2] },
-				{ type: "steer", id: "b", ts: 200, message: "later guidance", targetIndex: 1, source: "test" },
+				{ type: "steer", id: "b", ts: 200, message: "later guidance", mode: "follow_up", targetIndex: 1, source: "test" },
 			]);
 			assert.deepEqual(consumeSteerRequests(asyncDir), []);
 		} finally {
@@ -210,6 +213,19 @@ describe("control channel: request file", () => {
 		}
 	});
 
+	it("bounds retained revival briefs and keeps them FIFO", () => {
+		const asyncDir = tmpAsyncDir("pi-control-revival-brief-");
+		try {
+			for (let index = 0; index < MAX_STEER_QUEUE_SIZE; index++) {
+				queueRevivalBrief(asyncDir, { type: "steer", id: `brief-${index}`, ts: index + 1, message: `brief ${index}`, mode: "follow_up" });
+			}
+			assert.deepEqual(readRevivalBriefs(asyncDir).map(({ request }) => request.id), Array.from({ length: MAX_STEER_QUEUE_SIZE }, (_, index) => `brief-${index}`));
+			assert.throws(() => queueRevivalBrief(asyncDir, { type: "steer", id: "full", ts: 99, message: "too much", mode: "follow_up" }), /queue is full/);
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
 	it("rejects empty steer messages and invalid target indexes", () => {
 		const asyncDir = tmpAsyncDir("pi-control-steer-invalid-");
 		try {
@@ -232,16 +248,27 @@ describe("control channel: request file", () => {
 		try {
 			const capabilityPath = writeSteerCapability(asyncDir, { index: 0, pid: 42, readyAt: 100, supported: true });
 			assert.equal(capabilityPath, steerCapabilityPath(asyncDir, 0));
-			writeSteerAck(asyncDir, { requestId: "../request", index: 0, ts: 101, state: "delivered", message: "accepted" });
+			writeSteerAck(asyncDir, { requestId: "../request", index: 0, ts: 101, state: "queued", deliveryStatus: "queued", message: "accepted" });
 			assert.equal(path.dirname(steerAckPathFromDir(steerAcksDir(asyncDir, 0), "../request")), steerAcksDir(asyncDir, 0));
 			assert.deepEqual(consumeSteerCapabilities(asyncDir), [{ type: "steer-capability", protocolVersion: 1, index: 0, pid: 42, readyAt: 100, supported: true }]);
-			assert.deepEqual(consumeSteerAcks(asyncDir), [{ type: "steer-ack", protocolVersion: 1, requestId: "../request", index: 0, ts: 101, state: "delivered", message: "accepted" }]);
+			assert.deepEqual(consumeSteerAcks(asyncDir), [{ type: "steer-ack", protocolVersion: 1, requestId: "../request", index: 0, ts: 101, state: "queued", deliveryStatus: "queued", message: "accepted" }]);
 			assert.deepEqual(consumeSteerAcks(asyncDir), []);
 		} finally {
 			cleanup(asyncDir);
 		}
 	});
 
+	it("preserves queued and delivered receipts for the same request", () => {
+		const asyncDir = tmpAsyncDir("pi-control-steer-ack-order-");
+		try {
+			writeSteerAck(asyncDir, { requestId: "follow", index: 0, ts: 101, state: "queued", deliveryStatus: "queued", message: "queued" });
+			writeSteerAck(asyncDir, { requestId: "follow", index: 0, ts: 102, state: "delivered", deliveryStatus: "delivered", message: "delivered" });
+			assert.deepEqual(consumeSteerAcks(asyncDir).map((ack) => ack.state), ["queued", "delivered"]);
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
 	it("ignores malformed capabilities and acknowledgments", () => {
 		const asyncDir = tmpAsyncDir("pi-control-steer-malformed-");
 		try {
@@ -260,75 +287,22 @@ describe("control channel: request file", () => {
 });
 
 describe("control channel: deliverInterruptRequest", () => {
-	it("writes the portable request and signals best-effort when kill succeeds", () => {
-		const asyncDir = tmpAsyncDir("pi-control-deliver-ok-");
+	it("writes the portable request without signaling an unverified pid", () => {
+		const asyncDir = tmpAsyncDir("pi-control-deliver-file-only-");
 		try {
 			const kills: Array<{ pid: number; signal?: NodeJS.Signals | 0 }> = [];
-			deliverInterruptRequest({
+			const unverifiedInput = {
 				asyncDir,
 				pid: 4242,
-				signal: "SIGUSR2",
-				kill: (pid, signal) => {
+				signal: "SIGUSR2" as NodeJS.Signals,
+				kill: (pid: number, signal?: NodeJS.Signals | 0) => {
 					kills.push({ pid, signal });
 					return true;
 				},
-			});
-			assert.equal(fs.existsSync(interruptRequestPath(asyncDir)), true);
-			assert.deepEqual(kills, [{ pid: 4242, signal: "SIGUSR2" }]);
-		} finally {
-			cleanup(asyncDir);
-		}
-	});
-
-	it("still writes the request when the OS signal throws ENOSYS (Windows)", () => {
-		const asyncDir = tmpAsyncDir("pi-control-deliver-enosys-");
-		try {
-			assert.doesNotThrow(() =>
-				deliverInterruptRequest({
-					asyncDir,
-					pid: 4242,
-					kill: () => {
-						const error = new Error("kill ENOSYS") as NodeJS.ErrnoException;
-						error.code = "ENOSYS";
-						throw error;
-					},
-				}),
-			);
-			assert.equal(fs.existsSync(interruptRequestPath(asyncDir)), true);
-		} finally {
-			cleanup(asyncDir);
-		}
-	});
-
-	it("surfaces non-portability signal failures and removes the stale request", () => {
-		const asyncDir = tmpAsyncDir("pi-control-deliver-esrch-");
-		try {
-			assert.throws(
-				() =>
-					deliverInterruptRequest({
-						asyncDir,
-						pid: 4242,
-						kill: () => {
-							const error = new Error("missing process") as NodeJS.ErrnoException;
-							error.code = "ESRCH";
-							throw error;
-						},
-					}),
-				/missing process/,
-			);
-			assert.equal(fs.existsSync(interruptRequestPath(asyncDir)), false);
-		} finally {
-			cleanup(asyncDir);
-		}
-	});
-
-	it("skips signalling when no live pid is provided", () => {
-		const asyncDir = tmpAsyncDir("pi-control-deliver-nopid-");
-		try {
-			let killed = false;
-			deliverInterruptRequest({ asyncDir, kill: () => { killed = true; return true; } });
-			assert.equal(killed, false);
+			};
+			deliverInterruptRequest(unverifiedInput);
 			assert.equal(fs.existsSync(interruptRequestPath(asyncDir)), true);
+			assert.deepEqual(kills, []);
 		} finally {
 			cleanup(asyncDir);
 		}
@@ -339,14 +313,19 @@ describe("control channel: watchAsyncControlInbox", () => {
 	type WatchHarness = {
 		fsImpl: import("../../src/runs/background/control-channel.ts").ControlChannelFs;
 		timers: import("../../src/runs/background/control-channel.ts").ControlChannelTimers;
-		trigger: () => void;
+		trigger: (dir?: string) => void;
+		triggerError: (dir?: string) => void;
 		closed: () => boolean;
+		intervalCount: () => number;
+		intervalDelays: () => number[];
 		watchedDir: () => string | undefined;
 	};
 
 	function harness(nativeDir?: string): WatchHarness {
-		let listener: (() => void) | undefined;
+		const listeners = new Map<string, () => void>();
+		const errorListeners = new Map<string, () => void>();
 		let closed = false;
+		const intervalDelays: number[] = [];
 		let watchedDir: string | undefined;
 		const realpathSync = ((target: fs.PathLike, options?: unknown) => fs.realpathSync(target, options as BufferEncoding)) as typeof fs.realpathSync;
 		realpathSync.native = ((target: fs.PathLike) => nativeDir ?? fs.realpathSync.native(target)) as typeof fs.realpathSync.native;
@@ -359,15 +338,38 @@ describe("control channel: watchAsyncControlInbox", () => {
 			realpathSync,
 			watch: ((dir: string, cb: () => void) => {
 				watchedDir = dir;
-				listener = cb;
-				return { close: () => { closed = true; }, on: () => {} };
+				listeners.set(dir, cb);
+				return {
+					close: () => { closed = true; },
+					on: (event: string, handler: () => void) => {
+						if (event === "error") errorListeners.set(dir, handler);
+					},
+				};
 			}),
 		} as unknown as WatchHarness["fsImpl"];
 		const timers = {
-			setInterval: (() => ({ unref() {} })) as unknown as typeof setInterval,
+			setInterval: ((_handler: Parameters<typeof setInterval>[0], delay?: number) => {
+				intervalDelays.push(delay ?? 0);
+				return { unref() {} };
+			}) as unknown as typeof setInterval,
 			clearInterval: (() => {}) as unknown as typeof clearInterval,
 		};
-		return { fsImpl, timers, trigger: () => listener?.(), closed: () => closed, watchedDir: () => watchedDir };
+		return {
+			fsImpl,
+			timers,
+			trigger: (dir?: string) => {
+				if (dir) listeners.get(dir)?.();
+				else for (const listener of listeners.values()) listener();
+			},
+			triggerError: (dir?: string) => {
+				if (dir) errorListeners.get(dir)?.();
+				else for (const listener of errorListeners.values()) listener();
+			},
+			closed: () => closed,
+			intervalCount: () => intervalDelays.length,
+			intervalDelays: () => [...intervalDelays],
+			watchedDir: () => watchedDir,
+		};
 	}
 
 	it("registers the native canonical control inbox path", () => {
@@ -383,6 +385,32 @@ describe("control channel: watchAsyncControlInbox", () => {
 		}
 	});
 
+	it("does not start fast polling when native watch is available", () => {
+		const asyncDir = tmpAsyncDir("pi-control-watch-no-poll-");
+		try {
+			const h = harness();
+			const dispose = watchAsyncControlInbox(asyncDir, { onInterrupt() {}, fs: h.fsImpl, timers: h.timers });
+			assert.deepEqual(h.intervalDelays(), [5000]);
+			dispose();
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
+	it("starts portable polling once when the native watcher fails", () => {
+		const asyncDir = tmpAsyncDir("pi-control-watch-fallback-");
+		try {
+			const h = harness();
+			const dispose = watchAsyncControlInbox(asyncDir, { onInterrupt() {}, fs: h.fsImpl, timers: h.timers });
+			h.triggerError();
+			h.triggerError();
+			assert.deepEqual(h.intervalDelays(), [5000, 250]);
+			dispose();
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
+
 	it("fires on a request that arrived before the watcher started", () => {
 		const asyncDir = tmpAsyncDir("pi-control-watch-early-");
 		try {
@@ -471,4 +499,30 @@ describe("control channel: watchAsyncControlInbox", () => {
 			cleanup(asyncDir);
 		}
 	});
+
+	it("delivers later steer files from the watched request directory without polling", () => {
+		const asyncDir = tmpAsyncDir("pi-control-watch-steer-nested-");
+		try {
+			const steers: string[] = [];
+			const h = harness();
+			const dispose = watchAsyncControlInbox(asyncDir, {
+				onInterrupt() {},
+				onSteer: (request) => steers.push(request.message),
+				fs: h.fsImpl,
+				timers: h.timers,
+			});
+
+			const watchedSteerDir = fs.realpathSync.native(steerRequestsDir(asyncDir));
+			requestAsyncSteer(asyncDir, { message: "first", id: "s1", ts: 1 });
+			h.trigger(watchedSteerDir);
+			requestAsyncSteer(asyncDir, { message: "second", id: "s2", ts: 2 });
+			h.trigger(watchedSteerDir);
+
+			assert.deepEqual(steers, ["first", "second"]);
+			assert.deepEqual(h.intervalDelays(), [5000]);
+			dispose();
+		} finally {
+			cleanup(asyncDir);
+		}
+	});
 });

package/dist/extensions/pi-subagents/test/unit/control-notices.test.ts

@@ -26,9 +26,9 @@ function needsAttentionEvent(overrides: Partial<ControlEvent> = {}): ControlEven
 		to: "needs_attention",
 		ts: 1,
 		runId: "run-1",
-		agent: "builder",
+		agent: "worker",
 		index: 0,
-		message: "builder needs attention",
+		message: "worker needs attention",
 		reason: "idle",
 		...overrides,
 	};
@@ -62,6 +62,21 @@ describe("subagent control notice delivery", () => {
 		assert.deepEqual(recorder.sent[0]?.options, { triggerTurn: true });
 	});
 
+	it("delivers goal notices without starting a new turn", () => {
+		const state = makeState();
+		const recorder = makeRecorder();
+
+		handleSubagentControlNotice({
+			pi: recorder.pi,
+			state,
+			visibleControlNotices: new Set(),
+			details: { source: "goal", event: needsAttentionEvent(), noticeText: "Goal is ready." },
+		});
+
+		assert.equal(recorder.sent.length, 1);
+		assert.deepEqual(recorder.sent[0]?.options, { triggerTurn: false });
+	});
+
 	it("does not queue a foreground notice that Pi could flush after completion", () => {
 		const state = makeState();
 		state.foregroundControls.set("run-1", {
@@ -69,7 +84,7 @@ describe("subagent control notice delivery", () => {
 			mode: "parallel",
 			startedAt: 0,
 			updatedAt: 0,
-			currentAgent: "builder",
+			currentAgent: "worker",
 			currentIndex: 0,
 			currentActivityState: "needs_attention",
 		});

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

@@ -55,18 +55,18 @@ describe("subagents.defaultExtensions", () => {
 	});
 
 	it("preserves ambient discovery when omitted and disables it when empty", () => {
-		let explorer = discoverAgentsAll(tempProject).builtin.find(
-			(agent) => agent.name === "explorer",
+		let scout = discoverAgentsAll(tempProject).builtin.find(
+			(agent) => agent.name === "scout",
 		);
-		assert.equal(explorer?.extensions, undefined);
+		assert.equal(scout?.extensions, undefined);
 
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
 			subagents: { defaultExtensions: [] },
 		});
-		explorer = discoverAgentsAll(tempProject).builtin.find(
-			(agent) => agent.name === "explorer",
+		scout = discoverAgentsAll(tempProject).builtin.find(
+			(agent) => agent.name === "scout",
 		);
-		assert.deepEqual(explorer?.extensions, []);
+		assert.deepEqual(scout?.extensions, []);
 	});
 
 	it("applies the allowlist only when an agent has no extensions field", () => {
@@ -97,7 +97,7 @@ describe("subagents.defaultExtensions", () => {
 			subagents: {
 				defaultExtensions: [],
 				agentOverrides: {
-					explorer: { extensions: ["./explorer.ts"] },
+					scout: { extensions: ["./scout.ts"] },
 					inherited: { extensions: ["./inherited.ts"] },
 					explicit: { extensions: ["./ignored.ts"] },
 				},
@@ -108,8 +108,8 @@ describe("subagents.defaultExtensions", () => {
 
 		const agents = discoverAgents(tempProject, "both").agents;
 		assert.deepEqual(
-			agents.find((agent) => agent.name === "explorer")?.extensions,
-			["./explorer.ts"],
+			agents.find((agent) => agent.name === "scout")?.extensions,
+			["./scout.ts"],
 		);
 		assert.deepEqual(
 			agents.find((agent) => agent.name === "inherited")?.extensions,
@@ -185,19 +185,19 @@ describe("subagents.defaultExtensions", () => {
 
 		assert.deepEqual(
 			discoverAgents(tempProject, "both").agents.find(
-				(agent) => agent.name === "explorer",
+				(agent) => agent.name === "scout",
 			)?.extensions,
 			[],
 		);
 		assert.deepEqual(
 			discoverAgents(tempProject, "user").agents.find(
-				(agent) => agent.name === "explorer",
+				(agent) => agent.name === "scout",
 			)?.extensions,
 			["./user.ts"],
 		);
 		assert.deepEqual(
 			discoverAgents(tempProject, "project").agents.find(
-				(agent) => agent.name === "explorer",
+				(agent) => agent.name === "scout",
 			)?.extensions,
 			[],
 		);