@selesai/code 0.13.40 → 0.14.3

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

@@ -1,4 +1,5 @@
 import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -70,6 +71,14 @@ function writeMemoryFile(memoryDir: string, contents: string): void {
 	fs.writeFileSync(path.join(memoryDir, AGENT_MEMORY_FILE), contents, "utf-8");
 }
 
+function commitFixture(project: string, trackedFile: string): void {
+	execFileSync("git", ["init", "-q"], { cwd: project });
+	execFileSync("git", ["config", "user.email", "test@example.invalid"], { cwd: project });
+	execFileSync("git", ["config", "user.name", "Test"], { cwd: project });
+	execFileSync("git", ["add", trackedFile], { cwd: project });
+	execFileSync("git", ["commit", "-qm", "fixture"], { cwd: project });
+}
+
 afterEach(() => {
 	while (tempDirs.length > 0) {
 		const dir = tempDirs.pop();
@@ -269,6 +278,122 @@ describe("buildAgentMemoryInjection", () => {
 		assert.match(injection, /You may create it/);
 	});
 
+	it("resolves project memory through a linked worktree when Git trace writes to stderr", () => {
+		const root = mkdtemp("pi-subagents-mem-worktree-");
+		const project = path.join(root, "project");
+		const worktree = path.join(root, "worktree");
+		fs.mkdirSync(path.join(project, ".selesai", "agents"), { recursive: true });
+		fs.writeFileSync(path.join(project, ".selesai", "agents", "probe.md"), "probe\n");
+		commitFixture(project, ".selesai/agents/probe.md");
+		execFileSync("git", ["worktree", "add", "-qb", "probe", worktree], { cwd: project });
+		const expectedFile = path.join(fs.realpathSync.native(project), ".selesai", AGENT_MEMORY_DIR_NAME, "probe", AGENT_MEMORY_FILE);
+		writeMemoryFile(path.dirname(expectedFile), "marker: shared-main-memory\n");
+		const agent = makeAgent({ memory: { scope: "project", path: "probe" }, tools: ["read", "write"] });
+		const previousGitTrace = process.env.GIT_TRACE;
+		process.env.GIT_TRACE = "1";
+		let injection: string;
+		try {
+			injection = buildAgentMemoryInjection(agent, path.join(worktree, ".selesai", "agents"));
+		} finally {
+			if (previousGitTrace === undefined) delete process.env.GIT_TRACE;
+			else process.env.GIT_TRACE = previousGitTrace;
+		}
+		assert.match(injection, /marker: shared-main-memory/);
+		assert.match(injection, new RegExp(`Memory file: ${escapeRegex(expectedFile)}`));
+		assert.doesNotMatch(injection, new RegExp(escapeRegex(path.join(worktree, ".selesai", AGENT_MEMORY_DIR_NAME))));
+
+		const marker = path.join(worktree, ".git");
+		const absoluteGitDir = fs.readFileSync(marker, "utf8").match(/^gitdir:\s*(.+?)\s*$/m)?.[1];
+		assert.ok(absoluteGitDir);
+		const markerFd = fs.openSync(marker, "r+");
+		try {
+			fs.ftruncateSync(markerFd, 0);
+			fs.writeFileSync(markerFd, `gitdir: ${path.relative(fs.realpathSync(worktree), path.resolve(worktree, absoluteGitDir))}\n`);
+		} finally {
+			fs.closeSync(markerFd);
+		}
+		injection = buildAgentMemoryInjection(agent, worktree);
+		assert.match(injection, /marker: shared-main-memory/);
+		assert.match(injection, new RegExp(`Memory file: ${escapeRegex(expectedFile)}`));
+	});
+
+	it("maps nested project memory from a linked worktree to the same main-checkout path", () => {
+		const root = mkdtemp("pi-subagents-mem-nested-worktree-");
+		const project = path.join(root, "project");
+		const worktree = path.join(root, "worktree");
+		const nested = path.join("packages", "app");
+		fs.mkdirSync(path.join(project, nested, ".selesai", "agents"), { recursive: true });
+		fs.writeFileSync(path.join(project, nested, ".selesai", "agents", "probe.md"), "probe\n");
+		commitFixture(project, `${nested}/.selesai/agents/probe.md`);
+		execFileSync("git", ["worktree", "add", "-qb", "nested", worktree], { cwd: project });
+		const expectedFile = path.join(fs.realpathSync.native(project), nested, ".selesai", AGENT_MEMORY_DIR_NAME, "probe", AGENT_MEMORY_FILE);
+		writeMemoryFile(path.dirname(expectedFile), "marker: nested-main-memory\n");
+		const agent = makeAgent({ memory: { scope: "project", path: "probe" }, tools: ["read", "write"] });
+		const injection = buildAgentMemoryInjection(agent, path.join(worktree, nested));
+		assert.match(injection, /marker: nested-main-memory/);
+		assert.match(injection, new RegExp(`Memory file: ${escapeRegex(expectedFile)}`));
+	});
+
+	it("rejects a forged marker pointing at another repository's valid worktree metadata", () => {
+		const project = mkProject();
+		const other = path.join(mkdtemp("pi-subagents-mem-other-repo-"), "project");
+		const otherWorktree = path.join(path.dirname(other), "worktree");
+		fs.mkdirSync(other, { recursive: true });
+		fs.writeFileSync(path.join(other, "tracked.txt"), "fixture\n");
+		commitFixture(other, "tracked.txt");
+		execFileSync("git", ["worktree", "add", "-qb", "other", otherWorktree], { cwd: other });
+		const otherGitDir = fs.readFileSync(path.join(otherWorktree, ".git"), "utf8").match(/^gitdir:\s*(.+?)\s*$/m)?.[1];
+		assert.ok(otherGitDir);
+		fs.writeFileSync(path.join(project, ".git"), `gitdir: ${otherGitDir}\n`);
+		writeMemoryFile(path.join(project, ".selesai", AGENT_MEMORY_DIR_NAME, "probe"), "marker: checkout-local\n");
+		writeMemoryFile(path.join(other, ".selesai", AGENT_MEMORY_DIR_NAME, "probe"), "marker: other-repository\n");
+		const injection = buildAgentMemoryInjection(makeAgent({ memory: { scope: "project", path: "probe" }, tools: ["read"] }), project);
+		assert.match(injection, /marker: checkout-local/);
+		assert.doesNotMatch(injection, /marker: other-repository/);
+	});
+
+	it("rejects self-consistent forged worktree metadata that Git does not recognize", () => {
+		const project = mkProject();
+		const fakeMain = mkdtemp("pi-subagents-mem-forged-main-");
+		const fakeWorktreeGitDir = path.join(fakeMain, ".git", "worktrees", "forged");
+		fs.mkdirSync(fakeWorktreeGitDir, { recursive: true });
+		fs.writeFileSync(path.join(project, ".git"), `gitdir: ${fakeWorktreeGitDir}\n`);
+		fs.writeFileSync(path.join(fakeWorktreeGitDir, "gitdir"), `${path.join(project, ".git")}\n`);
+		writeMemoryFile(path.join(project, ".selesai", AGENT_MEMORY_DIR_NAME, "probe"), "marker: checkout-local\n");
+		writeMemoryFile(path.join(fakeMain, ".selesai", AGENT_MEMORY_DIR_NAME, "probe"), "marker: forged-main\n");
+		const injection = buildAgentMemoryInjection(makeAgent({ memory: { scope: "project", path: "probe" }, tools: ["read"] }), project);
+		assert.match(injection, /marker: checkout-local/);
+		assert.doesNotMatch(injection, /marker: forged-main/);
+	});
+
+	it("uses the Git root when a linked worktree has no local project config directory", () => {
+		const root = mkdtemp("pi-subagents-mem-unconfigured-worktree-");
+		const project = path.join(root, "project");
+		const worktree = path.join(root, "worktree");
+		fs.mkdirSync(project, { recursive: true });
+		fs.writeFileSync(path.join(project, "tracked.txt"), "fixture\n");
+		commitFixture(project, "tracked.txt");
+		execFileSync("git", ["worktree", "add", "-qb", "probe", worktree], { cwd: project });
+		writeMemoryFile(path.join(project, ".selesai", AGENT_MEMORY_DIR_NAME, "probe"), "marker: git-root-memory\n");
+		const agent = makeAgent({ memory: { scope: "project", path: "probe" }, tools: ["read"] });
+		assert.equal(findNearestProjectRoot(worktree), null);
+		assert.match(buildAgentMemoryInjection(agent, worktree), /marker: git-root-memory/);
+	});
+
+	it("keeps project memory checkout-local for unsupported separate Git directories", () => {
+		const root = mkdtemp("pi-subagents-mem-separate-git-dir-");
+		const project = path.join(root, "project");
+		const gitDir = path.join(root, "metadata");
+		fs.mkdirSync(path.join(project, ".selesai", "agents"), { recursive: true });
+		execFileSync("git", ["init", "-q", `--separate-git-dir=${gitDir}`, project]);
+		writeMemoryFile(path.join(project, ".selesai", AGENT_MEMORY_DIR_NAME, "probe"), "marker: checkout-local\n");
+		writeMemoryFile(path.join(root, ".selesai", AGENT_MEMORY_DIR_NAME, "probe"), "marker: unsupported-remap\n");
+		const injection = buildAgentMemoryInjection(makeAgent({ memory: { scope: "project", path: "probe" }, tools: ["read"] }), project);
+		assert.match(injection, /marker: checkout-local/);
+		assert.doesNotMatch(injection, /marker: unsupported-remap/);
+		assert.match(injection, new RegExp(`Memory file: ${escapeRegex(path.join(project, ".selesai", AGENT_MEMORY_DIR_NAME, "probe", AGENT_MEMORY_FILE))}`));
+	});
+
 	it("injects a read-only block for agents without write tools", () => {
 		const project = mkProject();
 		const memoryDir = path.join(project, ".selesai", AGENT_MEMORY_DIR_NAME, "scout");
@@ -417,4 +542,4 @@ Review for threats.
 
 function escapeRegex(value: string): string {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
+}

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

@@ -0,0 +1,75 @@
+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 { findConfiguredProjectRoot, resolveAgentName, type AgentConfig } from "../../src/agents/agents.ts";
+
+function makeAgent(name: string, localName?: string): AgentConfig {
+	return {
+		name,
+		localName,
+		description: `${name} agent`,
+		systemPromptMode: "replace",
+		inheritProjectContext: false,
+		inheritSkills: false,
+		systemPrompt: "Inspect",
+		source: "project",
+		filePath: path.join(".selesai", "agents", `${name}.md`),
+	};
+}
+
+describe("resolveAgentName", () => {
+	it("prefers an exact canonical name over a packaged local name", () => {
+		const plain = makeAgent("scout");
+		const packaged = makeAgent("code-analysis.scout", "scout");
+
+		assert.equal(resolveAgentName("scout", [plain, packaged]).agent, plain);
+		assert.equal(resolveAgentName("code-analysis.scout", [plain, packaged]).agent, packaged);
+	});
+
+	it("uses a unique packaged local name when no canonical name exists", () => {
+		const packaged = makeAgent("code-analysis.scout", "scout");
+
+		assert.equal(resolveAgentName("scout", [packaged]).agent, packaged);
+	});
+
+	it("rejects a local name shared by multiple packaged agents", () => {
+		const result = resolveAgentName("scout", [
+			makeAgent("code-analysis.scout", "scout"),
+			makeAgent("repository.scout", "scout"),
+		]);
+
+		assert.match(result.error ?? "", /Ambiguous local agent name 'scout': code-analysis\.scout, repository\.scout/);
+	});
+});
+
+describe("findConfiguredProjectRoot", () => {
+	it("does not reinterpret user config reached through a home alias as project config", () => {
+		const previousHome = process.env.HOME;
+		const previousUserProfile = process.env.USERPROFILE;
+		const isolatedRoot = fs.mkdtempSync(path.join(os.tmpdir(), "agent-home-"));
+		const isolatedHome = path.join(isolatedRoot, "home");
+		const homeAlias = path.join(isolatedRoot, "home-alias");
+
+		try {
+			fs.mkdirSync(isolatedHome);
+			fs.symlinkSync(isolatedHome, homeAlias, process.platform === "win32" ? "junction" : "dir");
+			process.env.HOME = isolatedHome;
+			process.env.USERPROFILE = isolatedHome;
+			const nested = fs.mkdtempSync(path.join(homeAlias, "agent-project-"));
+			fs.mkdirSync(path.join(isolatedHome, ".selesai"));
+
+			assert.equal(findConfiguredProjectRoot(nested), null);
+
+			fs.mkdirSync(path.join(nested, ".selesai"));
+			assert.equal(findConfiguredProjectRoot(nested), nested);
+		} finally {
+			if (previousHome === undefined) delete process.env.HOME;
+			else process.env.HOME = previousHome;
+			if (previousUserProfile === undefined) delete process.env.USERPROFILE;
+			else process.env.USERPROFILE = previousUserProfile;
+			fs.rmSync(isolatedRoot, { recursive: true, force: true });
+		}
+	});
+});

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

@@ -57,7 +57,7 @@ describe("builtin agent overrides", () => {
 		assert.ok(builtins.length > 0);
 		assert.deepEqual(
 			builtins
-				.filter((agent) => agent.model !== undefined || agent.fallbackModels !== undefined)
+				.filter((agent) => agent.model !== undefined)
 				.map((agent) => agent.name),
 			[],
 		);
@@ -88,6 +88,64 @@ describe("builtin agent overrides", () => {
 		assert.equal(reviewer?.modelSource, undefined);
 	});
 
+	it("applies machine placement overrides with project beating user and false clearing a pin", () => {
+		// Selesai: bundled builtins stand in for the unbundled external-CLI adapter agents.
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: { agentOverrides: { "scout": { machine: "workmac" }, "oracle": { machine: "workmac" }, "researcher": { machine: "workmac" } } },
+		});
+		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
+			subagents: { agentOverrides: { "oracle": { machine: "gpu-box" }, "researcher": { machine: false } } },
+		});
+
+		const builtins = discoverAgentsAll(tempProject).builtin;
+		assert.equal(builtins.find((agent) => agent.name === "scout")?.machine, "workmac");
+		assert.equal(builtins.find((agent) => agent.name === "oracle")?.machine, "gpu-box");
+		assert.equal(builtins.find((agent) => agent.name === "researcher")?.machine, undefined);
+		assert.deepEqual(builtins.find((agent) => agent.name === "researcher")?.override?.fields, ["machine"]);
+
+		// The disable/reset rewrite keeps a placement: the override is rebuilt from the agent's current fields.
+		const scout = builtins.find((agent) => agent.name === "scout")!;
+		assert.deepEqual(buildBuiltinOverrideConfig({ ...scout.override!.base }, { ...scout }), { machine: "workmac" });
+		assert.deepEqual(buildBuiltinOverrideConfig({ ...scout.override!.base, machine: "pinned" }, { ...scout, machine: undefined }), { machine: false });
+	});
+
+	it("rejects malformed machine overrides", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), { subagents: { agentOverrides: { "claude-code": { machine: 7 } } } });
+		assert.throws(() => discoverAgentsAll(tempProject), /field 'machine' must be a non-empty string or false/u);
+	});
+
+	it("replaces and clears custom-agent allowedAgents while preserving explicit deny-all", () => {
+		writeProjectAgent(tempProject, "coordinator", "---\nname: coordinator\ndescription: Coordinator\nallowedAgents: scout\n---\n\nCoordinate.\n");
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: { agentOverrides: { coordinator: { allowedAgents: false } } },
+		});
+		assert.equal(discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "coordinator")?.allowedAgents, undefined);
+
+		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
+			subagents: { agentOverrides: { coordinator: { allowedAgents: [] } } },
+		});
+		assert.deepEqual(discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "coordinator")?.allowedAgents, []);
+
+		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
+			subagents: { agentOverrides: { coordinator: { allowedAgents: ["worker", "reviewer"] } } },
+		});
+		assert.deepEqual(discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "coordinator")?.allowedAgents, ["reviewer", "worker"]);
+	});
+
+	it("rejects removed fallbackModels in user agent overrides", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: { agentOverrides: { worker: { fallbackModels: ["model/backup"] } } },
+		});
+		assert.throws(() => discoverAgentsAll(tempProject), /removed field 'fallbackModels'; configure one model instead/u);
+	});
+
+	it("rejects removed fallbackModels in project agent overrides", () => {
+		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
+			subagents: { agentOverrides: { worker: { fallbackModels: ["model/backup"] } } },
+		});
+		assert.throws(() => discoverAgentsAll(tempProject), /removed field 'fallbackModels'; configure one model instead/u);
+	});
+
 	it("lets a builtin agent inherit Pi's normal tools from an override", () => {
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
 			subagents: {
@@ -113,7 +171,9 @@ describe("builtin agent overrides", () => {
 
 		const builtins = discoverAgentsAll(tempProject).builtin;
 		assert.equal(builtins.find((agent) => agent.name === "researcher")?.tools, undefined);
-		assert.deepEqual(builtins.find((agent) => agent.name === "reviewer")?.tools, ["read", "grep", "find", "ls", "contact_supervisor"]);
+		assert.deepEqual(builtins.find((agent) => agent.name === "reviewer")?.tools, ["read", "grep", "find", "ls", "watchdog_diff", "contact_supervisor"]);
+		assert.deepEqual(builtins.find((agent) => agent.name === "worker")?.tools, ["read", "grep", "find", "ls", "bash", "edit", "write", "contact_supervisor"]);
+		assert.deepEqual(builtins.find((agent) => agent.name === "scout")?.tools, ["read", "grep", "find", "ls", "bash", "write", "contact_supervisor"]);
 	});
 
 	it("keeps explicit empty builtin tool allowlists distinct from inherited tools", () => {
@@ -344,6 +404,26 @@ describe("builtin agent overrides", () => {
 		assert.equal(agents.find((agent) => agent.name === "implementer")?.description, "Priced implementer");
 	});
 
+	it("lets a project advertise override beat a user one and clear it again", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: { agentOverrides: { oracle: { advertise: true }, reviewer: { advertise: true } } },
+		});
+		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
+			subagents: { agentOverrides: { oracle: { advertise: false } } },
+		});
+
+		const agents = discoverAgents(tempProject, "both").agents;
+		assert.equal(agents.find((agent) => agent.name === "oracle")?.advertise, false);
+		assert.equal(agents.find((agent) => agent.name === "reviewer")?.advertise, true);
+	});
+
+	it("rejects malformed advertise override values", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: { agentOverrides: { reviewer: { advertise: "yes" } } },
+		});
+		assert.throws(() => discoverAgentsAll(tempProject), /invalid 'advertise'; expected a boolean/u);
+	});
+
 	it("applies user settings overrides to builtin agents", () => {
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
 			subagents: {
@@ -359,7 +439,6 @@ describe("builtin agent overrides", () => {
 						acceptanceRole: "writer",
 						subagentOnlyExtensions: ["./tools/child-review.ts"],
 						mutationTools: ["replace", "undo_last_replace"],
-						completionGuard: false,
 					},
 				},
 			},
@@ -378,7 +457,6 @@ describe("builtin agent overrides", () => {
 		assert.equal(reviewer.acceptanceRole, "writer");
 		assert.deepEqual(reviewer.subagentOnlyExtensions, ["./tools/child-review.ts"]);
 		assert.deepEqual(reviewer.mutationTools, ["replace", "undo_last_replace"]);
-		assert.equal(reviewer.completionGuard, false);
 		assert.equal(reviewer.override?.scope, "user");
 		assert.equal(reviewer.override?.path, path.join(tempHome, ".selesai", "agent", "settings.json"));
 	});
@@ -568,19 +646,18 @@ describe("builtin agent overrides", () => {
 
 	it("layers a project override on top of a user override for a custom agent instead of discarding it", () => {
 		// Regression test: a custom agent (e.g. a reviewer persona shipped as a .md
-		// file with no model/thinking/fallbackModels in frontmatter) that gets its
+		// file with no model/thinking in frontmatter) that gets its
 		// model pin exclusively from a *user*-scope agentOverrides entry must keep
 		// that pin when a *project*-scope override adds an unrelated field (here:
 		// subagentOnlyExtensions). Previously the project override for this agent
 		// name replaced the user override wholesale, silently dropping model /
-		// thinking / fallbackModels with no error.
+		// thinking with no error.
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
 			subagents: {
 				agentOverrides: {
 					"persona-reviewer": {
 						model: "anthropic/claude-opus-4-8",
 						thinking: "high",
-						fallbackModels: ["anthropic/claude-sonnet-4-6"],
 					},
 				},
 			},
@@ -601,7 +678,6 @@ describe("builtin agent overrides", () => {
 		assert.ok(reviewer);
 		assert.equal(reviewer.model, "anthropic/claude-opus-4-8");
 		assert.equal(reviewer.thinking, "high");
-		assert.deepEqual(reviewer.fallbackModels, ["anthropic/claude-sonnet-4-6"]);
 		assert.deepEqual(reviewer.subagentOnlyExtensions, ["./tools/child-only.ts"]);
 		assert.equal(reviewer.override?.scope, "project");
 	});
@@ -740,7 +816,6 @@ describe("builtin agent overrides", () => {
 						outputMode: "file-only",
 						defaultReads: ["CONTEXT.md", "docs/spec.md"],
 						model: "anthropic/claude-sonnet-4-6",
-						fallbackModels: ["openai/gpt-5-mini"],
 						fast: true,
 						thinking: "high",
 						systemPromptMode: "append",
@@ -751,7 +826,6 @@ describe("builtin agent overrides", () => {
 						tools: ["bash", "mcp:xcodebuild_list_sims"],
 						skills: ["tdd"],
 						subagentOnlyExtensions: ["./tools/child-review.ts"],
-						completionGuard: false,
 					},
 				},
 			},
@@ -765,7 +839,6 @@ describe("builtin agent overrides", () => {
 		assert.equal(implementer.outputMode, "file-only");
 		assert.deepEqual(implementer.defaultReads, ["CONTEXT.md", "docs/spec.md"]);
 		assert.equal(implementer.model, "anthropic/claude-sonnet-4-6");
-		assert.deepEqual(implementer.fallbackModels, ["openai/gpt-5-mini"]);
 		assert.equal(implementer.fast, true);
 		assert.equal(implementer.thinking, "high");
 		assert.equal(implementer.systemPromptMode, "append");
@@ -777,7 +850,6 @@ describe("builtin agent overrides", () => {
 		assert.deepEqual(implementer.mcpDirectTools, ["xcodebuild_list_sims"]);
 		assert.deepEqual(implementer.skills, ["tdd"]);
 		assert.deepEqual(implementer.subagentOnlyExtensions, ["./tools/child-review.ts"]);
-		assert.equal(implementer.completionGuard, false);
 		assert.equal(implementer.override?.scope, "project");
 		assert.equal(implementer.override?.path, path.join(tempProject, ".selesai", "settings.json"));
 	});
@@ -844,12 +916,11 @@ describe("builtin agent overrides", () => {
 						defaultContext: "fork",
 						acceptanceRole: "writer",
 						systemPrompt: "Override prompt",
-						completionGuard: true,
 					},
 				},
 			},
 		});
-		writeProjectAgent(tempProject, "implementer", `---\nname: implementer\ndescription: TDD implementer\noutput: artifacts/explicit.md\noutputMode: inline\ndefaultReads: explicit.md\nmodel: google/gemini-3-pro\nfast: false\nthinking: medium\ntools: read, mcp:local_tool\nskills: agent-skill\ninheritProjectContext: false\ndefaultContext: fresh\nacceptanceRole: read-only\ncompletionGuard: false\n---\n\nDrive the failing test first.\n`);
+		writeProjectAgent(tempProject, "implementer", `---\nname: implementer\ndescription: TDD implementer\noutput: artifacts/explicit.md\noutputMode: inline\ndefaultReads: explicit.md\nmodel: google/gemini-3-pro\nfast: false\nthinking: medium\ntools: read, mcp:local_tool\nskills: agent-skill\ninheritProjectContext: false\ndefaultContext: fresh\nacceptanceRole: read-only\n---\n\nDrive the failing test first.\n`);
 
 		const implementer = discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "implementer");
 		assert.ok(implementer);
@@ -866,7 +937,6 @@ describe("builtin agent overrides", () => {
 		assert.equal(implementer.defaultContext, "fork");
 		assert.equal(implementer.acceptanceRole, "writer");
 		assert.equal(implementer.systemPrompt, "Override prompt");
-		assert.equal(implementer.completionGuard, true);
 		assert.equal(implementer.override?.scope, "project");
 	});
 
@@ -922,6 +992,15 @@ describe("builtin agent overrides", () => {
 		assert.equal(fs.existsSync(settingsPath), false);
 	});
 
+	it("does not preserve empty or whitespace machine values when clearing other override fields", () => {
+		const settingsPath = path.join(tempHome, ".selesai", "agent", "settings.json");
+		for (const machine of ["", " \t "]) {
+			writeJson(settingsPath, { subagents: { agentOverrides: { reviewer: { machine, model: "openai/gpt-5.4" } } } });
+			removeBuiltinAgentOverride(tempProject, "reviewer", "user", { preserveMachine: true });
+			assert.equal((JSON.parse(fs.readFileSync(settingsPath, "utf-8")) as { subagents?: unknown }).subagents, undefined);
+		}
+	});
+
 	it("surfaces malformed settings files instead of silently ignoring them", () => {
 		const settingsPath = path.join(tempHome, ".selesai", "agent", "settings.json");
 		fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
@@ -1005,27 +1084,6 @@ describe("builtin agent overrides", () => {
 		}
 	});
 
-	it("surfaces malformed completion guard override values", () => {
-		const settingsPath = path.join(tempHome, ".selesai", "agent", "settings.json");
-		writeJson(settingsPath, {
-			subagents: {
-				agentOverrides: {
-					reviewer: {
-						completionGuard: "false",
-					},
-				},
-			},
-		});
-
-		assert.throws(
-			() => discoverAgents(tempProject, "both"),
-			(error: unknown) => error instanceof Error
-				&& error.message.includes(settingsPath)
-				&& error.message.includes("reviewer")
-				&& error.message.includes("completionGuard"),
-		);
-	});
-
 	it("rejects unsupported outputMode override values", () => {
 		const settingsPath = path.join(tempHome, ".selesai", "agent", "settings.json");
 		for (const outputMode of ["artifact-only", false]) {
@@ -1092,7 +1150,6 @@ describe("builtin agent overrides", () => {
 				output: "base-output.md",
 				defaultReads: ["base-read.md"],
 				model: "openai-codex/gpt-5.4-mini",
-				fallbackModels: ["openai/gpt-5-mini"],
 				thinking: "high",
 				systemPromptMode: "append",
 				inheritProjectContext: true,
@@ -1105,14 +1162,12 @@ describe("builtin agent overrides", () => {
 				tools: ["bash"],
 				mcpDirectTools: ["xcodebuild_list_sims"],
 				subagentOnlyExtensions: ["./tools/base-child.ts"],
-				completionGuard: false,
 			},
 			{
 				description: "Override description",
 				output: undefined,
 				defaultReads: undefined,
 				model: undefined,
-				fallbackModels: undefined,
 				thinking: undefined,
 				systemPromptMode: "replace",
 				inheritProjectContext: false,
@@ -1125,7 +1180,6 @@ describe("builtin agent overrides", () => {
 				tools: undefined,
 				mcpDirectTools: undefined,
 				subagentOnlyExtensions: undefined,
-				completionGuard: true,
 			},
 		);
 
@@ -1134,7 +1188,6 @@ describe("builtin agent overrides", () => {
 			output: false,
 			defaultReads: false,
 			model: false,
-			fallbackModels: false,
 			thinking: false,
 			systemPromptMode: "replace",
 			inheritProjectContext: false,
@@ -1144,7 +1197,6 @@ describe("builtin agent overrides", () => {
 			skills: false,
 			tools: false,
 			subagentOnlyExtensions: false,
-			completionGuard: true,
 		});
 		assert.ok(override);
 		fs.mkdirSync(path.join(tempProject, ".selesai"), { recursive: true });

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

@@ -4,9 +4,10 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
 import type { ExtensionAPI } from "@selesai/code";
-import { buildAsyncRunnerSteps, DEFAULT_ASYNC_TIMEOUT_MS, emitProcessTerminalEvent, formatAsyncStartedMessage, resolveAsyncRunnerLogPaths } from "../../src/runs/background/async-execution.ts";
+import { buildAsyncRunnerSteps, assertClaudeCodeOverrideIsLocal, DEFAULT_ASYNC_TIMEOUT_MS, emitProcessTerminalEvent, formatAsyncStartedMessage, resolveAsyncRunnerLogPaths } from "../../src/runs/background/async-execution.ts";
 import type { AgentConfig } from "../../src/agents/agents.ts";
 import { SUBAGENT_PROCESS_TERMINAL_EVENT } from "../../src/shared/types.ts";
+import { registerRequiredChildExtensions } from "../../src/api/required-child-extensions.ts";
 
 const agent = (name: string, toolBudget?: AgentConfig["toolBudget"]): AgentConfig => ({
 	name,
@@ -29,6 +30,42 @@ const ctx = {
 };
 
 describe("async runner execution", () => {
+	it("propagates static parallel machine placement before agent pins and rejects group worktrees", { skip: process.platform === "win32" ? "Herdr saved-machine launches are unsupported on Windows" : undefined }, (t) => {
+		const bin = fs.mkdtempSync(path.join(os.tmpdir(), "herdr-bin-"));
+		const herdr = path.join(bin, "herdr");
+		fs.writeFileSync(herdr, "#!/bin/sh\necho '[{\"id\":\"machine-1\",\"label\":\"workmac\",\"target\":\"host.example\",\"enabled\":true}]'\n", "utf-8");
+		fs.chmodSync(herdr, 0o755);
+		const previousHerdrBin = process.env.HERDR_BIN;
+		process.env.HERDR_BIN = herdr;
+		t.after(() => {
+			if (previousHerdrBin === undefined) delete process.env.HERDR_BIN;
+			else process.env.HERDR_BIN = previousHerdrBin;
+			fs.rmSync(bin, { recursive: true, force: true });
+		});
+		const external = { ...agent("external"), machine: "agent-pin", runner: { type: "external-cli" as const, adapter: "codex-exec" as const, command: "codex" } };
+		const built = buildAsyncRunnerSteps("parallel-machine", {
+			chain: [{ machine: "workmac", parallel: [{ agent: "external", task: "Review", cwd: "/remote/repo" }] }],
+			agents: [external],
+			ctx,
+			asyncDir: path.join(process.cwd(), ".tmp-parallel-machine"),
+			maxSubagentDepth: 1,
+		});
+		assert.ok("steps" in built);
+		const parallel = built.steps[0];
+		assert.ok(parallel && "parallel" in parallel && Array.isArray(parallel.parallel));
+		assert.equal(parallel.parallel[0]?.machine?.label, "workmac");
+
+		const rejected = buildAsyncRunnerSteps("parallel-machine-worktree", {
+			chain: [{ machine: "workmac", worktree: true, parallel: [{ agent: "external", task: "Review" }] }],
+			agents: [external],
+			ctx,
+			asyncDir: path.join(process.cwd(), ".tmp-parallel-machine-worktree"),
+			maxSubagentDepth: 1,
+		});
+		assert.ok("error" in rejected);
+		assert.match(rejected.error, /managed worktrees are local git operations/u);
+	});
+
 	it("uses supplied discovery context for missing async agents", () => {
 		const result = buildAsyncRunnerSteps("missing-agent", {
 			chain: [{ agent: "missing", task: "Do not launch" }],
@@ -202,9 +239,11 @@ describe("async runner execution", () => {
 		assert.deepEqual(result.steps[0]?.toolBudget, { hard: 4, block: ["read"] });
 	});
 
-	it("attaches external runner config and rejects unsupported Pi-only overrides", () => {
+	it("attaches external runner config and rejects unsupported Pi-only overrides", (t) => {
 		const external = agent("external");
 		external.runner = { type: "external-cli", command: process.execPath, args: ["fake.mjs"] };
+		const registration = registerRequiredChildExtensions({ sessionId: ctx.currentSessionId, extensions: [{ id: "native-only", path: import.meta.filename }] });
+		t.after(registration.dispose);
 		const built = buildAsyncRunnerSteps("external-run", {
 			chain: [{ agent: "external", task: "review" }],
 			agents: [external],
@@ -215,6 +254,7 @@ describe("async runner execution", () => {
 		assert.ok("steps" in built);
 		assert.deepEqual(built.steps[0]?.runner, external.runner);
 		assert.equal(built.steps[0]?.model, undefined);
+		assert.equal(built.steps[0]?.requiredExtensions, undefined);
 
 		const rejected = buildAsyncRunnerSteps("external-rejected", {
 			chain: [{ agent: "external", task: "review", model: "provider/model" }],
@@ -226,6 +266,36 @@ describe("async runner execution", () => {
 		assert.deepEqual(rejected, { error: "Agent 'external' uses runner.type='external-cli' and does not support: model override." });
 	});
 
+	it("rejects an external runner step when the host required extensions are mandatory for all runners", (t) => {
+		const external = agent("external");
+		external.runner = { type: "external-cli", command: process.execPath, args: ["fake.mjs"] };
+		const registration = registerRequiredChildExtensions({ sessionId: ctx.currentSessionId, extensions: [{ id: "host-policy", path: import.meta.filename }], requireForAllRunners: true });
+		t.after(registration.dispose);
+		const rejected = buildAsyncRunnerSteps("external-mandatory", {
+			chain: [{ agent: "external", task: "review" }],
+			agents: [external],
+			ctx,
+			asyncDir: path.join(process.cwd(), ".tmp-external-mandatory"),
+			maxSubagentDepth: 2,
+		});
+		assert.ok("error" in rejected);
+		assert.match(rejected.error, /requires child extensions \(host-policy\) for every runner/u);
+	});
+
+	it("refuses a pinned Claude Code model on a saved machine instead of dropping the flags", () => {
+		assert.throws(
+			() => assertClaudeCodeOverrideIsLocal("cc", "workmac", { args: ["--model", "opus"], model: "opus" }),
+			/Agent 'cc' requested machine 'workmac', but a Claude Code model or thinking level cannot be honored on a saved machine/u,
+		);
+		assert.throws(
+			() => assertClaudeCodeOverrideIsLocal("cc", "workmac", { args: ["--effort", "low"] }),
+			/cannot be honored on a saved machine/u,
+		);
+		// A local launch, or one that pins nothing, is unaffected.
+		assert.doesNotThrow(() => assertClaudeCodeOverrideIsLocal("cc", undefined, { args: ["--model", "opus"], model: "opus" }));
+		assert.doesNotThrow(() => assertClaudeCodeOverrideIsLocal("cc", "workmac", undefined));
+	});
+
 	it("uses config default when no step, run, or agent budget exists", () => {
 		const result = buildAsyncRunnerSteps("run-3", {
 			chain: [{ agent: "worker", task: "config default" }],
@@ -277,4 +347,4 @@ describe("async runner process terminal events", () => {
 
 		assert.ok(logged?.some((arg) => arg instanceof Error && arg.message === "event bus unavailable"));
 	});
-});
+});