@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-subagents/test/unit/fork-cache-key.test.ts

@@ -1,14 +1,16 @@
 import assert from "node:assert/strict";
-import { afterEach, describe, it } from "node:test";
+import * as os from "node:os";
+import { describe, it } from "node:test";
 import type { ExtensionContext } from "@selesai/code";
-import { buildPiArgs, deriveForkPromptCacheKey, SUBAGENT_FORK_CACHE_KEY_ENV } from "../../src/runs/shared/pi-args.ts";
+import { buildInProcessChildLaunch } from "../../src/runs/shared/child-launch.ts";
+import { deriveForkPromptCacheKey } from "../../src/runs/shared/child-tool-plan.ts";
 import { rewriteForkCacheProviderRequest } from "../../src/runs/shared/subagent-prompt-runtime.ts";
 
-const originalForkCacheKey = process.env[SUBAGENT_FORK_CACHE_KEY_ENV];
-
 const baseLaunch = {
-	baseArgs: [] as string[],
-	task: "test",
+	host: "parent" as const,
+	cwd: os.tmpdir(),
+	childAgentName: "worker",
+	childIndex: 0,
 	sessionEnabled: false,
 	inheritProjectContext: false,
 	inheritGlobalContext: false,
@@ -19,11 +21,6 @@ function providerContext(api: string): Pick<ExtensionContext, "model"> {
 	return { model: { api } };
 }
 
-afterEach(() => {
-	if (originalForkCacheKey === undefined) delete process.env[SUBAGENT_FORK_CACHE_KEY_ENV];
-	else process.env[SUBAGENT_FORK_CACHE_KEY_ENV] = originalForkCacheKey;
-});
-
 describe("fork prompt cache keys", () => {
 	it("derives a bounded sibling cache key from the parent session id", () => {
 		assert.equal(deriveForkPromptCacheKey(undefined), undefined);
@@ -43,17 +40,15 @@ describe("fork prompt cache keys", () => {
 		assert.notEqual(deriveForkPromptCacheKey(`${prefix}/one.jsonl`), deriveForkPromptCacheKey(`${prefix}/two.jsonl`));
 	});
 
-	it("passes the explicit fork cache key without inheriting ambient values", () => {
-		process.env[SUBAGENT_FORK_CACHE_KEY_ENV] = "leaked-parent-value";
-
-		assert.equal(buildPiArgs(baseLaunch).env[SUBAGENT_FORK_CACHE_KEY_ENV], undefined);
+	it("passes only the explicit fork cache key to the child config", () => {
+		assert.equal(buildInProcessChildLaunch(baseLaunch).config.forkCacheKey, undefined);
 
 		const forkCacheKey = deriveForkPromptCacheKey("parent-session");
-		assert.equal(buildPiArgs({ ...baseLaunch, forkCacheKey }).env[SUBAGENT_FORK_CACHE_KEY_ENV], forkCacheKey);
+		assert.equal(buildInProcessChildLaunch({ ...baseLaunch, forkCacheKey }).config.forkCacheKey, forkCacheKey);
 	});
 
 	it("rewrites only existing OpenAI-style string prompt cache keys", () => {
-		process.env[SUBAGENT_FORK_CACHE_KEY_ENV] = "pi-fork:parent-session";
+		const forkCacheKey = "pi-fork:parent-session";
 		const payload = {
 			model: "test-model",
 			input: [{ role: "user", content: "hello" }],
@@ -61,31 +56,30 @@ describe("fork prompt cache keys", () => {
 		};
 
 		assert.deepEqual(
-			rewriteForkCacheProviderRequest({ type: "before_provider_request", payload }, providerContext("openai-responses")),
+			rewriteForkCacheProviderRequest({ type: "before_provider_request", payload }, providerContext("openai-responses"), forkCacheKey),
 			{ ...payload, prompt_cache_key: "pi-fork:parent-session" },
 		);
 		assert.deepEqual(
-			rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { ...payload, prompt_cache_key: "pi-fork:parent-session" } }, providerContext("openai-responses")),
+			rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { ...payload, prompt_cache_key: "pi-fork:parent-session" } }, providerContext("openai-responses"), forkCacheKey),
 			{ ...payload, prompt_cache_key: "pi-fork:parent-session" },
 		);
 	});
 
 	it("does not add prompt cache keys or touch non-OpenAI payloads", () => {
-		process.env[SUBAGENT_FORK_CACHE_KEY_ENV] = "pi-fork:parent-session";
+		const forkCacheKey = "pi-fork:parent-session";
 
-		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: "raw" }, providerContext("openai-responses")), undefined);
-		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: [] }, providerContext("openai-responses")), undefined);
-		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { model: "test" } }, providerContext("openai-responses")), undefined);
-		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { model: "test", prompt_cache_key: undefined } }, providerContext("openai-responses")), undefined);
-		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { model: "test", prompt_cache_key: "child" } }, providerContext("anthropic-messages")), undefined);
-		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { model: "test", prompt_cache_key: "child" } }, providerContext("unknown-api")), undefined);
+		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: "raw" }, providerContext("openai-responses"), forkCacheKey), undefined);
+		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: [] }, providerContext("openai-responses"), forkCacheKey), undefined);
+		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { model: "test" } }, providerContext("openai-responses"), forkCacheKey), undefined);
+		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { model: "test", prompt_cache_key: undefined } }, providerContext("openai-responses"), forkCacheKey), undefined);
+		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { model: "test", prompt_cache_key: "child" } }, providerContext("anthropic-messages"), forkCacheKey), undefined);
+		assert.equal(rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { model: "test", prompt_cache_key: "child" } }, providerContext("unknown-api"), forkCacheKey), undefined);
 	});
 
 	it("is a no-op when fork cache affinity is not configured", () => {
-		delete process.env[SUBAGENT_FORK_CACHE_KEY_ENV];
 		assert.equal(
-			rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { model: "test", prompt_cache_key: "child" } }, providerContext("openai-responses")),
+			rewriteForkCacheProviderRequest({ type: "before_provider_request", payload: { model: "test", prompt_cache_key: "child" } }, providerContext("openai-responses"), undefined),
 			undefined,
 		);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/host-peer-runtime-imports.test.ts

