@selesai/code 0.13.5 → 0.13.7

package/dist/extensions/pi-subagents/test/support/real-session-runner.ts

@@ -308,4 +308,4 @@ export async function runRealSubagentSession(options: RealSessionRunOptions): Pr
 		await dispose();
 		throw error;
 	}
-}
+}

package/dist/extensions/pi-subagents/test/support/register-loader.mjs

@@ -13,4 +13,4 @@
 import { register } from "node:module";
 import "./isolated-temp-root.mjs";
 
-register(new URL("./ts-loader.mjs", import.meta.url));
+register(new URL("./ts-loader.mjs", import.meta.url));

package/dist/extensions/pi-subagents/test/support/session-lease-child.mjs

@@ -39,4 +39,4 @@ const timer = setInterval(() => {
 	clearInterval(timer);
 	lease.release();
 	process.exit(0);
-}, 20);
+}, 20);

package/dist/extensions/pi-subagents/test/support/ts-loader.mjs

@@ -97,4 +97,4 @@ export function resolve(specifier, context, nextResolve) {
   }
 
   return nextResolve(specifier, context);
-}
+}

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

@@ -149,4 +149,4 @@ describe("planAbortRecovery", () => {
 			error: "bash failed (exit 1): request connection error",
 		})).action, "settle");
 	});
-});
+});

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

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -1075,6 +1076,70 @@ describe("acceptance gates", () => {
 		}
 	});
 
+	it("records durable malformed report evidence without relaxing rejection", async () => {
+		const cwd = tempRepo();
+		try {
+			const acceptance = resolveEffectiveAcceptance({
+				agentName: "worker",
+				task: "Implement a fix",
+				explicit: { level: "checked" },
+			});
+			const reportPath = path.join(cwd, "child-report.md");
+			const malformed = JSON.stringify({ criteriaSatisfied: true, commandsRun: ["npm test"] });
+			const ledger = await evaluateAcceptance({
+				acceptance,
+				output: "file-only child output",
+				fileOutput: { content: `ACCEPTANCE_REPORT: ${malformed}`, path: reportPath, authoritative: true, durable: true },
+				cwd,
+			});
+
+			assert.equal(ledger.status, "rejected");
+			assert.deepEqual(ledger.recovery, {
+				status: "available-for-review",
+				reason: "acceptance-metadata-rejected",
+				reportPath,
+				reportHash: createHash("sha256").update(`ACCEPTANCE_REPORT: ${malformed}`).digest("hex"),
+			});
+			const optional = await evaluateAcceptance({
+				acceptance,
+				output: "file-only child output",
+				fileOutput: { content: `ACCEPTANCE_REPORT: ${malformed}`, path: reportPath, authoritative: true, durable: true },
+				cwd,
+				reportOptional: true,
+			});
+			assert.equal(optional.status, "rejected");
+			assert.deepEqual(optional.recovery, ledger.recovery);
+
+			const missing = await evaluateAcceptance({
+				acceptance,
+				output: "file-only child output",
+				fileOutput: { content: "artifact without acceptance metadata", path: reportPath, authoritative: true, durable: true },
+				cwd,
+			});
+			assert.equal(missing.status, "rejected");
+			assert.equal(missing.recovery, undefined);
+			const textOnlyMalformed = await evaluateAcceptance({
+				acceptance,
+				output: `ACCEPTANCE_REPORT: ${malformed}`,
+				fileOutput: { content: "artifact without acceptance metadata", path: reportPath, authoritative: true, durable: true },
+				cwd,
+			});
+			assert.equal(textOnlyMalformed.status, "rejected");
+			assert.equal(textOnlyMalformed.recovery, undefined);
+
+			const unmet = await evaluateAcceptance({
+				acceptance,
+				output: report({ criteriaSatisfied: [{ id: "criterion-1", status: "not-satisfied", evidence: "not proved" }] }),
+				fileOutput: { content: report({ criteriaSatisfied: [{ id: "criterion-1", status: "not-satisfied", evidence: "not proved" }] }), path: reportPath, authoritative: true, durable: true },
+				cwd,
+			});
+			assert.equal(unmet.status, "rejected");
+			assert.equal(unmet.recovery, undefined);
+		} finally {
+			fs.rmSync(cwd, { recursive: true, force: true });
+		}
+	});
+
 	it("surfaces field-level errors from an invalid configured-output report", async () => {
 		const cwd = tempRepo();
 		try {
@@ -1407,4 +1472,4 @@ describe("quoteExecutableForShell", () => {
 			assert.equal(quoteExecutableForShell(command, "win32"), command);
 		}
 	});
-});
+});

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

