@selesai/code 0.3.0 → 0.3.1

package/dist/extensions/pi-subagents/test/integration/fork-context-execution.test.ts

@@ -0,0 +1,1306 @@
+import { describe, it, before, after, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { MockPi } from "../support/helpers.ts";
+import { createEventBus, createMockPi, createTempDir, events, removeTempDir, tryImport } from "../support/helpers.ts";
+import { discoverAgents } from "../../src/agents/agents.ts";
+import { INTERCOM_DETACH_REQUEST_EVENT } from "../../src/shared/types.ts";
+
+interface ExecutorModule {
+	createSubagentExecutor?: (...args: unknown[]) => {
+		execute: (
+			id: string,
+			params: Record<string, unknown>,
+			signal: AbortSignal,
+			onUpdate: ((result: unknown) => void) | undefined,
+			ctx: unknown,
+		) => Promise<{
+			isError?: boolean;
+			content: Array<{ text?: string }>;
+			details?: {
+				context?: "fresh" | "fork";
+				mode?: "single" | "parallel" | "chain";
+				asyncId?: string;
+				results?: Array<{ detached?: boolean; exitCode?: number; skills?: string[] }>;
+			};
+		}>;
+	};
+}
+
+interface AsyncExecutionModule {
+	isAsyncAvailable?: () => boolean;
+}
+
+interface ProgressUpdate {
+	details?: {
+		progress?: Array<{ status?: string; currentTool?: string }>;
+	};
+}
+
+const executorMod = await tryImport<ExecutorModule>("./src/runs/foreground/subagent-executor.ts");
+const asyncExecutionMod = await tryImport<AsyncExecutionModule>("./src/runs/background/async-execution.ts");
+const available = !!executorMod;
+const createSubagentExecutor = executorMod?.createSubagentExecutor;
+const asyncAvailable = asyncExecutionMod?.isAsyncAvailable?.() === true;
+const originalHome = process.env.HOME;
+const originalUserProfile = process.env.USERPROFILE;
+
+interface SessionStubOptions {
+	sessionFile?: string;
+	leafId?: string | null;
+}
+
+interface SessionManagerStub {
+	getSessionId(): string;
+	getSessionFile(): string | undefined;
+	getLeafId(): string | null;
+	openSession(sessionFile: string): { createBranchedSession(leafId: string): string | undefined };
+}
+
+function makeSessionManagerRecorder(options: SessionStubOptions = {}) {
+	const manager: SessionManagerStub = {
+		getSessionId: () => "session-123",
+		getSessionFile: () => options.sessionFile,
+		getLeafId: () => (options.leafId === undefined ? "leaf-current" : options.leafId),
+		openSession: () => ({
+			createBranchedSession: () => "/tmp/child.jsonl",
+		}),
+	};
+	return { manager };
+}
+
+function makeState(cwd: string) {
+	return {
+		baseCwd: cwd,
+		currentSessionId: null,
+		asyncJobs: new Map(),
+		cleanupTimers: new Map(),
+		lastUiContext: null,
+		poller: null,
+		completionSeen: new Map(),
+		watcher: null,
+		watcherRestartTimer: null,
+		resultFileCoalescer: {
+			schedule: () => false,
+			clear: () => {},
+		},
+	};
+}
+
+describe("fork context execution wiring", { skip: !available ? "subagent executor not importable" : undefined }, () => {
+	let tempDir: string;
+	let mockPi: MockPi;
+
+	before(() => {
+		mockPi = createMockPi();
+		mockPi.install();
+	});
+
+	after(() => {
+		mockPi.uninstall();
+	});
+
+	beforeEach(() => {
+		tempDir = createTempDir("pi-subagent-fork-test-");
+		mockPi.reset();
+		mockPi.onCall({ output: "ok" });
+	});
+
+	afterEach(() => {
+		if (originalHome === undefined) delete process.env.HOME;
+		else process.env.HOME = originalHome;
+		if (originalUserProfile === undefined) delete process.env.USERPROFILE;
+		else process.env.USERPROFILE = originalUserProfile;
+		removeTempDir(tempDir);
+	});
+
+	function makeExecutor() {
+		return makeExecutorWithConfig({});
+	}
+
+	function makeExecutorWithConfig(config: Record<string, unknown>) {
+		return makeExecutorWithDiscoverAgents(() => ({
+			agents: [
+				{ name: "echo", description: "Echo test agent" },
+				{ name: "second", description: "Second test agent" },
+			],
+			projectAgentsDir: null,
+		}), config);
+	}
+
+	function makeExecutorWithDiscoverAgents(discoverAgentsImpl: typeof discoverAgents, config: Record<string, unknown> = {}) {
+		let sessionName: string | undefined;
+		const eventsApi = createEventBus();
+		return Object.assign(createSubagentExecutor({
+			pi: {
+				events: eventsApi,
+				getSessionName: () => sessionName,
+				setSessionName: (name: string) => {
+					sessionName = name;
+				},
+				sendMessage: () => {},
+			},
+			state: makeState(tempDir),
+			config,
+			asyncByDefault: false,
+			tempArtifactsDir: tempDir,
+			getSubagentSessionRoot: () => tempDir,
+			expandTilde: (p: string) => p,
+			discoverAgents: discoverAgentsImpl,
+		}), { eventsApi });
+	}
+
+	function readCallArgs(): string[] {
+		const callFile = fs.readdirSync(mockPi.dir)
+			.filter((name) => name.startsWith("call-") && name.endsWith(".json"))
+			.sort()
+			.at(-1);
+		assert.ok(callFile, "expected a recorded mock pi call");
+		return readRecordedArgs(callFile);
+	}
+
+	function readAllCallArgs(): string[][] {
+		return fs.readdirSync(mockPi.dir)
+			.filter((name) => name.startsWith("call-") && name.endsWith(".json"))
+			.sort()
+			.map(readRecordedArgs);
+	}
+
+	function readRecordedArgs(callFile: string): string[] {
+		const payload = JSON.parse(fs.readFileSync(path.join(mockPi.dir, callFile), "utf-8"));
+		assert.equal(typeof payload, "object", "expected recorded args payload");
+		assert.notEqual(payload, null, "expected recorded args payload");
+		assert.ok("args" in payload, "expected recorded args payload");
+		assert.ok(Array.isArray(payload.args), "expected recorded args");
+		return payload.args;
+	}
+
+	function readSessionArgsFromCalls(): string[] {
+		return readAllCallArgs()
+			.map((args) => {
+				const sessionIndex = args.indexOf("--session");
+				if (sessionIndex === -1) return undefined;
+				const sessionFile = args[sessionIndex + 1];
+				assert.ok(sessionFile, "expected a session file after --session");
+				return sessionFile;
+			})
+			.filter((sessionFile): sessionFile is string => Boolean(sessionFile));
+	}
+
+	function readCallArgsForTask(taskText: string): string[] {
+		const args = readAllCallArgs().find((callArgs) => {
+			const prompt = callArgs.at(-1) ?? "";
+			return prompt.startsWith(`Task: ${taskText}\n`)
+				|| prompt.includes(`\n\nTask:\n${taskText}\n`);
+		});
+		assert.ok(args, `expected a recorded mock pi call for task '${taskText}'`);
+		return args;
+	}
+
+	function readSessionArg(args: string[]): string {
+		const sessionIndex = args.indexOf("--session");
+		assert.notEqual(sessionIndex, -1);
+		const sessionFile = args[sessionIndex + 1];
+		assert.ok(sessionFile, "expected a session file after --session");
+		return sessionFile;
+	}
+
+	function makeForkingSessionManagerRecorder(options: { sessionFile: string; leafId: string }) {
+		const openedPaths: string[] = [];
+		const branchedLeafIds: string[] = [];
+		let counter = 0;
+		fs.mkdirSync(path.dirname(options.sessionFile), { recursive: true });
+		fs.writeFileSync(options.sessionFile, '{"type":"session","version":1,"id":"parent","timestamp":"2026-04-16T00:00:00.000Z","cwd":"/tmp"}\n', "utf-8");
+		const manager = {
+			getSessionId: () => "session-123",
+			getSessionFile: () => options.sessionFile,
+			getLeafId: () => options.leafId,
+			openSession: (sessionFile: string) => {
+				openedPaths.push(sessionFile);
+				return {
+					createBranchedSession: (leafId: string) => {
+						branchedLeafIds.push(leafId);
+						counter++;
+						const childSessionFile = path.join(tempDir, `fork-${counter}.jsonl`);
+						fs.writeFileSync(childSessionFile, '{"type":"session","version":1,"id":"child","timestamp":"2026-04-16T00:00:00.000Z","cwd":"/tmp"}\n', "utf-8");
+						return childSessionFile;
+					},
+				};
+			},
+		};
+		return { manager, openedPaths, branchedLeafIds };
+	}
+
+	function writeAgent(projectRoot: string, name: string, model: string): void {
+		const filePath = path.join(projectRoot, ".selesai", "agents", `${name}.md`);
+		fs.mkdirSync(path.dirname(filePath), { recursive: true });
+		fs.writeFileSync(
+			filePath,
+			`---\nname: ${name}\ndescription: ${name} agent\nmodel: ${model}\n---\n\nUse ${model}.\n`,
+			"utf-8",
+		);
+	}
+
+	function writeProjectOverride(projectRoot: string, agentName: string, model: string): void {
+		const settingsPath = path.join(projectRoot, ".selesai", "settings.json");
+		fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+		fs.writeFileSync(
+			settingsPath,
+			JSON.stringify({ subagents: { agentOverrides: { [agentName]: { model } } } }, null, 2),
+			"utf-8",
+		);
+	}
+
+	function writePackageSkill(packageRoot: string, skillName: string): void {
+		const skillDir = path.join(packageRoot, "skills", skillName);
+		fs.mkdirSync(skillDir, { recursive: true });
+		fs.writeFileSync(
+			path.join(packageRoot, "package.json"),
+			JSON.stringify({ name: `${skillName}-pkg`, version: "1.0.0", pi: { skills: [`./skills/${skillName}`] } }, null, 2),
+			"utf-8",
+		);
+		fs.writeFileSync(
+			path.join(skillDir, "SKILL.md"),
+			`---\nname: ${skillName}\ndescription: test skill\n---\nbody\n`,
+			"utf-8",
+		);
+	}
+
+	function makeCtx(sessionManager: SessionManagerStub) {
+		return {
+			cwd: tempDir,
+			hasUI: false,
+			ui: {},
+			modelRegistry: { getAvailable: () => [] },
+			sessionManager,
+		};
+	}
+
+	it("runs a single agent when task is omitted", async () => {
+		const { manager } = makeSessionManagerRecorder();
+		const executor = makeExecutor();
+
+		const result = await executor.execute(
+			"id",
+			{ agent: "echo" },
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		const args = readCallArgs();
+		assert.ok((args.at(-1) ?? "").startsWith("Task: \n\n## Acceptance Contract"));
+	});
+
+	it("does not treat top-level agent as single mode when tasks are present", async () => {
+		const { manager } = makeSessionManagerRecorder();
+		const executor = makeExecutor();
+
+		const result = await executor.execute(
+			"id",
+			{ agent: "echo", tasks: [{ agent: "second", task: "parallel task" }] },
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		const args = readCallArgs();
+		assert.ok((args.at(-1) ?? "").startsWith("Task: parallel task\n\n## Acceptance Contract"));
+	});
+
+	it("uses agent defaultContext fork when launch context is omitted", async () => {
+		const parentSessionFile = path.join(tempDir, "parent.jsonl");
+		const { manager, openedPaths, branchedLeafIds } = makeForkingSessionManagerRecorder({ sessionFile: parentSessionFile, leafId: "leaf-current" });
+		const executor = makeExecutorWithDiscoverAgents(() => ({
+			agents: [
+				{ name: "worker", description: "Worker", defaultContext: "fork" },
+			],
+			projectAgentsDir: null,
+		}));
+
+		const result = await executor.execute(
+			"id",
+			{ agent: "worker", task: "test" },
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.equal(result.details?.context, "fork");
+		assert.deepEqual(openedPaths, [parentSessionFile]);
+		assert.deepEqual(branchedLeafIds, ["leaf-current"]);
+		assert.deepEqual(readSessionArgsFromCalls(), [path.join(tempDir, "fork-1.jsonl")]);
+	});
+
+	it("sanitizes inherited signed thinking and forces child thinking off", async () => {
+		const parentSessionFile = path.join(tempDir, "parent.jsonl");
+		const childSessionFile = path.join(tempDir, "fork-with-thinking.jsonl");
+		fs.writeFileSync(parentSessionFile, '{"type":"session","version":1,"id":"parent","timestamp":"2026-04-16T00:00:00.000Z","cwd":"/tmp"}\n', "utf-8");
+		const manager = {
+			getSessionId: () => "session-123",
+			getSessionFile: () => parentSessionFile,
+			getLeafId: () => "assistant-1",
+			openSession: () => ({
+				createBranchedSession: () => {
+					fs.writeFileSync(childSessionFile, [
+						{ type: "session", version: 1, id: "child", timestamp: "2026-04-16T00:00:00.000Z", cwd: "/tmp", parentSession: parentSessionFile },
+						{ type: "message", id: "user-1", parentId: null, timestamp: "2026-04-16T00:00:01.000Z", message: { role: "user", content: "prompt" } },
+						{ type: "message", id: "assistant-1", parentId: "user-1", timestamp: "2026-04-16T00:00:02.000Z", message: { role: "assistant", provider: "anthropic", api: "anthropic-messages", model: "anthropic/claude-sonnet-4-5", content: [{ type: "thinking", thinking: "private chain", thinkingSignature: "signed" }, { type: "text", text: "answer" }] } },
+					].map((entry) => JSON.stringify(entry)).join("\n") + "\n", "utf-8");
+					return childSessionFile;
+				},
+			}),
+		};
+		const executor = makeExecutorWithDiscoverAgents(() => ({
+			agents: [
+				{ name: "worker", description: "Worker", defaultContext: "fork", model: "anthropic/claude-sonnet-4-5:high", thinking: "high" },
+			],
+			projectAgentsDir: null,
+		}));
+
+		const result = await executor.execute(
+			"id",
+			{ agent: "worker", task: "test" },
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		const args = readCallArgs();
+		assert.equal(args[args.indexOf("--model") + 1], "anthropic/claude-sonnet-4-5:off");
+		const entries = fs.readFileSync(childSessionFile, "utf-8").trim().split("\n").map((line) => JSON.parse(line));
+		assert.deepEqual(entries[2].message.content, [{ type: "text", text: "answer" }]);
+		assert.equal(entries[3].type, "thinking_level_change");
+		assert.equal(entries[3].thinkingLevel, "off");
+	});
+
+	it("forces every foreground fallback attempt off after sanitizing inherited signed thinking", async () => {
+		mockPi.reset();
+		mockPi.onCall({
+			jsonl: [{
+				type: "message_end",
+				message: {
+					role: "assistant",
+					content: [{ type: "text", text: "temporary provider failure" }],
+					model: "openai/gpt-5-mini",
+					errorMessage: "rate limit exceeded",
+					usage: { input: 10, output: 5, cacheRead: 0, cacheWrite: 0, cost: { total: 0.01 } },
+				},
+			}],
+			exitCode: 1,
+		});
+		mockPi.onCall({ output: "Recovered on fallback" });
+		const parentSessionFile = path.join(tempDir, "parent.jsonl");
+		const childSessionFile = path.join(tempDir, "fork-with-thinking.jsonl");
+		fs.writeFileSync(parentSessionFile, '{"type":"session","version":1,"id":"parent","timestamp":"2026-04-16T00:00:00.000Z","cwd":"/tmp"}\n', "utf-8");
+		const manager = {
+			getSessionId: () => "session-123",
+			getSessionFile: () => parentSessionFile,
+			getLeafId: () => "assistant-1",
+			openSession: () => ({
+				createBranchedSession: () => {
+					fs.writeFileSync(childSessionFile, [
+						{ type: "session", version: 1, id: "child", timestamp: "2026-04-16T00:00:00.000Z", cwd: "/tmp", parentSession: parentSessionFile },
+						{ type: "message", id: "assistant-1", parentId: null, timestamp: "2026-04-16T00:00:02.000Z", message: { role: "assistant", provider: "anthropic", api: "anthropic-messages", model: "anthropic/claude-sonnet-4-5", content: [{ type: "thinking", thinking: "private chain", thinkingSignature: "signed" }, { type: "text", text: "answer" }] } },
+					].map((entry) => JSON.stringify(entry)).join("\n") + "\n", "utf-8");
+					return childSessionFile;
+				},
+			}),
+		};
+		const executor = makeExecutorWithDiscoverAgents(() => ({
+			agents: [
+				{ name: "worker", description: "Worker", defaultContext: "fork", model: "openai/gpt-5-mini:high", fallbackModels: ["anthropic/claude-sonnet-4:low"], thinking: "high" },
+			],
+			projectAgentsDir: null,
+		}));
+
+		const result = await executor.execute(
+			"id",
+			{ agent: "worker", task: "test" },
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		const modelArgs = readAllCallArgs().map((args) => args[args.indexOf("--model") + 1]);
+		assert.deepEqual(modelArgs, ["openai/gpt-5-mini:off", "anthropic/claude-sonnet-4:off"]);
+	});
+
+	it("keeps default-fork context on run-path errors", async () => {
+		const parentSessionFile = path.join(tempDir, "parent.jsonl");
+		const { manager } = makeForkingSessionManagerRecorder({ sessionFile: parentSessionFile, leafId: "leaf-current" });
+		const executor = makeExecutorWithDiscoverAgents(() => ({
+			agents: [
+				{ name: "worker", description: "Worker", defaultContext: "fork" },
+			],
+			projectAgentsDir: null,
+		}));
+
+		const ctx = makeCtx(manager);
+		ctx.modelRegistry.getAvailable = () => {
+			throw new Error("model registry unavailable");
+		};
+
+		const result = await executor.execute(
+			"id",
+			{ agent: "worker" },
+			new AbortController().signal,
+			undefined,
+			ctx,
+		);
+
+		assert.equal(result.isError, true);
+		assert.match(result.content[0]?.text ?? "", /model registry unavailable/);
+		assert.equal(result.details?.context, "fork");
+	});
+
+	it("keeps explicit fresh context over agent defaultContext fork", async () => {
+		const parentSessionFile = path.join(tempDir, "parent.jsonl");
+		const { manager, openedPaths, branchedLeafIds } = makeForkingSessionManagerRecorder({ sessionFile: parentSessionFile, leafId: "leaf-current" });
+		const executor = makeExecutorWithDiscoverAgents(() => ({
+			agents: [
+				{ name: "oracle", description: "Oracle", defaultContext: "fork" },
+			],
+			projectAgentsDir: null,
+		}));
+
+		const result = await executor.execute(
+			"id",
+			{ agent: "oracle", task: "test", context: "fresh" },
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.equal(result.details?.context, undefined);
+		assert.deepEqual(openedPaths, []);
+		assert.deepEqual(branchedLeafIds, []);
+		assert.notEqual(readSessionArgsFromCalls()[0], path.join(tempDir, "fork-1.jsonl"));
+	});
+
+	it("uses each agent defaultContext for top-level parallel when launch context is omitted", async () => {
+		const parentSessionFile = path.join(tempDir, "parent.jsonl");
+		const { manager, openedPaths, branchedLeafIds } = makeForkingSessionManagerRecorder({ sessionFile: parentSessionFile, leafId: "leaf-current" });
+		const executor = makeExecutorWithDiscoverAgents(() => ({
+			agents: [
+				{ name: "worker", description: "Worker", defaultContext: "fork" },
+				{ name: "second", description: "Second" },
+			],
+			projectAgentsDir: null,
+		}));
+
+		const result = await executor.execute(
+			"id",
+			{ tasks: [{ agent: "worker", task: "one" }, { agent: "second", task: "two" }] },
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.equal(result.details?.context, "fork");
+		assert.deepEqual(openedPaths, [parentSessionFile]);
+		assert.deepEqual(branchedLeafIds, ["leaf-current"]);
+		const workerArgs = readCallArgsForTask("one");
+		const freshArgs = readCallArgsForTask("two");
+		assert.match(workerArgs.at(-1) ?? "", /delegated subagent running from a fork/);
+		assert.doesNotMatch(freshArgs.at(-1) ?? "", /delegated subagent running from a fork/);
+		assert.equal(readSessionArg(workerArgs), path.join(tempDir, "fork-1.jsonl"));
+		assert.notEqual(readSessionArg(freshArgs), path.join(tempDir, "fork-1.jsonl"));
+	});
+
+	it("keeps explicit fresh context over top-level parallel agent defaultContext fork", async () => {
+		const parentSessionFile = path.join(tempDir, "parent.jsonl");
+		const { manager, openedPaths } = makeForkingSessionManagerRecorder({ sessionFile: parentSessionFile, leafId: "leaf-current" });
+		const executor = makeExecutorWithDiscoverAgents(() => ({
+			agents: [
+				{ name: "worker", description: "Worker", defaultContext: "fork" },
+				{ name: "second", description: "Second" },
+			],
+			projectAgentsDir: null,
+		}));
+
+		const result = await executor.execute(
+			"id",
+			{ tasks: [{ agent: "worker", task: "one" }, { agent: "second", task: "two" }], context: "fresh" },
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.equal(result.details?.context, undefined);
+		assert.deepEqual(openedPaths, []);
+	});
+
+	it("uses each agent defaultContext for chain runs when launch context is omitted", async () => {
+		const parentSessionFile = path.join(tempDir, "parent.jsonl");
+		const { manager, openedPaths, branchedLeafIds } = makeForkingSessionManagerRecorder({ sessionFile: parentSessionFile, leafId: "leaf-current" });
+		const executor = makeExecutorWithDiscoverAgents(() => ({
+			agents: [
+				{ name: "echo", description: "Echo" },
+				{ name: "worker", description: "Worker", defaultContext: "fork" },
+			],
+			projectAgentsDir: null,
+		}));
+
+		const result = await executor.execute(
+			"id",
+			{ chain: [{ agent: "echo", task: "scan" }, { agent: "worker", task: "write" }], clarify: false },
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.equal(result.details?.context, "fork");
+		assert.deepEqual(openedPaths, [parentSessionFile]);
+		assert.deepEqual(branchedLeafIds, ["leaf-current"]);
+		const scanArgs = readCallArgsForTask("scan");
+		const writeArgs = readCallArgsForTask("write");
+		assert.doesNotMatch(scanArgs.at(-1) ?? "", /delegated subagent running from a fork/);
+		assert.match(writeArgs.at(-1) ?? "", /delegated subagent running from a fork/);
+		const forkSessionArgs = readSessionArgsFromCalls().filter((sessionFile) => path.basename(sessionFile).startsWith("fork-"));
+		assert.deepEqual(forkSessionArgs, [path.join(tempDir, "fork-1.jsonl")]);
+	});
+
+	it("fails before launching mixed parallel children when a default-fork session cannot branch", async () => {
+		const parentSessionFile = path.join(tempDir, "parent-mixed-fail.jsonl");
+		fs.writeFileSync(parentSessionFile, '{"type":"session","version":1,"id":"parent","timestamp":"2026-04-16T00:00:00.000Z","cwd":"/tmp"}\n', "utf-8");
+		const manager = {
+			getSessionId: () => "session-123",
+			getSessionFile: () => parentSessionFile,
+			getLeafId: () => "leaf-fail",
+			openSession: () => ({
+				createBranchedSession: () => {
+					throw new Error("branch write failed");
+				},
+			}),
+		};
+		const executor = makeExecutorWithDiscoverAgents(() => ({
+			agents: [
+				{ name: "scout", description: "Scout", defaultContext: "fresh" },
+				{ name: "worker", description: "Worker", defaultContext: "fork" },
+			],
+			projectAgentsDir: null,
+		}));
+
+		const result = await executor.execute(
+			"id",
+			{ tasks: [{ agent: "scout", task: "scan" }, { agent: "worker", task: "write" }] },
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, true);
+		assert.match(result.content[0]?.text ?? "", /Failed to create forked subagent session/);
+		assert.match(result.content[0]?.text ?? "", /branch write failed/);
+		assert.equal(mockPi.callCount(), 0);
+	});
+
+	it("preflights static default-fork chain steps even when the chain also has dynamic fanout", async () => {
+		const parentSessionFile = path.join(tempDir, "parent-dynamic-chain-fail.jsonl");
+		fs.writeFileSync(parentSessionFile, '{"type":"session","version":1,"id":"parent","timestamp":"2026-04-16T00:00:00.000Z","cwd":"/tmp"}\n', "utf-8");
+		const manager = {
+			getSessionId: () => "session-123",
+			getSessionFile: () => parentSessionFile,
+			getLeafId: () => "leaf-fail",
+			openSession: () => ({
+				createBranchedSession: () => {
+					throw new Error("branch write failed");
+				},
+			}),
+		};
+		const executor = makeExecutorWithDiscoverAgents(() => ({
+			agents: [
+				{ name: "scout", description: "Scout", defaultContext: "fresh" },
+				{ name: "worker", description: "Worker", defaultContext: "fork" },
+			],
+			projectAgentsDir: null,
+		}));
+
+		const result = await executor.execute(
+			"id",
+			{
+				chain: [
+					{ agent: "scout", task: "scan" },
+					{ agent: "worker", task: "write" },
+					{
+						expand: { from: { output: "items", path: "$" } },
+						parallel: { agent: "scout", task: "inspect item" },
+						collect: { as: "inspections" },
+					},
+				],
+				clarify: false,
+			},
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, true);
+		assert.match(result.content[0]?.text ?? "", /Failed to create forked subagent session/);
+		assert.match(result.content[0]?.text ?? "", /branch write failed/);
+		assert.equal(mockPi.callCount(), 0);
+	});
+
+	it("keeps later foreground forked chain steps aligned after short dynamic fanout", async () => {
+		mockPi.reset();
+		mockPi.onCall({ output: "targets", structuredOutput: { items: [{ id: "one" }] } });
+		mockPi.onCall({ output: "inspected one" });
+		mockPi.onCall({ output: "final done" });
+		const parentSessionFile = path.join(tempDir, "parent-dynamic-chain.jsonl");
+		const { manager } = makeForkingSessionManagerRecorder({ sessionFile: parentSessionFile, leafId: "leaf-current" });
+		const executor = makeExecutorWithDiscoverAgents(() => ({
+			agents: [
+				{ name: "producer", description: "Producer", defaultContext: "fresh" },
+				{ name: "worker", description: "Worker", defaultContext: "fork" },
+			],
+			projectAgentsDir: null,
+		}));
+
+		const result = await executor.execute(
+			"id",
+			{
+				chain: [
+					{ agent: "producer", task: "produce", as: "items", outputSchema: { type: "object" } },
+					{
+						expand: { from: { output: "items", path: "/items" }, item: "item", key: "/id", maxItems: 3 },
+						parallel: { agent: "worker", task: "inspect {item.id}" },
+						collect: { as: "inspections" },
+					},
+					{ agent: "worker", task: "final" },
+				],
+				clarify: false,
+			},
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.equal(mockPi.callCount(), 3);
+		assert.equal(readSessionArg(readCallArgsForTask("inspect one")), path.join(tempDir, "fork-1.jsonl"));
+		assert.equal(readSessionArg(readCallArgsForTask("final")), path.join(tempDir, "fork-4.jsonl"));
+	});
+
+	it("reports unknown top-level parallel agents before default-fork preconditions", async () => {
+		const { manager } = makeSessionManagerRecorder({ sessionFile: undefined, leafId: "leaf-current" });
+		const executor = makeExecutorWithDiscoverAgents(() => ({
+			agents: [{ name: "worker", description: "Worker", defaultContext: "fork" }],
+			projectAgentsDir: null,
+		}));
+
+		const result = await executor.execute(
+			"id",
+			{ tasks: [{ agent: "worker", task: "one" }, { agent: "missing", task: "two" }] },
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, true);
+		assert.match(result.content[0]?.text ?? "", /Unknown agent: missing/);
+		assert.doesNotMatch(result.content[0]?.text ?? "", /persisted parent session/);
+	});
+
+	it("fails fast when context=fork and parent session is missing", async () => {
+		const { manager } = makeSessionManagerRecorder({ sessionFile: undefined, leafId: "leaf-current" });
+		const executor = makeExecutor();
+
+		const result = await executor.execute(
+			"id",
+			{ agent: "echo", task: "test", context: "fork" },
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, true);
+		assert.match(result.content[0]?.text ?? "", /persisted parent session/);
+	});
+
+	it("fails fast when context=fork and leaf is missing", async () => {
+		const { manager } = makeSessionManagerRecorder({ sessionFile: "/tmp/parent.jsonl", leafId: null });
+		const executor = makeExecutor();
+
+		const result = await executor.execute(
+			"id",
+			{ agent: "echo", task: "test", context: "fork" },
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, true);
+		assert.match(result.content[0]?.text ?? "", /current leaf/);
+	});
+
+	it("returns a tool error (instead of throwing) when branch creation fails", async () => {
+		const executor = makeExecutor();
+		const parentSessionFile = path.join(tempDir, "parent.jsonl");
+		fs.writeFileSync(parentSessionFile, '{"type":"session","version":1,"id":"parent","timestamp":"2026-04-16T00:00:00.000Z","cwd":"/tmp"}\n', "utf-8");
+		const manager = {
+			getSessionId: () => "session-123",
+			getSessionFile: () => parentSessionFile,
+			getLeafId: () => "leaf-fail",
+			openSession: () => ({
+				createBranchedSession: () => {
+					throw new Error("branch write failed");
+				},
+			}),
+		};
+
+		const result = await executor.execute(
+			"id",
+			{ agent: "echo", task: "test", context: "fork" },
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, true);
+		assert.match(result.content[0]?.text ?? "", /Failed to create forked subagent session/);
+		assert.match(result.content[0]?.text ?? "", /branch write failed/);
+	});
+
+	it("creates one forked session for single mode", async () => {
+		const { manager, openedPaths, branchedLeafIds } = makeForkingSessionManagerRecorder({
+			sessionFile: path.join(tempDir, "parent.jsonl"),
+			leafId: "leaf-123",
+		});
+		const executor = makeExecutor();
+
+		const result = await executor.execute(
+			"id",
+			{ agent: "echo", task: "single task", context: "fork" },
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.deepEqual(openedPaths, [path.join(tempDir, "parent.jsonl")]);
+		assert.deepEqual(branchedLeafIds, ["leaf-123"]);
+		const args = readCallArgs();
+		const sessionIndex = args.indexOf("--session");
+		assert.notEqual(sessionIndex, -1);
+		assert.notEqual(args[sessionIndex + 1], path.join(tempDir, "parent.jsonl"));
+		assert.ok(args[sessionIndex + 1]);
+		assert.equal(fs.existsSync(args[sessionIndex + 1]!), true);
+	});
+
+	it("creates isolated forked sessions per parallel task", async () => {
+		const { manager, openedPaths, branchedLeafIds } = makeForkingSessionManagerRecorder({
+			sessionFile: path.join(tempDir, "parent-parallel.jsonl"),
+			leafId: "leaf-777",
+		});
+		const executor = makeExecutor();
+
+		const result = await executor.execute(
+			"id",
+			{
+				tasks: [
+					{ agent: "echo", task: "task one" },
+					{ agent: "second", task: "task two" },
+				],
+				context: "fork",
+			},
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.deepEqual(openedPaths, [path.join(tempDir, "parent-parallel.jsonl"), path.join(tempDir, "parent-parallel.jsonl")]);
+		assert.deepEqual(branchedLeafIds, ["leaf-777", "leaf-777"]);
+		const sessionArgs = readSessionArgsFromCalls();
+		assert.equal(sessionArgs.length, 2);
+		assert.equal(new Set(sessionArgs).size, 2);
+		for (const childSessionFile of sessionArgs) {
+			assert.notEqual(childSessionFile, path.join(tempDir, "parent-parallel.jsonl"));
+			assert.equal(fs.existsSync(childSessionFile), true);
+		}
+	});
+
+	it("expands top-level parallel task counts before fork session allocation", async () => {
+		const { manager, openedPaths, branchedLeafIds } = makeForkingSessionManagerRecorder({
+			sessionFile: path.join(tempDir, "parent-count.jsonl"),
+			leafId: "leaf-count",
+		});
+		const executor = makeExecutor();
+
+		const result = await executor.execute(
+			"id",
+			{
+				tasks: [{ agent: "echo", task: "task one", count: 3 }],
+				context: "fork",
+			},
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.deepEqual(openedPaths, [
+			path.join(tempDir, "parent-count.jsonl"),
+			path.join(tempDir, "parent-count.jsonl"),
+			path.join(tempDir, "parent-count.jsonl"),
+		]);
+		assert.deepEqual(branchedLeafIds, ["leaf-count", "leaf-count", "leaf-count"]);
+		const sessionArgs = readSessionArgsFromCalls();
+		assert.equal(sessionArgs.length, 3);
+		assert.equal(new Set(sessionArgs).size, 3);
+	});
+
+	it("rejects top-level parallel worktree runs with a conflicting task cwd", async () => {
+		const { manager } = makeSessionManagerRecorder({ sessionFile: "/tmp/parent.jsonl", leafId: "leaf-777" });
+		const executor = makeExecutor();
+
+		const result = await executor.execute(
+			"id",
+			{
+				tasks: [
+					{ agent: "echo", task: "task one" },
+					{ agent: "second", task: "task two", cwd: `${tempDir}/other` },
+				],
+				worktree: true,
+			},
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, true);
+		assert.match(result.content[0]?.text ?? "", /worktree isolation uses the shared cwd/i);
+		assert.match(result.content[0]?.text ?? "", /task 2 \(second\) sets cwd/i);
+	});
+
+	it("rejects top-level parallel counts that expand past MAX_PARALLEL", async () => {
+		const { manager } = makeSessionManagerRecorder({ sessionFile: "/tmp/parent.jsonl", leafId: "leaf-max" });
+		const executor = makeExecutor();
+
+		const result = await executor.execute(
+			"id",
+			{
+				tasks: [{ agent: "echo", task: "task one", count: 9 }],
+			},
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, true);
+		assert.match(result.content[0]?.text ?? "", /Max 8 tasks/);
+	});
+
+	it("uses top-level parallel config overrides for maxTasks and concurrency", async () => {
+		const { manager } = makeSessionManagerRecorder({ sessionFile: "/tmp/parent.jsonl", leafId: "leaf-max-config" });
+		const maxTasksExecutor = makeExecutorWithConfig({ parallel: { maxTasks: 9 } });
+
+		const maxTasksResult = await maxTasksExecutor.execute(
+			"id",
+			{
+				tasks: [{ agent: "echo", task: "task one", count: 9 }],
+			},
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(maxTasksResult.isError, undefined);
+		assert.equal(mockPi.callCount(), 9);
+
+		for (const testCase of [
+			{ name: "config", configConcurrency: 2, paramsConcurrency: undefined, expectedMaxRunning: 2 },
+			{ name: "per-call", configConcurrency: 3, paramsConcurrency: 1, expectedMaxRunning: 1 },
+		]) {
+			mockPi.reset();
+			for (let i = 0; i < 3; i++) {
+				mockPi.onCall({
+					steps: [
+						{ jsonl: [events.toolStart("bash", { command: `${testCase.name}-${i}` })] },
+						{ delay: 250 },
+						{ jsonl: [events.toolEnd("bash"), events.assistantMessage(`done-${i}`)] },
+					],
+				});
+			}
+
+			const executor = makeExecutorWithConfig({ parallel: { concurrency: testCase.configConcurrency } });
+			let maxRunning = 0;
+
+			const result = await executor.execute(
+				"id",
+				{
+					tasks: [
+						{ agent: "echo", task: "task one" },
+						{ agent: "second", task: "task two" },
+						{ agent: "echo", task: "task three" },
+					],
+					...(testCase.paramsConcurrency ? { concurrency: testCase.paramsConcurrency } : {}),
+				},
+				new AbortController().signal,
+				(update: ProgressUpdate) => {
+					const progress = update.details?.progress ?? [];
+					const running = progress.filter((entry) => entry.status === "running").length;
+					maxRunning = Math.max(maxRunning, running);
+				},
+				makeCtx(makeSessionManagerRecorder().manager),
+			);
+
+			assert.equal(result.isError, undefined, testCase.name);
+			assert.equal(maxRunning, testCase.expectedMaxRunning, testCase.name);
+		}
+	});
+
+	it("caps top-level foreground parallel execution with globalConcurrencyLimit", async () => {
+		mockPi.reset();
+		for (let i = 0; i < 4; i++) {
+			mockPi.onCall({
+				steps: [
+					{ jsonl: [events.toolStart("bash", { command: `global-${i}` })] },
+					{ delay: 250 },
+					{ jsonl: [events.toolEnd("bash"), events.assistantMessage(`done-${i}`)] },
+				],
+			});
+		}
+
+		const executor = makeExecutorWithConfig({ globalConcurrencyLimit: 2, parallel: { concurrency: 4 } });
+		let maxRunning = 0;
+
+		const result = await executor.execute(
+			"id",
+			{
+				tasks: [
+					{ agent: "echo", task: "task one" },
+					{ agent: "second", task: "task two" },
+					{ agent: "echo", task: "task three" },
+					{ agent: "second", task: "task four" },
+				],
+			},
+			new AbortController().signal,
+			(update: ProgressUpdate) => {
+				const progress = update.details?.progress ?? [];
+				const running = progress.filter((entry) => entry.status === "running").length;
+				maxRunning = Math.max(maxRunning, running);
+			},
+			makeCtx(makeSessionManagerRecorder().manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.equal(mockPi.callCount(), 4);
+		assert.equal(maxRunning, 2);
+	});
+
+	it("detaches parallel child runs cleanly on intercom handoff", async () => {
+		mockPi.reset();
+		mockPi.onCall({
+			steps: [
+				{ jsonl: [events.toolStart("intercom", { action: "send", to: "orchestrator" })] },
+				{ delay: 1000, jsonl: [events.assistantMessage("after handoff")] },
+			],
+		});
+		mockPi.onCall({ output: "other done" });
+		const executor = makeExecutorWithDiscoverAgents(() => ({
+			agents: [
+				{ name: "echo", description: "Echo", systemPrompt: "Intercom orchestration channel:" },
+				{ name: "second", description: "Second", systemPrompt: "Intercom orchestration channel:" },
+			],
+			projectAgentsDir: null,
+		}));
+		let detachEmitted = false;
+		const result = await executor.execute(
+			"intercom-parallel",
+			{
+				tasks: [
+					{ agent: "echo", task: "send handoff" },
+					{ agent: "second", task: "continue" },
+				],
+			},
+			new AbortController().signal,
+			(update: ProgressUpdate) => {
+				if (detachEmitted) return;
+				if (!update.details?.progress?.some((entry) => entry.currentTool === "intercom")) return;
+				detachEmitted = true;
+				executor.eventsApi.emit(INTERCOM_DETACH_REQUEST_EVENT, { requestId: "parallel-detach" });
+			},
+			makeCtx(makeSessionManagerRecorder().manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.match(result.content[0]?.text ?? "", /Parallel run detached for intercom coordination/);
+		assert.equal(detachEmitted, true);
+		assert.equal(result.details?.results?.some((entry) => entry.detached === true && entry.exitCode === 0), true);
+	});
+
+	it("runs top-level parallel async requests in the background", { skip: !asyncAvailable ? "jiti not available" : undefined }, async () => {
+		const executor = makeExecutor();
+
+		const result = await executor.execute(
+			"id",
+			{
+				tasks: [
+					{ agent: "echo", task: "task one" },
+					{ agent: "second", task: "task two" },
+				],
+				async: true,
+				clarify: false,
+			},
+			new AbortController().signal,
+			undefined,
+			makeCtx(makeSessionManagerRecorder().manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.equal(result.details?.mode, "parallel");
+		assert.ok(result.details?.asyncId, "expected an asyncId for background top-level parallel runs");
+		assert.match(result.content[0]?.text ?? "", /Async parallel:/);
+	});
+
+	it("runs async chain requests in the background when clarify is omitted", { skip: !asyncAvailable ? "jiti not available" : undefined }, async () => {
+		const executor = makeExecutor();
+
+		const result = await executor.execute(
+			"id",
+			{
+				chain: [
+					{ agent: "echo", task: "task one" },
+					{ agent: "second", task: "task two" },
+				],
+				async: true,
+			},
+			new AbortController().signal,
+			undefined,
+			makeCtx(makeSessionManagerRecorder().manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.equal(result.details?.mode, "chain");
+		assert.ok(result.details?.asyncId, "expected an asyncId for background chain runs");
+		assert.match(result.content[0]?.text ?? "", /Async chain:/);
+	});
+
+	it("keeps explicit clarify async chain requests in the foreground", async () => {
+		const executor = makeExecutor();
+
+		const result = await executor.execute(
+			"id",
+			{
+				chain: [
+					{ agent: "echo", task: "task one" },
+					{ agent: "second", task: "task two" },
+				],
+				async: true,
+				clarify: true,
+			},
+			new AbortController().signal,
+			undefined,
+			makeCtx(makeSessionManagerRecorder().manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.equal(result.details?.mode, "chain");
+		assert.equal(result.details?.asyncId, undefined);
+		assert.doesNotMatch(result.content[0]?.text ?? "", /Async chain:/);
+	});
+
+	it("rejects invalid background top-level parallel requests during executor preflight", async () => {
+		const executor = makeExecutor();
+		for (const testCase of [
+			{
+				name: "max tasks",
+				params: { tasks: [{ agent: "echo", task: "task one", count: 9 }], async: true, clarify: false },
+				patterns: [/Max 8 tasks/],
+			},
+			{
+				name: "worktree cwd conflict",
+				params: {
+					tasks: [
+						{ agent: "echo", task: "task one" },
+						{ agent: "second", task: "task two", cwd: `${tempDir}/other` },
+					],
+					worktree: true,
+					async: true,
+					clarify: false,
+				},
+				patterns: [/worktree isolation uses the shared cwd/i, /task 2 \(second\) sets cwd/i],
+			},
+		]) {
+			const result = await executor.execute(
+				"id",
+				testCase.params,
+				new AbortController().signal,
+				undefined,
+				makeCtx(makeSessionManagerRecorder().manager),
+			);
+
+			assert.equal(result.isError, true, testCase.name);
+			for (const pattern of testCase.patterns) {
+				assert.match(result.content[0]?.text ?? "", pattern, testCase.name);
+			}
+		}
+	});
+
+	it("rejects async chain worktree runs with a conflicting task cwd", async () => {
+		const { manager } = makeSessionManagerRecorder({ sessionFile: "/tmp/parent.jsonl", leafId: "leaf-chain" });
+		const executor = makeExecutor();
+
+		const result = await executor.execute(
+			"id",
+			{
+				chain: [
+					{
+						parallel: [
+							{ agent: "echo", task: "p1" },
+							{ agent: "second", task: "p2", cwd: `${tempDir}/other` },
+						],
+						worktree: true,
+					},
+				],
+				async: true,
+				clarify: false,
+			},
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, true);
+		assert.match(result.content[0]?.text ?? "", /parallel chain step 1/i);
+		assert.match(result.content[0]?.text ?? "", /task 2 \(second\) sets cwd/i);
+	});
+
+	it("creates isolated forked sessions per chain step (including counted parallel steps)", async () => {
+		const { manager, openedPaths, branchedLeafIds } = makeForkingSessionManagerRecorder({
+			sessionFile: path.join(tempDir, "parent-chain.jsonl"),
+			leafId: "leaf-chain",
+		});
+		const executor = makeExecutor();
+
+		const result = await executor.execute(
+			"id",
+			{
+				chain: [
+					{ agent: "echo", task: "step 1" },
+					{ parallel: [{ agent: "echo", task: "p1", count: 2 }, { agent: "second", task: "p2", count: 2 }] },
+					{ agent: "second", task: "step 3" },
+				],
+				context: "fork",
+				clarify: false,
+			},
+			new AbortController().signal,
+			undefined,
+			makeCtx(manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.deepEqual(openedPaths, Array(6).fill(path.join(tempDir, "parent-chain.jsonl")));
+		assert.deepEqual(branchedLeafIds, Array(6).fill("leaf-chain"));
+		const sessionArgs = readSessionArgsFromCalls().filter((sessionFile) => path.dirname(sessionFile) === tempDir && path.basename(sessionFile).startsWith("fork-"));
+		assert.equal(sessionArgs.length, 6, "1 sequential + 4 parallel + 1 sequential");
+		assert.equal(new Set(sessionArgs).size, 6);
+	});
+
+	it("uses request cwd for management actions", async () => {
+		const executor = makeExecutor();
+		const worktreeDir = path.join(tempDir, "worktree");
+		fs.mkdirSync(path.join(worktreeDir, ".selesai"), { recursive: true });
+
+		const result = await executor.execute(
+			"id",
+			{
+				action: "create",
+				cwd: "worktree",
+				config: { name: "local-helper", description: "Local helper", scope: "project" },
+			},
+			new AbortController().signal,
+			undefined,
+			makeCtx(makeSessionManagerRecorder().manager),
+		);
+
+		assert.equal(result.isError, false);
+		assert.equal(fs.existsSync(path.join(worktreeDir, ".selesai", "agents", "local-helper.md")), true);
+		assert.equal(fs.existsSync(path.join(tempDir, ".selesai", "agents", "local-helper.md")), false);
+	});
+
+	it("uses request cwd for execution-time agent discovery", async () => {
+		const worktreeDir = path.join(tempDir, "worktree");
+		writeAgent(tempDir, "echo", "openai/gpt-5-main");
+		writeAgent(worktreeDir, "echo", "anthropic/claude-haiku-4-5");
+		const executor = makeExecutorWithDiscoverAgents(discoverAgents);
+		const task = `test ${path.basename(tempDir)}`;
+
+		const result = await executor.execute(
+			"id",
+			{ agent: "echo", task, cwd: "worktree" },
+			new AbortController().signal,
+			undefined,
+			makeCtx(makeSessionManagerRecorder().manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		const args = readAllCallArgs().find((callArgs) => (callArgs.at(-1) ?? "").startsWith(`Task: ${task}\n\n## Acceptance Contract`));
+		assert.ok(args, "expected a recorded mock pi call for this test task");
+		const modelIndex = args.indexOf("--model");
+		assert.notEqual(modelIndex, -1);
+		assert.equal(args[modelIndex + 1], "anthropic/claude-haiku-4-5");
+	});
+
+	it("resolves parallel task cwd values relative to the request cwd", async () => {
+		const worktreeDir = path.join(tempDir, "worktree");
+		writePackageSkill(path.join(worktreeDir, "packages", "app"), "parallel-step-skill");
+		const executor = makeExecutorWithDiscoverAgents(() => ({
+			agents: [{ name: "echo", description: "Echo test agent", skills: ["parallel-step-skill"] }],
+			projectAgentsDir: null,
+		}));
+
+		const result = await executor.execute(
+			"id",
+			{
+				tasks: [{ agent: "echo", task: "test", cwd: "packages/app" }],
+				cwd: worktreeDir,
+			},
+			new AbortController().signal,
+			undefined,
+			makeCtx(makeSessionManagerRecorder().manager),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.deepEqual(result.details?.results?.[0]?.skills, ["parallel-step-skill"]);
+	});
+
+	it("uses request cwd for project builtin overrides during management", async () => {
+		const tempHome = createTempDir("pi-subagent-home-");
+		process.env.HOME = tempHome;
+		process.env.USERPROFILE = tempHome;
+		const worktreeDir = path.join(tempDir, "worktree");
+		fs.mkdirSync(worktreeDir, { recursive: true });
+		writeProjectOverride(tempDir, "reviewer", "openai/gpt-5-main");
+		writeProjectOverride(worktreeDir, "reviewer", "openai/gpt-5-worktree");
+		const executor = makeExecutor();
+
+		try {
+			const result = await executor.execute(
+				"id",
+				{ action: "get", agent: "reviewer", cwd: "worktree" },
+				new AbortController().signal,
+				undefined,
+				makeCtx(makeSessionManagerRecorder().manager),
+			);
+
+			assert.equal(result.isError, false);
+			assert.match(result.content[0]?.text ?? "", /Model: openai\/gpt-5-worktree/);
+			assert.doesNotMatch(result.content[0]?.text ?? "", /Model: openai\/gpt-5-main/);
+		} finally {
+			removeTempDir(tempHome);
+		}
+	});
+});