@@ -4,6 +4,8 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import test from "node:test";
+import { HOST_PEER_ALIASES, resolveHostPeerAliases } from "../../src/runs/background/runner-aliases.ts";
+import { resolveInstalledPiPackageRoot } from "../../src/runs/shared/pi-spawn.ts";
 import { resolveCompileFromPackageRoot, validateStructuredOutputValue } from "../../src/runs/shared/structured-output.ts";
 import type { JsonSchemaObject } from "../../src/shared/types.ts";
 
@@ -59,11 +61,12 @@ function resolveRelativeImport(fromFile: string, specifier: string): string | un
 	return candidates.find((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile());
 }
 
-test("detached async runner's runtime import graph never reaches a host peer package (issues #334, #526)", () => {
+test("every host peer package the detached async runner imports is aliased to the installed pi package (issues #334, #526)", () => {
 	const entryPoint = path.join(projectRoot, "src", "runs", "background", "subagent-runner.ts");
 	const visited = new Set<string>([entryPoint]);
 	const queue: string[] = [entryPoint];
 	const violations: string[] = [];
+	const aliased = new Set(HOST_PEER_ALIASES.map((entry) => entry.specifier));
 
 	while (queue.length > 0) {
 		const file = queue.shift()!;
@@ -71,7 +74,7 @@ test("detached async runner's runtime import graph never reaches a host peer pac
 		for (const specifier of extractStaticImportSpecifiers(source)) {
 			const hostPeerMatch = matchingHostPeerPackage(specifier);
 			if (hostPeerMatch) {
-				violations.push(`${path.relative(projectRoot, file)} has a runtime import of '${specifier}' (host peer package '${hostPeerMatch}')`);
+				if (!aliased.has(specifier)) violations.push(`${path.relative(projectRoot, file)} imports '${specifier}' (host peer package '${hostPeerMatch}'), which has no runner alias`);
 				continue;
 			}
 			if (!specifier.startsWith(".")) continue;
@@ -86,8 +89,39 @@ test("detached async runner's runtime import graph never reaches a host peer pac
 		}
 	}
 
-	assert.equal(violations.length, 0, `runtime import graph reached host peer package(s):\n${violations.join("\n")}`);
+	assert.equal(violations.length, 0, `runtime import graph reaches host peer package(s) the runner does not alias:\n${violations.join("\n")}`);
 	assert.ok(visited.size > 20, `expected a non-trivial reachable file set (a broken resolver could undercount it), got ${visited.size}`);
+	const packageRoot = resolveInstalledPiPackageRoot();
+	assert.ok(packageRoot, "expected the pi package (or its test shim) to be resolvable");
+	const resolved = resolveHostPeerAliases(packageRoot);
+	assert.deepEqual(resolved.missing, []);
+	for (const specifier of aliased) assert.ok(fs.existsSync(resolved.aliases[specifier]!), `alias target for ${specifier} exists`);
+});
+
+test("resolves pi-agent-core/node to its exact package export instead of appending to the root alias", () => {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-agent-core-node-alias-"));
+	const packageDir = path.join(root, "node_modules", "@earendil-works", "pi-agent-core");
+	const distDir = path.join(packageDir, "dist");
+	try {
+		fs.mkdirSync(distDir, { recursive: true });
+		fs.writeFileSync(path.join(packageDir, "package.json"), JSON.stringify({
+			name: "@earendil-works/pi-agent-core",
+			version: "0.85.0-test",
+			exports: {
+				".": "./dist/index.js",
+				"./node": "./dist/node.js",
+			},
+		}), "utf-8");
+		fs.writeFileSync(path.join(distDir, "index.js"), "export {};\n", "utf-8");
+		fs.writeFileSync(path.join(distDir, "node.js"), "export {};\n", "utf-8");
+
+		const resolved = resolveHostPeerAliases(root);
+		assert.equal(resolved.aliases["@earendil-works/pi-agent-core"], path.join(distDir, "index.js"));
+		assert.equal(resolved.aliases["@earendil-works/pi-agent-core/node"], path.join(distDir, "node.js"));
+		assert.notEqual(resolved.aliases["@earendil-works/pi-agent-core/node"], path.join(distDir, "index.js", "node"));
+	} finally {
+		fs.rmSync(root, { recursive: true, force: true });
+	}
 });
 
 function writeFakeTypeboxPackage(typeboxDir: string): void {
@@ -154,4 +188,62 @@ test("validateStructuredOutputValue validates values against a JSON Schema", asy
 	const invalid = await validateStructuredOutputValue(schema, {});
 	assert.equal(invalid.status, "invalid");
 	assert.ok(invalid.status === "invalid" && invalid.message.length > 0);
-});
+});
+
+test("server supplementation is host-first, missing-only, and restricted to matching 0.85.0", () => {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-server-alias-"));
+	const host = path.join(root, "host");
+	const extension = path.join(root, "extension");
+	const server = "@earendil-works/pi-server";
+	function writePackage(dir: string, name: string, version: string, exports: Record<string, string> = {}) {
+		fs.mkdirSync(dir, { recursive: true });
+		fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ name, version, exports }));
+		for (const target of Object.values(exports)) fs.writeFileSync(path.join(dir, target), "export {};\n");
+	}
+	const localServer = path.join(extension, "node_modules", server);
+	const hostServer = path.join(host, "node_modules", server);
+	const exports = { ".": "./public.mjs", "./unix": "./unix.mjs" };
+	try {
+		writePackage(host, "@selesai/code", "0.85.0", { ".": "./sdk.mjs" });
+		writePackage(localServer, server, "0.85.0", exports);
+		writePackage(path.join(extension, "node_modules", "@earendil-works/pi-tui"), "@earendil-works/pi-tui", "0.85.0", exports);
+		let result = resolveHostPeerAliases(host, extension);
+		assert.deepEqual(result.supplemental, [server, `${server}/unix`]);
+		assert.equal(result.aliases[server], path.join(localServer, "public.mjs"));
+		assert.ok(result.missing.includes("@earendil-works/pi-tui"), "other missing peers stay closed");
+
+		writePackage(hostServer, server, "0.85.0", { ".": "./host.mjs" });
+		result = resolveHostPeerAliases(host, extension);
+		assert.equal(result.aliases[server], path.join(hostServer, "host.mjs"));
+		assert.deepEqual(result.supplemental, [`${server}/unix`]);
+		writePackage(hostServer, server, "0.86.0", { ".": "./host.mjs" });
+		assert.ok(resolveHostPeerAliases(host, extension).missing.includes(`${server}/unix`));
+		fs.rmSync(hostServer, { recursive: true });
+
+		for (const version of ["0.84.0", "0.85.1", "0.85.0-test"]) {
+			writePackage(host, "@selesai/code", version, { ".": "./sdk.mjs" });
+			result = resolveHostPeerAliases(host, extension);
+			assert.deepEqual(result.supplemental, []);
+			for (const specifier of [server, `${server}/unix`, "@earendil-works/pi-client/unix"]) {
+				assert.ok(!result.missing.includes(specifier));
+				assert.equal(result.aliases[specifier], undefined);
+			}
+			assert.ok(result.missing.includes("@earendil-works/pi-agent-core/node"));
+		}
+		writePackage(host, "@selesai/code", "0.85.0", { ".": "./sdk.mjs" });
+		writePackage(localServer, server, "0.85.1", exports);
+		assert.deepEqual(resolveHostPeerAliases(host, extension).supplemental, []);
+		writePackage(localServer, server, "0.85.0", exports);
+		fs.unlinkSync(path.join(localServer, "unix.mjs"));
+		assert.ok(resolveHostPeerAliases(host, extension).missing.includes(`${server}/unix`));
+
+		// Non-exception hosts ignore experimental packages even when installed.
+		writePackage(host, "@selesai/code", "0.86.0", { ".": "./sdk.mjs" });
+		writePackage(hostServer, server, "0.86.0", exports);
+		result = resolveHostPeerAliases(host, extension);
+		assert.deepEqual(result.supplemental, []);
+		assert.equal(result.aliases[`${server}/unix`], undefined);
+	} finally {
+		fs.rmSync(root, { recursive: true, force: true });
+	}
+});