@@ -79,4 +79,4 @@ describe("ensureAccessibleDir", () => {
 		assert.equal(fakeFs.accessCalls, 1);
 		assert.deepEqual(waits, []);
 	});
-});
+});

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

@@ -412,4 +412,4 @@ describe("active async capacity", () => {
 			}
 		}
 	});
-});
+});

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

@@ -11,4 +11,4 @@ describe("buildExecutionProjection", () => {
 			interrupted: true,
 		});
 	});
-});
+});

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

@@ -210,4 +210,4 @@ describe("builtin agent disabling", () => {
 
 		assert.deepEqual(override, { disabled: false });
 	});
-});
+});

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

@@ -0,0 +1,232 @@
+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, beforeEach, describe, it } from "node:test";
+import { registerAgent } from "../../src/api/agents.ts";
+import { clearAgentDiscoveryCache, discoverAgentSnapshot, discoverAgents, discoverAgentsAll } from "../../src/agents/agents.ts";
+import { mergeRuntimeAgents, clearRuntimeAgentsForPi } from "../../src/agents/runtime-agent-registry.ts";
+import type { ExtensionAPI } from "@selesai/code";
+
+let tempRoot = "";
+let home = "";
+let project = "";
+let pi: ExtensionAPI;
+const previousEnv: Record<string, string | undefined> = {};
+const managedEnv = ["HOME", "USERPROFILE", "SELESAI_CODING_AGENT_DIR", "SELESAI_SUBAGENT_EXTRA_AGENT_DIRS", "PI_OFFLINE"];
+
+function writeAgent(filePath: string, name: string, description: string): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, `---\nname: ${name}\ndescription: ${description}\n---\n\n${description}.\n`, "utf-8");
+}
+
+function writeJson(filePath: string, value: unknown): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
+}
+
+function makePi(): ExtensionAPI {
+	return { on() {}, registerTool() {} } as unknown as ExtensionAPI;
+}
+
+describe("agent discovery snapshots", () => {
+	beforeEach(() => {
+		tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-agent-discovery-cache-"));
+		home = path.join(tempRoot, "home");
+		project = path.join(tempRoot, "project");
+		for (const name of managedEnv) previousEnv[name] = process.env[name];
+		process.env.HOME = home;
+		process.env.USERPROFILE = home;
+		process.env.SELESAI_CODING_AGENT_DIR = path.join(home, ".selesai", "agent");
+		process.env.PI_OFFLINE = "true";
+		delete process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS;
+		pi = makePi();
+		clearAgentDiscoveryCache();
+	});
+
+	afterEach(() => {
+		clearRuntimeAgentsForPi(pi);
+		clearAgentDiscoveryCache();
+		for (const name of managedEnv) {
+			const value = previousEnv[name];
+			if (value === undefined) delete process.env[name];
+			else process.env[name] = value;
+		}
+		fs.rmSync(tempRoot, { recursive: true, force: true });
+	});
+
+	it("keeps effective and all-source projections distinct in one snapshot", () => {
+		const userAgentPath = path.join(home, ".selesai", "agent", "agents", "shared.md");
+		const projectAgentPath = path.join(project, ".selesai", "agents", "shared.md");
+		writeAgent(userAgentPath, "shared", "User shared");
+		writeAgent(projectAgentPath, "shared", "Project shared");
+		writeAgent(path.join(home, ".selesai", "agent", "agents", "scope-hidden.md"), "scope-hidden", "User hidden");
+		writeJson(path.join(project, ".selesai", "settings.json"), {
+			subagents: { agentOverrides: { "scope-hidden": { disabled: true } } },
+		});
+
+		const snapshot = discoverAgentSnapshot(project, "both", undefined, { includeChains: false });
+		assert.equal(snapshot.effective.agents.find((agent) => agent.name === "shared")?.source, "project");
+		assert.equal(snapshot.effective.agents.some((agent) => agent.name === "scope-hidden"), false);
+		assert.equal(snapshot.all.user.some((agent) => agent.name === "shared"), true);
+		assert.equal(snapshot.all.project.some((agent) => agent.name === "shared"), true);
+		assert.equal(snapshot.all.user.some((agent) => agent.name === "scope-hidden"), true);
+		assert.equal(snapshot.all.project.some((agent) => agent.name === "scope-hidden"), false);
+		assert.equal(snapshot.effective.directories.some((directory) => directory.source === "project"), true);
+	});
+
+	it("retains hidden definitions for runtime collision checks", () => {
+		const hiddenPath = path.join(home, ".selesai", "agent", "agents", "scope-hidden.md");
+		writeAgent(hiddenPath, "scope-hidden", "User hidden");
+		const registration = registerAgent({
+			pi,
+			name: "scope-hidden",
+			definition: { description: "Runtime hidden collision", systemPrompt: "Runtime." },
+		});
+		try {
+			const snapshot = discoverAgentSnapshot(project, "project", undefined, { includeChains: false });
+			const configured = [...snapshot.all.builtin, ...snapshot.all.package, ...snapshot.all.user, ...snapshot.all.project];
+			assert.equal(snapshot.effective.agents.some((agent) => agent.name === "scope-hidden"), false);
+			assert.throws(
+				() => mergeRuntimeAgents(pi, snapshot.effective, configured),
+				/collides with configured agent 'scope-hidden'/,
+			);
+		} finally {
+			registration.dispose();
+		}
+	});
+
+	it("invalidates agent and chain projections when files change or appear", () => {
+		const agentPath = path.join(project, ".selesai", "agents", "fresh.md");
+		const chainPath = path.join(project, ".selesai", "chains", "fresh.chain.md");
+		writeAgent(agentPath, "fresh", "Initial agent");
+		fs.mkdirSync(path.dirname(chainPath), { recursive: true });
+		fs.writeFileSync(chainPath, "---\nname: fresh-chain\ndescription: Initial chain\n---\n\n## fresh\nInspect\n", "utf-8");
+
+		const first = discoverAgentSnapshot(project, "both");
+		assert.equal(first.effective.agents.find((agent) => agent.name === "fresh")?.description, "Initial agent");
+		assert.equal(first.all.chains.find((chain) => chain.name === "fresh-chain")?.description, "Initial chain");
+
+		writeAgent(agentPath, "fresh", "Updated agent");
+		fs.writeFileSync(chainPath, "---\nname: fresh-chain\ndescription: Updated chain\n---\n\n## fresh\nInspect\n", "utf-8");
+		const updated = discoverAgentSnapshot(project, "both");
+		assert.equal(updated.effective.agents.find((agent) => agent.name === "fresh")?.description, "Updated agent");
+		assert.equal(updated.all.chains.find((chain) => chain.name === "fresh-chain")?.description, "Updated chain");
+
+		fs.rmSync(agentPath);
+		const addedPath = path.join(project, ".selesai", "agents", "added.md");
+		writeAgent(addedPath, "added", "Added agent");
+		const changedFiles = discoverAgents(project, "both");
+		assert.equal(changedFiles.agents.some((agent) => agent.name === "fresh"), false);
+		assert.equal(changedFiles.agents.some((agent) => agent.name === "added"), true);
+	});
+
+	it("matches scoped discovery settings and precedence for user and project views", () => {
+		writeAgent(path.join(home, ".selesai", "agent", "agents", "shared.md"), "shared", "User shared");
+		writeAgent(path.join(project, ".selesai", "agents", "shared.md"), "shared", "Project shared");
+		writeAgent(path.join(home, ".selesai", "agent", "agents", "user-only.md"), "user-only", "User only");
+		writeAgent(path.join(project, ".selesai", "agents", "project-only.md"), "project-only", "Project only");
+		writeJson(path.join(home, ".selesai", "agent", "settings.json"), { subagents: { agentOverrides: { shared: { description: "User override" } } } });
+		writeJson(path.join(project, ".selesai", "settings.json"), { subagents: { agentOverrides: { shared: { description: "Project override" } } } });
+
+		for (const scope of ["user", "project"] as const) {
+			const direct = discoverAgents(project, scope);
+			const snapshot = discoverAgentSnapshot(project, scope, undefined, { includeChains: false }).effective;
+			assert.deepEqual(snapshot, direct);
+		}
+	});
+
+	it("invalidates when a new agent appears in a previously inspected nested directory", () => {
+		const nestedDir = path.join(project, ".selesai", "agents", "nested");
+		fs.mkdirSync(nestedDir, { recursive: true });
+
+		const initial = discoverAgents(project, "both");
+		assert.equal(initial.agents.some((agent) => agent.name === "nested-agent"), false);
+
+		writeAgent(path.join(nestedDir, "nested-agent.md"), "nested-agent", "Nested agent");
+		const updated = discoverAgents(project, "both");
+		assert.equal(updated.agents.some((agent) => agent.name === "nested-agent"), true);
+	});
+
+	it("does not read out-of-scope user settings for a project snapshot", () => {
+		writeAgent(path.join(project, ".selesai", "agents", "project-agent.md"), "project-agent", "Project agent");
+		const userSettingsPath = path.join(home, ".selesai", "agent", "settings.json");
+		fs.mkdirSync(path.dirname(userSettingsPath), { recursive: true });
+		fs.writeFileSync(userSettingsPath, "{ malformed", "utf-8");
+
+		const snapshot = discoverAgentSnapshot(project, "project", undefined, { includeChains: false });
+		assert.equal(snapshot.effective.agents.some((agent) => agent.name === "project-agent"), true);
+		assert.equal(snapshot.all.project.some((agent) => agent.name === "project-agent"), true);
+	});
+
+	it("keeps shared package agent metadata scoped to the selected settings source", () => {
+		const userPackageRoot = path.join(tempRoot, "user-package");
+		const projectPackageRoot = path.join(tempRoot, "project-package");
+		const sharedAgentDir = path.join(tempRoot, "shared-package-agents");
+		writeJson(path.join(home, ".selesai", "agent", "settings.json"), { packages: [userPackageRoot] });
+		writeJson(path.join(project, ".selesai", "settings.json"), { packages: [projectPackageRoot] });
+		writeJson(path.join(userPackageRoot, "package.json"), {
+			name: "user-package",
+			"pi-subagents": { agents: [path.relative(userPackageRoot, sharedAgentDir)] },
+		});
+		writeJson(path.join(projectPackageRoot, "package.json"), {
+			name: "project-package",
+			"pi-subagents": { agents: [path.relative(projectPackageRoot, sharedAgentDir)] },
+		});
+		writeAgent(path.join(sharedAgentDir, "shared.md"), "shared", "Shared package agent");
+
+		const directUser = discoverAgents(project, "user").agents.find((agent) => agent.name === "shared");
+		const directProject = discoverAgents(project, "project").agents.find((agent) => agent.name === "shared");
+		const snapshotUser = discoverAgentSnapshot(project, "user", undefined, { includeChains: false }).effective.agents.find((agent) => agent.name === "shared");
+		const snapshotProject = discoverAgentSnapshot(project, "project", undefined, { includeChains: false }).effective.agents.find((agent) => agent.name === "shared");
+
+		assert.equal(directUser?.packageSourceName, "user-package");
+		assert.equal(directProject?.packageSourceName, "project-package");
+		assert.equal(snapshotUser?.packageSourceName, directUser?.packageSourceName);
+		assert.equal(snapshotProject?.packageSourceName, directProject?.packageSourceName);
+	});
+
+	it("surfaces malformed in-scope settings while collecting package roots", () => {
+		const settingsPath = path.join(home, ".selesai", "agent", "settings.json");
+		fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+		fs.writeFileSync(settingsPath, "{ malformed", "utf-8");
+
+		assert.throws(
+			() => discoverAgentSnapshot(project, "both", undefined, { includeChains: false }),
+			(error: unknown) => error instanceof Error
+				&& error.message.includes(settingsPath)
+				&& error.message.includes("Failed to parse settings file"),
+		);
+	});
+
+	it("invalidates when project-root policy changes", () => {
+		const outer = path.join(tempRoot, "outer");
+		const nested = path.join(outer, "nested");
+		fs.mkdirSync(path.join(outer, ".git"), { recursive: true });
+		writeAgent(path.join(outer, ".selesai", "agents", "outer.md"), "outer", "Outer agent");
+		writeAgent(path.join(nested, ".selesai", "agents", "nested.md"), "nested", "Nested agent");
+		writeJson(path.join(nested, ".selesai", "settings.json"), { subagents: { projectRootResolution: "git-root" } });
+
+		const gitRoot = discoverAgents(nested, "both");
+		assert.equal(gitRoot.projectAgentsDir, path.join(outer, ".selesai", "agents"));
+		assert.equal(gitRoot.agents.some((agent) => agent.name === "outer"), true);
+		assert.equal(gitRoot.agents.some((agent) => agent.name === "nested"), false);
+
+		writeJson(path.join(nested, ".selesai", "settings.json"), { subagents: { projectRootResolution: "nearest" } });
+		const nearest = discoverAgents(nested, "both");
+		assert.equal(nearest.projectAgentsDir, path.join(nested, ".selesai", "agents"));
+		assert.equal(nearest.agents.some((agent) => agent.name === "nested"), true);
+		assert.equal(nearest.agents.some((agent) => agent.name === "outer"), false);
+	});
+
+	it("does not parse chains on the ordinary effective discovery fast path", () => {
+		const agentPath = path.join(project, ".selesai", "agents", "worker.md");
+		const chainPath = path.join(project, ".selesai", "chains", "broken.chain.md");
+		writeAgent(agentPath, "worker", "Worker");
+		fs.mkdirSync(path.dirname(chainPath), { recursive: true });
+		fs.writeFileSync(chainPath, "not a valid chain", "utf-8");
+
+		assert.equal(discoverAgents(project, "both").agents.some((agent) => agent.name === "worker"), true);
+		assert.equal(discoverAgentsAll(project).chainDiagnostics.some((diagnostic) => diagnostic.filePath === chainPath), true);
+	});
+});

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

