@selesai/code 0.13.15 → 0.13.18

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

@@ -4,13 +4,13 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
 import { acquireActiveAsyncCapacity } from "../../src/runs/background/active-async-capacity.ts";
-import { consumeSteerRequests, consumeSteerRequestsFromDir, consumeStopRequestPayload, stepSteerInboxDir, writeSteerAck } from "../../src/runs/background/control-channel.ts";
+import { consumeSteerRequests, consumeStopRequestPayload } from "../../src/runs/background/control-channel.ts";
 import { listAsyncRuns } from "../../src/runs/background/async-status.ts";
 import { inspectSubagentStatus } from "../../src/runs/background/run-status.ts";
 import { createSubagentExecutor, steerWorkflowChildByKey } from "../../src/runs/foreground/subagent-executor.ts";
 import { resolveExternalCliRunnerStatus } from "../../src/runs/shared/external-cli-contract.ts";
-import { steerWorkflowForegroundTarget, workflowForegroundSteeringDir } from "../../src/runs/foreground/workflow-foreground-steering.ts";
-import { ASYNC_DIR, RESULTS_DIR, type SubagentState } from "../../src/shared/types.ts";
+import { steerWorkflowForegroundTarget } from "../../src/runs/foreground/workflow-foreground-steering.ts";
+import { ASYNC_DIR, RESULTS_DIR, type ForegroundChildControl, type ForegroundSteerInput, type SubagentState } from "../../src/shared/types.ts";
 
 function createState(): SubagentState {
 	return {
@@ -68,24 +68,38 @@ function cleanup(runId: string, asyncDir: string): void {
 	fs.rmSync(path.join(RESULTS_DIR, `${runId}.json`), { force: true });
 }
 
-function createWorkflowForegroundControl(state: SubagentState, workflowRunId: string, childRunId: string): string {
-	const routeDir = workflowForegroundSteeringDir(ASYNC_DIR, workflowRunId, childRunId);
+interface RecordedSteer {
+	message: string;
+	mode?: string;
+}
+
+function createWorkflowForegroundControl(
+	state: SubagentState,
+	workflowRunId: string,
+	childRunId: string,
+	options: { steer?: ForegroundChildControl["steer"] | null } = {},
+): RecordedSteer[] {
+	const steers: RecordedSteer[] = [];
+	const steer = options.steer === null
+		? undefined
+		: options.steer ?? (async (input: ForegroundSteerInput) => {
+			steers.push({ message: input.message, ...(input.mode ? { mode: input.mode } : {}) });
+			return { state: input.mode === "follow_up" ? "queued" as const : "delivered" as const };
+		});
 	state.workflowControllers ??= new Map();
 	state.workflowControllers.set(workflowRunId, new AbortController());
 	state.foregroundControls.set(childRunId, {
 		runId: childRunId,
 		parentWorkflowRunId: workflowRunId,
 		workflowKey: childRunId,
-		workflowSteeringDir: routeDir,
 		sessionId: "session",
 		mode: "single",
 		startedAt: 100,
 		updatedAt: 100,
-		activeChildren: new Map([[0, { index: 0, agent: "worker", startedAt: 100, updatedAt: 100 }]]),
+		activeChildren: new Map([[0, { index: 0, agent: "worker", startedAt: 100, updatedAt: 100, ...(steer ? { steer } : {}) }]]),
 		schedulingOwners: 1,
 	});
-	fs.mkdirSync(stepSteerInboxDir(routeDir, 0), { recursive: true });
-	return routeDir;
+	return steers;
 }
 
 async function waitUntil<T>(read: () => T | undefined, timeoutMs = 5_000): Promise<T> {
@@ -200,22 +214,15 @@ describe("async interrupt action", () => {
 		const workflowRunId = `workflow-child-${Date.now().toString(36)}`;
 		const childRunId = `${workflowRunId}-child`;
 		const asyncDir = createRunningAsync(state, workflowRunId, { track: false, mode: "workflow" });
-		const routeDir = createWorkflowForegroundControl(state, workflowRunId, childRunId);
+		const steers = createWorkflowForegroundControl(state, workflowRunId, childRunId);
 		try {
-			const action = executorWithKill(state, () => true)
+			const result = await executorWithKill(state, () => true)
 				.execute("steer", { action: "steer", id: childRunId, message: "Focus on the failing test." }, new AbortController().signal, undefined, ctx());
-			const request = await waitUntil(() => {
-				const inbox = stepSteerInboxDir(routeDir, 0);
-				const entry = fs.existsSync(inbox) ? fs.readdirSync(inbox).find((name) => name.endsWith(".json")) : undefined;
-				return entry ? JSON.parse(fs.readFileSync(path.join(inbox, entry), "utf-8")) as { id: string; message: string } : undefined;
-			});
-			writeSteerAck(routeDir, { requestId: request.id, index: 0, ts: Date.now(), state: "delivered", message: "accepted" });
-			const result = await action;
 
 			assert.equal(result.isError, undefined);
 			assert.equal(result.details.steering?.state, "delivered");
 			assert.equal(result.details.steering?.sourceRunId, childRunId);
-			assert.equal(request.message, "Focus on the failing test.");
+			assert.deepEqual(steers, [{ message: "Focus on the failing test." }]);
 			assert.match(text(result), /Message sent:\n```text\nFocus on the failing test\.\n```/);
 		} finally {
 			cleanup(workflowRunId, asyncDir);
@@ -227,16 +234,27 @@ describe("async interrupt action", () => {
 		const workflowRunId = `workflow-key-foreground-${Date.now().toString(36)}`;
 		const childRunId = `${workflowRunId}-writer`;
 		const asyncDir = createRunningAsync(state, workflowRunId, { track: false, mode: "workflow" });
-		const routeDir = createWorkflowForegroundControl(state, workflowRunId, childRunId);
+		const steers = createWorkflowForegroundControl(state, workflowRunId, childRunId);
 		try {
-			const action = steerWorkflowChildByKey({ state, workflowRunId, key: childRunId, message: "Focus on the contract.", options: { ackTimeoutMs: 500 } });
-			const request = await waitUntil(() => {
-				const inbox = stepSteerInboxDir(routeDir, 0);
-				const entry = fs.readdirSync(inbox).find((name) => name.endsWith(".json"));
-				return entry ? JSON.parse(fs.readFileSync(path.join(inbox, entry), "utf-8")) as { id: string } : undefined;
-			});
-			writeSteerAck(routeDir, { requestId: request.id, index: 0, ts: Date.now(), state: "delivered", message: "accepted" });
-			assert.equal((await action).state, "delivered");
+			const action = await steerWorkflowChildByKey({ state, workflowRunId, key: childRunId, message: "Focus on the contract.", options: { ackTimeoutMs: 500 } });
+			assert.equal(action.state, "delivered");
+			assert.deepEqual(steers, [{ message: "Focus on the contract." }]);
+		} finally {
+			cleanup(workflowRunId, asyncDir);
+		}
+	});
+
+	it("retries a foreground workflow-key steer until the child session is running", async () => {
+		const state = createState();
+		const workflowRunId = `workflow-key-early-${Date.now().toString(36)}`;
+		const childRunId = `${workflowRunId}-writer`;
+		const asyncDir = createRunningAsync(state, workflowRunId, { track: false, mode: "workflow" });
+		let attempts = 0;
+		createWorkflowForegroundControl(state, workflowRunId, childRunId, { steer: async () => ++attempts < 3 ? { state: "failed" as const, reason: "Child session is not running yet." } : { state: "delivered" as const } });
+		try {
+			const action = await steerWorkflowChildByKey({ state, workflowRunId, key: childRunId, message: "Early.", options: { ackTimeoutMs: 500 } });
+			assert.equal(action.state, "delivered");
+			assert.equal(attempts, 3);
 		} finally {
 			cleanup(workflowRunId, asyncDir);
 		}
@@ -342,74 +360,65 @@ describe("async interrupt action", () => {
 		}
 	});
 
-	it("rejects a steer request when its workflow foreground route is already removed", async () => {
+	it("reports a failed steer when the child session rejects it", async () => {
 		const state = createState();
-		const workflowRunId = `workflow-missing-route-${Date.now().toString(36)}`;
+		const workflowRunId = `workflow-steer-failed-${Date.now().toString(36)}`;
 		const childRunId = `${workflowRunId}-child`;
 		const asyncDir = createRunningAsync(state, workflowRunId, { track: false, mode: "workflow" });
-		const routeDir = createWorkflowForegroundControl(state, workflowRunId, childRunId);
+		createWorkflowForegroundControl(state, workflowRunId, childRunId, { steer: async () => ({ state: "failed", reason: "session is settling" }) });
 		try {
 			const control = state.foregroundControls.get(childRunId)!;
-			fs.rmSync(routeDir, { recursive: true, force: true });
 			const result = await steerWorkflowForegroundTarget({
 				target: { control, workflowRunId, sourceRunId: childRunId },
 				message: "Focus on the failing test.",
-				ackTimeoutMs: 40,
 			});
 
 			assert.equal(result.isError, true);
-			assert.match(text(result), /no live workflow steering route/);
-			assert.equal(result.details.steering, undefined);
-			assert.equal(fs.existsSync(routeDir), false);
+			assert.match(text(result), /Steering failed .*session is settling/);
+			assert.equal(result.details.steering?.state, "failed");
 		} finally {
 			cleanup(workflowRunId, asyncDir);
 		}
 	});
 
-	it("rejects a steer request when its workflow foreground child inbox is missing", async () => {
+	it("rejects a steer request when the child session is not steerable", async () => {
 		const state = createState();
-		const workflowRunId = `workflow-missing-inbox-${Date.now().toString(36)}`;
+		const workflowRunId = `workflow-no-steer-${Date.now().toString(36)}`;
 		const childRunId = `${workflowRunId}-child`;
 		const asyncDir = createRunningAsync(state, workflowRunId, { track: false, mode: "workflow" });
-		const routeDir = createWorkflowForegroundControl(state, workflowRunId, childRunId);
+		createWorkflowForegroundControl(state, workflowRunId, childRunId, { steer: null });
 		try {
 			const control = state.foregroundControls.get(childRunId)!;
-			fs.rmSync(stepSteerInboxDir(routeDir, 0), { recursive: true, force: true });
 			const result = await steerWorkflowForegroundTarget({
 				target: { control, workflowRunId, sourceRunId: childRunId },
 				message: "Focus on the failing test.",
-				ackTimeoutMs: 40,
 			});
 
 			assert.equal(result.isError, true);
-			assert.match(text(result), /no live workflow steering route/);
+			assert.match(text(result), /does not support steering/);
 			assert.equal(result.details.steering, undefined);
-			assert.equal(fs.existsSync(stepSteerInboxDir(routeDir, 0)), false);
 		} finally {
 			cleanup(workflowRunId, asyncDir);
 		}
 	});
 
-	it("rejects a steer request when its workflow foreground route is removed during the final acknowledgment wait", async () => {
+	it("queues follow-up steering through the child session", async () => {
 		const state = createState();
-		const workflowRunId = `workflow-removed-route-${Date.now().toString(36)}`;
+		const workflowRunId = `workflow-follow-up-${Date.now().toString(36)}`;
 		const childRunId = `${workflowRunId}-child`;
 		const asyncDir = createRunningAsync(state, workflowRunId, { track: false, mode: "workflow" });
-		const routeDir = createWorkflowForegroundControl(state, workflowRunId, childRunId);
+		const steers = createWorkflowForegroundControl(state, workflowRunId, childRunId);
 		try {
 			const control = state.foregroundControls.get(childRunId)!;
-			const action = steerWorkflowForegroundTarget({
+			const result = await steerWorkflowForegroundTarget({
 				target: { control, workflowRunId, sourceRunId: childRunId },
-				message: "Focus on the failing test.",
-				ackTimeoutMs: 40,
+				message: "After this, update the docs.",
+				mode: "follow_up",
 			});
-			await waitUntil(() => fs.existsSync(stepSteerInboxDir(routeDir, 0)) ? true : undefined);
-			fs.rmSync(routeDir, { recursive: true, force: true });
-			const result = await action;
 
-			assert.equal(result.isError, true);
-			assert.match(text(result), /no live child session/);
-			assert.equal(result.details.steering, undefined);
+			assert.equal(result.isError, undefined);
+			assert.equal(result.details.steering?.deliveryStatus, "queued");
+			assert.deepEqual(steers, [{ message: "After this, update the docs.", mode: "follow_up" }]);
 		} finally {
 			cleanup(workflowRunId, asyncDir);
 		}
@@ -421,19 +430,17 @@ describe("async interrupt action", () => {
 			const workflowRunId = `workflow-${target}-${Date.now().toString(36)}`;
 			const childRunId = `${workflowRunId}-child`;
 			const asyncDir = createRunningAsync(state, workflowRunId, { track: false, mode: "workflow" });
-			const routeDir = createWorkflowForegroundControl(state, workflowRunId, childRunId);
+			const steers = createWorkflowForegroundControl(state, workflowRunId, childRunId);
 			try {
-				const controller = new AbortController();
-				setTimeout(() => controller.abort(), 10);
 				const params = target === "id"
 					? { action: "steer", id: workflowRunId, message: "Review the contract." }
 					: { action: "steer", dir: asyncDir, message: "Review the contract." };
 				const result = await executorWithKill(state, () => true)
-					.execute("steer", params, controller.signal, undefined, ctx());
+					.execute("steer", params, new AbortController().signal, undefined, ctx());
 
 				assert.equal(result.isError, undefined);
 				assert.equal(result.details.steering?.sourceRunId, workflowRunId);
-				assert.equal(consumeSteerRequestsFromDir(stepSteerInboxDir(routeDir, 0))[0]?.message, "Review the contract.");
+				assert.deepEqual(steers, [{ message: "Review the contract." }]);
 			} finally {
 				cleanup(workflowRunId, asyncDir);
 			}
@@ -444,16 +451,16 @@ describe("async interrupt action", () => {
 		const state = createState();
 		const workflowRunId = `workflow-ambiguous-${Date.now().toString(36)}`;
 		const asyncDir = createRunningAsync(state, workflowRunId, { track: false, mode: "workflow" });
-		const firstRoute = createWorkflowForegroundControl(state, workflowRunId, `${workflowRunId}-one`);
-		const secondRoute = createWorkflowForegroundControl(state, workflowRunId, `${workflowRunId}-two`);
+		const firstSteers = createWorkflowForegroundControl(state, workflowRunId, `${workflowRunId}-one`);
+		const secondSteers = createWorkflowForegroundControl(state, workflowRunId, `${workflowRunId}-two`);
 		try {
 			const result = await executorWithKill(state, () => true)
 				.execute("steer", { action: "steer", id: workflowRunId, message: "Do not guess." }, new AbortController().signal, undefined, ctx());
 
 			assert.equal(result.isError, true);
 			assert.match(text(result), /2 live foreground children/);
-			assert.equal(consumeSteerRequestsFromDir(stepSteerInboxDir(firstRoute, 0)).length, 0);
-			assert.equal(consumeSteerRequestsFromDir(stepSteerInboxDir(secondRoute, 0)).length, 0);
+			assert.equal(firstSteers.length, 0);
+			assert.equal(secondSteers.length, 0);
 		} finally {
 			cleanup(workflowRunId, asyncDir);
 		}
@@ -475,7 +482,7 @@ describe("async interrupt action", () => {
 				.execute("steer", { action: "steer", dir: asyncDir, message: "Too late." }, new AbortController().signal, undefined, ctx());
 
 			assert.equal(result.isError, true);
-			assert.match(text(result), /no live foreground child/);
+			assert.match(text(result), /not running or queued/);
 			assert.equal(fs.existsSync(path.join(asyncDir, "control", "steer-requests")), false);
 		} finally {
 			cleanup(workflowRunId, asyncDir);
@@ -1019,4 +1026,4 @@ describe("async interrupt action", () => {
 			cleanup(runId, asyncDir);
 		}
 	});
-});
+});

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

@@ -49,6 +49,56 @@ describe("async recovery descriptor", () => {
 		}
 	});
 
+	it("accepts a safe baseRef in persisted recovery descriptors", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-recovery-base-ref-"));
+		try {
+			fs.writeFileSync(path.join(root, "recovery-descriptor.json"), JSON.stringify({
+				version: 1,
+				baseRef: "@/foo",
+				runFanoutBudget: runFanoutBudget("run-base-ref"),
+				sourceRunId: "run-base-ref",
+				agent: "worker",
+				cwd: root,
+				systemPromptMode: "replace",
+				inheritGlobalContext: false,
+				inheritProjectContext: false,
+				inheritSkills: false,
+				outputMode: "inline",
+				maxSubagentDepth: 2,
+				share: false,
+			}), "utf-8");
+			assert.equal(readAsyncRecoveryDescriptor(root)?.baseRef, "@/foo");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects unsafe baseRef values in persisted recovery descriptors", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-recovery-bad-base-ref-"));
+		try {
+			for (const baseRef of ["refs/heads/unsafe..ref", "a".repeat(40), "a".repeat(64)] as const) {
+				fs.writeFileSync(path.join(root, "recovery-descriptor.json"), JSON.stringify({
+					version: 1,
+					baseRef,
+					runFanoutBudget: runFanoutBudget("run-bad-base-ref"),
+					sourceRunId: "run-bad-base-ref",
+					agent: "worker",
+					cwd: root,
+					systemPromptMode: "replace",
+					inheritGlobalContext: false,
+					inheritProjectContext: false,
+					inheritSkills: false,
+					outputMode: "inline",
+					maxSubagentDepth: 2,
+					share: false,
+				}), "utf-8");
+				assert.throws(() => readAsyncRecoveryDescriptor(root), /baseRef must be a valid Git ref/);
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("defaults inheritGlobalContext from inheritProjectContext for descriptors from older versions", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-recovery-legacy-global-context-"));
 		try {
@@ -185,4 +235,4 @@ describe("async recovery descriptor", () => {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
 	});
-});
+});

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

@@ -287,6 +287,54 @@ describe("async retention cleanup", () => {
 		}
 	});
 
+	it("does not reclaim a live replacement owner after a reused pid identity changes", async () => {
+		const roots = makeRoots();
+		try {
+			const reusedPid = process.pid + 100_000;
+			const lockDir = path.join(roots.root, ".async-retention.lock");
+			const ownerPath = path.join(lockDir, "owner.json");
+			const replacementOwner = {
+				version: 1,
+				token: "replacement-token",
+				pid: reusedPid,
+				hostname: "test-host",
+				processStartIdentity: "replacement-process",
+				startedAt: NOW,
+			};
+			fs.mkdirSync(lockDir);
+			fs.writeFileSync(ownerPath, JSON.stringify({
+				version: 1,
+				token: "old-token",
+				pid: reusedPid,
+				hostname: "test-host",
+				processStartIdentity: "old-process",
+				startedAt: NOW,
+			}));
+
+			let currentIdentity = "old-process";
+			const options = {
+				...cleanupOptions(roots),
+				hostname: "test-host",
+				processStartIdentity: "cleaner-process",
+				isProcessAlive: (pid: number) => pid === reusedPid || pid === process.pid,
+				getProcessStartIdentity: (pid: number) => pid === reusedPid ? currentIdentity : "cleaner-process",
+			};
+			const first = await cleanupAsyncRetention(options);
+			assert.equal(first.acquired, false);
+			assert.equal(first.skipped["lock-busy"], 1);
+
+			fs.writeFileSync(ownerPath, JSON.stringify(replacementOwner));
+			currentIdentity = "replacement-process";
+			const second = await cleanupAsyncRetention(options);
+
+			assert.equal(second.acquired, false);
+			assert.equal(second.skipped["lock-busy"], 1);
+			assert.deepEqual(JSON.parse(fs.readFileSync(ownerPath, "utf-8")), replacementOwner);
+		} finally {
+			fs.rmSync(roots.root, { recursive: true, force: true });
+		}
+	});
+
 	it("limits result candidates to the cleanup batch", async () => {
 		const roots = makeRoots();
 		try {
@@ -632,4 +680,4 @@ describe("async retention cleanup", () => {
 			fs.rmSync(roots.root, { recursive: true, force: true });
 		}
 	});
-});
+});

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

@@ -0,0 +1,103 @@
+import assert from "node:assert/strict";
+import childProcess from "node:child_process";
+import * as fs from "node:fs";
+import { syncBuiltinESMExports } from "node:module";
+import * as os from "node:os";
+import * as path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV } from "../../src/shared/utils.ts";
+
+test("executeAsyncSingle preloads supplemental server aliases before jiti, but not for complete hosts", async (t) => {
+	const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "async-spawn-preload-")));
+	const host = path.join(root, "host");
+	const server = "@earendil-works/pi-server";
+	const expectedAliases: Record<string, string> = {};
+	const hostExports: Record<string, string[]> = {
+		"@selesai/code": ["."],
+		"@earendil-works/pi-agent-core": [".", "./node"],
+		"@earendil-works/chord": [".", "./context"],
+		"@earendil-works/pi-tui": ["."],
+		"@earendil-works/pi-ai": ["./compat", "./oauth", "./providers/all"],
+		"typebox": [".", "./compile", "./value"],
+		[server]: [".", "./unix"],
+		"@earendil-works/pi-client": ["./unix"],
+	};
+	// Use real package manifests/targets, as in host-peer-runtime-imports.test.ts.
+	function writeHostPackage(pkg: string) {
+		const dir = pkg === "@selesai/code" ? host : path.join(host, "node_modules", pkg);
+		fs.mkdirSync(dir, { recursive: true });
+		const exports = Object.fromEntries(hostExports[pkg]!.map(subpath => {
+			const target = `./${subpath === "." ? "index" : subpath.slice(2).replaceAll("/", "-")}.mjs`;
+			fs.writeFileSync(path.join(dir, target), "export {};\n");
+			expectedAliases[subpath === "." ? pkg : `${pkg}/${subpath.slice(2)}`] = path.join(dir, target);
+			if (pkg === "@earendil-works/pi-ai" && subpath === "./compat") expectedAliases[pkg] = path.join(dir, target);
+			return [subpath, target];
+		}));
+		fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ name: pkg, version: "0.85.0", exports }));
+	}
+	const originalArgv1 = process.argv[1];
+	try {
+		for (const pkg of Object.keys(hostExports)) {
+			if (pkg !== server) writeHostPackage(pkg);
+		}
+		for (const specifier of [server, `${server}/unix`]) {
+			expectedAliases[specifier] = fileURLToPath(import.meta.resolve(specifier));
+		}
+		// Production discovers the host from the Pi entrypoint at module load.
+		process.argv[1] = expectedAliases["@selesai/code"];
+		// helpers -> mock-pi -> child-session -> readonly evidence -> child hooks
+		// also loads async-execution. Set the host before importing that graph.
+		const { makeAgent } = await import("../support/helpers.ts");
+		const { executeAsyncSingle } = await import("../../src/runs/background/async-execution.ts");
+		const spawn = t.mock.method(childProcess, "spawn", () => {
+			// Stop at the only external I/O seam: no fake pid or detached lifecycle.
+			throw new Error("spawn boundary captured");
+		});
+		syncBuiltinESMExports();
+		for (const scenario of ["supplemental", "complete", "stable", "missing-stable"]) {
+			if (scenario === "complete") writeHostPackage(server);
+			if (scenario === "stable") {
+				fs.writeFileSync(path.join(host, "package.json"), JSON.stringify({ name: "@selesai/code", version: "0.85.1", exports: { ".": "./index.mjs" } }));
+				for (const pkg of [server, "@earendil-works/pi-client"]) fs.rmSync(path.join(host, "node_modules", pkg), { recursive: true });
+				for (const specifier of [server, `${server}/unix`, "@earendil-works/pi-client/unix"]) delete expectedAliases[specifier];
+			}
+			if (scenario === "missing-stable") fs.unlinkSync(expectedAliases["@earendil-works/pi-agent-core/node"]!);
+			const result = executeAsyncSingle(`spawn-preload-${scenario}`, {
+				agent: "worker", task: "Inspect launch wiring", agentConfig: makeAgent("worker"),
+				ctx: { pi: { events: { emit() {} } }, cwd: root, currentSessionId: "spawn-preload-session" },
+				artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+				shareEnabled: false, sessionRoot: path.join(root, "sessions"), maxSubagentDepth: 1, acceptance: false,
+			});
+			assert.equal(result.isError, true);
+			if (scenario === "missing-stable") {
+				assert.match(result.content[0]!.text, /@earendil-works\/pi-agent-core\/node/);
+				assert.equal(spawn.mock.callCount(), 3);
+				continue;
+			}
+			assert.match(result.content[0]!.text, /spawn boundary captured/);
+			assert.equal(spawn.mock.callCount(), scenario === "supplemental" ? 1 : scenario === "complete" ? 2 : 3);
+			const [command, args, options] = spawn.mock.calls.at(-1)!.arguments;
+			assert.ok(path.isAbsolute(command));
+			assert.equal(options.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV], host);
+			const actualAliases = JSON.parse(options.env.JITI_ALIAS) as Record<string, string>;
+			assert.deepEqual(Object.fromEntries(Object.entries(actualAliases).map(([key, target]) => [key, fs.realpathSync(target)])), expectedAliases);
+			const jitiIndex = scenario === "supplemental" ? 2 : 0;
+			if (scenario !== "supplemental") assert.ok(!args.includes("--import"));
+			else {
+				assert.equal(args[0], "--import");
+				assert.equal(args[1], new URL("../../runner-server-preload.mjs", import.meta.url).href);
+				assert.ok(fs.existsSync(fileURLToPath(args[1])));
+			}
+			assert.match(args[jitiIndex], /[/\\]jiti-cli\.mjs$/);
+			assert.match(args[jitiIndex + 1], /[/\\]subagent-runner\.ts$/);
+			assert.equal(args.length, jitiIndex + 3);
+		}
+	} finally {
+		t.mock.restoreAll();
+		syncBuiltinESMExports();
+		if (originalArgv1 === undefined) delete process.argv[1];
+		else process.argv[1] = originalArgv1;
+		fs.rmSync(root, { recursive: true, force: true });
+	}
+});

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

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import type { AsyncJobState, HostStepNodeV1, WorkflowGraphSnapshot, WorkflowNodeStatus } from "../../src/shared/types.ts";
+import type { AsyncJobState, HostStepNode, WorkflowGraphSnapshot, WorkflowNodeStatus } from "../../src/shared/types.ts";
 import {
 	ASYNC_STATUS_SNAPSHOT_KIND,
 	ASYNC_STATUS_SNAPSHOT_VERSION,
@@ -15,7 +15,7 @@ function job(input: Partial<AsyncJobState> & Pick<AsyncJobState, "asyncId" | "st
 	} as AsyncJobState;
 }
 
-function hostStep(overrides: Partial<HostStepNodeV1> = {}): HostStepNodeV1 {
+function hostStep(overrides: Partial<HostStepNode> = {}): HostStepNode {
 	return {
 		version: 1,
 		kind: "host-step",
@@ -257,4 +257,4 @@ describe("async status projection", () => {
 			{ name: "writer · Second (worker)", state: "running" },
 		]);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/capability-ceiling-agent-allowlist.test.ts

@@ -11,7 +11,7 @@ import {
 	registerSubagentCapabilityCeiling,
 } from "../../src/api/capability-ceiling.ts";
 import { runSync } from "../../src/runs/foreground/execution.ts";
-import { buildPiArgs } from "../../src/runs/shared/pi-args.ts";
+import { buildInProcessChildLaunch } from "../../src/runs/shared/child-launch.ts";
 
 function agent(name: string): AgentConfig {
 	return {
@@ -84,19 +84,20 @@ describe("capability ceiling agent allowlist", () => {
 		assert.deepEqual(result.capabilityCeiling?.allowedAgents, ["reviewer"]);
 	});
 
-	it("includes allowedAgents in propagated launch env and audit metadata", () => {
-		const { env, capabilityAudit } = buildPiArgs({
-			baseArgs: [],
-			task: "Review",
+	it("includes allowedAgents in the child runtime config and audit metadata", () => {
+		const { config, capabilityAudit } = buildInProcessChildLaunch({
+			host: "parent",
+			cwd: process.cwd(),
 			sessionEnabled: false,
 			inheritProjectContext: false,
+			inheritGlobalContext: false,
 			inheritSkills: false,
 			childAgentName: "reviewer",
+			childIndex: 0,
 			capabilityCeiling: { version: 1, allowedAgents: ["reviewer"], allowedTools: ["read"], denyExtensions: true, sources: ["plan-mode"] },
 		});
 		assert.equal(capabilityAudit?.agentAllowed, true);
 		assert.deepEqual(capabilityAudit?.agentRestrictionSources, ["plan-mode"]);
-		assert.ok(env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1);
-		assert.deepEqual(decodeSubagentCapabilityCeiling(env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1)?.allowedAgents, ["reviewer"]);
+		assert.deepEqual(config.capabilityCeiling?.allowedAgents, ["reviewer"]);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/capability-ceiling.test.ts

@@ -47,22 +47,25 @@ describe("subagent capability ceiling", () => {
 		assert.throws(() => parseSubagentCapabilityCeiling({ version: 2, allowedTools: ["read"], denyExtensions: true, sources: ["plan"] }), /version/);
 	});
 
-	it("combines inherited process policy with exact-session registrations", () => {
-		const previous = process.env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1;
+	it("combines the inherited child runtime ceiling with exact-session registrations", () => {
 		const sessionId = `current-${Date.now()}-${Math.random()}`;
 		const handle = registerSubagentCapabilityCeiling({ sessionId, source: "local", ceiling: { allowedTools: ["grep", "read"] } });
 		try {
-			process.env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1 = encodeSubagentCapabilityCeiling({ version: 1, allowedTools: ["read", "write"], denyExtensions: true, sources: ["ancestor"] });
-			assert.deepEqual(resolveCurrentSubagentCapabilityCeiling(sessionId), {
+			const inherited = decodeSubagentCapabilityCeiling(encodeSubagentCapabilityCeiling({ version: 1, allowedTools: ["read", "write"], denyExtensions: true, sources: ["ancestor"] }));
+			assert.deepEqual(resolveSubagentCapabilityCeiling(sessionId, inherited), {
 				version: 1,
 				allowedTools: ["read"],
 				denyExtensions: true,
 				sources: ["ancestor", "local"],
 			});
+			assert.deepEqual(resolveCurrentSubagentCapabilityCeiling(sessionId), {
+				version: 1,
+				allowedTools: ["grep", "read"],
+				denyExtensions: false,
+				sources: ["local"],
+			});
 		} finally {
 			handle.dispose();
-			if (previous === undefined) delete process.env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1;
-			else process.env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1 = previous;
 		}
 	});
-});
+});