package/dist/extensions/pi-subagents/test/unit/host-step-status.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import type { AsyncStatus, HostStepNodeV1 } from "../../src/shared/types.ts";
+import type { AsyncStatus, HostStepNode } from "../../src/shared/types.ts";
 import {
 	HOST_STEP_MAX_LABEL_CHARS,
 	assertHostStepNode,
@@ -12,7 +12,7 @@ import {
 	validHostStepNodes,
 } from "../../src/runs/shared/host-step-status.ts";
 
-function hostStep(overrides: Partial<HostStepNodeV1> = {}): HostStepNodeV1 {
+function hostStep(overrides: Partial<HostStepNode> = {}): HostStepNode {
 	return {
 		version: 1,
 		kind: "host-step",
@@ -43,7 +43,7 @@ describe("host step status", () => {
 	it("rejects unbounded or incomplete terminal data", () => {
 		assert.throws(() => assertHostStepNode(hostStep({ label: "x".repeat(HOST_STEP_MAX_LABEL_CHARS + 1) }), "fixture"), /label exceeds/);
 		assert.throws(() => assertHostStepNode(hostStep({ state: "running", verdict: "pass" }), "fixture"), /verdict is only valid/);
-		assert.throws(() => assertHostStepNode(hostStep({ state: "done", verdict: "inconclusive", freshness: {} as HostStepNodeV1["freshness"] }), "fixture"), /expected/);
+		assert.throws(() => assertHostStepNode(hostStep({ state: "done", verdict: "inconclusive", freshness: {} as HostStepNode["freshness"] }), "fixture"), /expected/);
 		assert.throws(() => assertHostStepNode(hostStep({ state: "done", verdict: "pass", freshness: { expectedRef: "head", stale: true } }), "fixture"), /stale freshness/);
 		assert.throws(() => assertHostStepNode(hostStep({ exitCode: 1 }), "fixture"), /only valid for command/);
 		assert.throws(() => assertHostStepNode(hostStep({ monitorKind: "command", exitCode: 1 }), "fixture"), /only valid after command settlement/);
@@ -95,4 +95,4 @@ describe("host step status", () => {
 		assert.deepEqual(validHostStepNodes(graph), []);
 		assert.throws(() => assertWorkflowGraphHostSteps(graph, "status", "workflow-1"), /duplicate host step id/);
 	});
-});
+});