@@ -340,4 +340,4 @@ describe("agent eject/disable/enable/reset management actions", () => {
 			assert.match(readText(reset), /not found/);
 		});
 	});
-});
+});

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

@@ -1017,7 +1017,7 @@ Review nested project work.
 		assert.equal(agent.filePath, path.join(packageRoot, "agents", "reviewer.md"));
 	}));
 
-	it("keeps nearest project root discovery by default when a nested .pi exists", () => withTempHome(() => {
+	it("keeps nearest project root discovery by default when a nested .selesai exists", () => withTempHome(() => {
 		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-nearest-root-default-"));
 		tempDirs.push(dir);
 		const nested = path.join(dir, "packages", "app", "src");
@@ -1083,7 +1083,7 @@ Plan outer project work.
 		assert.equal(reviewer?.override?.path, path.join(dir, ".selesai", "settings.json"));
 	}));
 
-	it("keeps git-root discovery stable when a nested linked worktree creates incidental .pi state", () => withTempHome(() => {
+	it("keeps git-root discovery stable when a nested linked worktree creates incidental .selesai state", () => withTempHome(() => {
 		const { repo, worktree } = createNestedLinkedWorktree();
 		const { packageAgentName, packageAgentPath, settingsPath } = writeLinkedWorktreePackage(repo);
 
@@ -2301,4 +2301,4 @@ Inspect project
 			else process.env.USERPROFILE = oldUserProfile;
 		}
 	});
-});
+});

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

@@ -391,7 +391,7 @@ Advise only.
 		assert.match(readText(result), /Agent 'foo' has invalid configuration: Agent 'foo' package is invalid after sanitization/);
 	});
 
-	it("blocks a malformed .pi agent from falling back to a legacy project agent", () => {
+	it("blocks a malformed .selesai agent from falling back to a legacy project agent", () => {
 		const canonicalAgentsDir = path.join(tempDir, ".selesai", "agents");
 		const legacyAgentsDir = path.join(tempDir, ".agents");
 		fs.mkdirSync(canonicalAgentsDir, { recursive: true });
@@ -1048,7 +1048,7 @@ Drive the failing test first.
 		const result = handleManagementAction("models", {}, ctx);
 		const text = readText(result);
 		assert.equal(result.isError, false);
-		assert.match(text, /^Builtin subagent models/m);
+		assert.match(text, /^Subagent models/m);
 		assert.match(text, /Current session model:\n  openai\/gpt-5-mini/);
 		assert.match(text, /(?:^|\n)scout\n  model:\n    openai\/gpt-5-mini\n  source: inherits current session model(?:\n|$)/);
 		assert.match(text, /(?:^|\n)advisor\n  model:\n    openai\/gpt-5-mini\n  source: inherits current session model(?:\n|$)/);
@@ -1071,6 +1071,66 @@ Drive the failing test first.
 		assert.doesNotMatch(text, /Builtin agent 'advisor' not found|source: missing/);
 	});
 
+	it("reports effective model mappings for discovered package, user, and project agents", () => {
+		const projectAgentsDir = path.join(tempDir, ".selesai", "agents");
+		const userAgentsDir = path.join(tempDir, "agent-home", "agents");
+		const packageDir = path.join(tempDir, ".selesai", "npm", "node_modules", "model-agents");
+		fs.mkdirSync(projectAgentsDir, { recursive: true });
+		fs.mkdirSync(userAgentsDir, { recursive: true });
+		fs.mkdirSync(path.join(packageDir, "agents"), { recursive: true });
+		fs.writeFileSync(path.join(packageDir, "package.json"), JSON.stringify({
+			name: "model-agents",
+			version: "1.2.3",
+			pi: { subagents: { agents: ["agents"] } },
+		}));
+		const writeAgent = (dir: string, name: string, model: string, thinking: string, fallback: string) => fs.writeFileSync(path.join(dir, `${name}.md`), [
+			"---",
+			`name: ${name}`,
+			`description: ${name} model mapping`,
+			`model: ${model}`,
+			`thinking: ${thinking}`,
+			`fallbackModels: ${fallback}`,
+			"---",
+			"Model mapping test agent.",
+		].join("\n"));
+		writeAgent(path.join(packageDir, "agents"), "package-worker", "anthropic/claude-sonnet-4", "low", "openai/gpt-5-mini");
+		writeAgent(userAgentsDir, "user-worker", "gpt-5-mini", "medium", "claude-sonnet-4");
+		writeAgent(userAgentsDir, "shadowed", "openai/gpt-5-mini", "low", "anthropic/claude-sonnet-4");
+		writeAgent(projectAgentsDir, "project-worker", "anthropic/claude-sonnet-4", "high", "openai/gpt-5-mini");
+		writeAgent(projectAgentsDir, "shadowed", "openai/gpt-5-mini", "high", "anthropic/claude-sonnet-4");
+		fs.writeFileSync(path.join(projectAgentsDir, "off-worker.md"), [
+			"---",
+			"name: off-worker",
+			"description: off-worker model mapping",
+			"model: openai/gpt-5-mini",
+			"thinking: false",
+			"---",
+			"Explicitly disable thinking.",
+		].join("\n"));
+		const settingsPath = path.join(tempDir, ".selesai", "settings.json");
+		fs.writeFileSync(settingsPath, JSON.stringify({ subagents: { agentOverrides: { reviewer: { disabled: true } } } }));
+
+		const ctx = {
+			cwd: tempDir,
+			modelRegistry: { getAvailable: () => [
+				{ provider: "openai", id: "gpt-5-mini" },
+				{ provider: "anthropic", id: "claude-sonnet-4" },
+			] },
+			model: { provider: "openai", id: "gpt-5-mini" },
+		};
+		const result = handleManagementAction("models", {}, ctx);
+		const text = readText(result);
+		assert.equal(result.isError, false);
+		assert.match(text, /package-worker\n  model:\n    anthropic\/claude-sonnet-4\n  source: package agent config\n  thinking: low\n  fallback models:\n    openai\/gpt-5-mini/);
+		assert.match(text, /user-worker\n  model:\n    openai\/gpt-5-mini\n  source: user agent config\n  thinking: medium/);
+		assert.match(text, /project-worker\n  model:\n    anthropic\/claude-sonnet-4\n  source: project agent config\n  thinking: high/);
+		assert.match(text, /off-worker\n  model:\n    openai\/gpt-5-mini\n  source: project agent config\n  thinking: off/);
+		assert.match(text, /shadowed\n  model:\n    openai\/gpt-5-mini\n  source: project agent config/);
+		assert.doesNotMatch(text, /shadowed\n  model:\n    openai\/gpt-5-mini\n  source: user agent config/);
+		assert.match(text, /reviewer\n  model:\n    openai\/gpt-5-mini\n  source: inherits current session model; disabled/);
+		assert.doesNotMatch(text, /api[_-]?key|token|secret/i);
+	});
+
 	it("reports override source and disabled builtin state in runtime model mappings", () => {
 		const projectSettingsPath = path.join(tempDir, ".selesai", "settings.json");
 		fs.mkdirSync(path.dirname(projectSettingsPath), { recursive: true });
@@ -1096,7 +1156,7 @@ Drive the failing test first.
 		const result = handleManagementAction("models", { agent: "reviewer" }, ctx);
 		const text = readText(result);
 		assert.equal(result.isError, false);
-		assert.match(text, /^Builtin subagent model/m);
+		assert.match(text, /^Subagent model/m);
 		assert.match(text, /Agent: reviewer/);
 		assert.match(text, /Effective model:\n  anthropic\/claude-sonnet-4/);
 		assert.match(text, /Source: project override/);
@@ -1105,14 +1165,14 @@ Drive the failing test first.
 		assert.match(text.replaceAll("\\", "/"), /Override file:\n  .*\.selesai[\\/]settings\.json/);
 	});
 
-	it("rejects unknown builtin filters for runtime model mappings", () => {
+	it("rejects unknown agents for runtime model mappings", () => {
 		const result = handleManagementAction("models", { agent: "not-a-builtin" }, {
 			cwd: tempDir,
 			modelRegistry: { getAvailable: () => [] },
 		});
 
 		assert.equal(result.isError, true);
-		assert.match(readText(result), /Builtin agent 'not-a-builtin' not found/);
+		assert.match(readText(result), /Agent 'not-a-builtin' not found/);
 	});
 
 	it("creates delegate with its builtin prompt defaults", () => {
@@ -1181,4 +1241,4 @@ Inspect cleanup.
 		assert.doesNotMatch(readText(listed), /Proactive skill subagent suggestions:/);
 	});
 
-});
+});

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

@@ -58,7 +58,7 @@ function withTempHome<T>(fn: (home: string) => T): T {
 	}
 }
 
-// Create a temp project root that findNearestProjectRoot will recognise (.pi dir present).
+// Create a temp project root that findNearestProjectRoot will recognise (.selesai dir present).
 function mkProject(): string {
 	const dir = mkdtemp("pi-subagents-mem-project-");
 	fs.mkdirSync(path.join(dir, ".selesai", "agents"), { recursive: true });
@@ -417,4 +417,4 @@ Review for threats.
 
 function escapeRegex(value: string): string {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
+}

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

@@ -1150,4 +1150,4 @@ describe("builtin agent overrides", () => {
 		);
 		assert.equal(whitespaceDescription, undefined);
 	});
-});
+});

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

@@ -175,4 +175,4 @@ describe("agent refinements", () => {
 		assert.match(prompt, /confirm it before finishing/);
 		assert.doesNotMatch(prompt, /When acceptance is rejected/);
 	});
-});
+});

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

@@ -17,4 +17,4 @@ describe("resolveExecutionAgentScope", () => {
 		assert.equal(resolveExecutionAgentScope("invalid"), "both");
 		assert.equal(resolveExecutionAgentScope(""), "both");
 	});
-});
+});

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

@@ -85,4 +85,4 @@ describe("mergeAgentsForScope", () => {
 		assert.equal(result.length, 1);
 		assert.equal(result[0]?.source, "project");
 	});
-});
+});

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

@@ -11,4 +11,4 @@ describe("agent stream options", () => {
 		assert.equal(options.streamFunction, streamFn);
 		assert.equal(options.streamFn, streamFn);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/anti-slop-oxlint.test.ts

@@ -19,10 +19,22 @@ function lintFixture(source: string): string {
 			cwd: projectRoot,
 			encoding: "utf8",
 		});
-		assert.equal(result.error, undefined, result.error?.message);
-		assert.ok(result.status !== null, result.stderr);
+		const stdout = String(result.stdout ?? "");
+		const processOutput = [String(result.stderr ?? ""), stdout].filter(Boolean).join("\n").trim() || "(no output)";
+		if (result.error) assert.fail(`Oxlint setup failed to start: ${result.error.message}\n${processOutput}`);
+		if (result.status === null) assert.fail(`Oxlint setup failed before producing a result:\n${processOutput}`);
+
+		let lintResult: unknown;
+		try {
+			lintResult = JSON.parse(stdout);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			assert.fail(`Oxlint setup/configuration failed before producing a JSON lint result: ${message}\n${processOutput}`);
+		}
+		const diagnostics = lintResult !== null && typeof lintResult === "object" && "diagnostics" in lintResult ? lintResult.diagnostics : undefined;
+		assert.ok(Array.isArray(diagnostics), `Oxlint setup/configuration did not produce a JSON lint result with diagnostics:\n${processOutput}`);
 		assert.notEqual(result.status, 0, result.stderr);
-		return result.stdout;
+		return stdout;
 	} finally {
 		fs.rmSync(root, { recursive: true, force: true });
 	}
@@ -83,4 +95,4 @@ export const safeConst = "x" as const;
 			assert.equal(output.includes(safeName), false, `unexpected diagnostic for ${safeName}`);
 		}
 	});
-});
+});

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

@@ -75,4 +75,4 @@ describe("project-local artifact paths", () => {
 		assert.equal(getArtifactsDir(sessionFile, cwd), path.join("tmp", "sessions", "subagent-artifacts"));
 		assert.equal(getArtifactsDir(null, cwd), path.join(TEMP_ARTIFACTS_DIR));
 	});
-});
+});