@selesai/code 0.13.39 → 0.14.0

package/dist/extensions/pi-subagents/test/unit/herdr-status-bridge.test.ts

@@ -2,11 +2,13 @@ import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 
 import {
+	HERDR_FOREGROUND_CONTROL_CHANGED_EVENT,
 	registerHerdrStatusBridge,
 	type HerdrStatusBridgeEvents,
 	type HerdrStatusRun,
 } from "../../src/integrations/herdr-status.ts";
 import { projectActiveHerdrRuns } from "../../src/extension/index.ts";
+import { beginForegroundChild, finishForegroundChild } from "../../src/runs/foreground/foreground-control.ts";
 import type { SubagentState } from "../../src/shared/types.ts";
 import {
 	SUBAGENT_ASYNC_COMPLETE_EVENT,
@@ -103,12 +105,106 @@ describe("Herdr status bridge", () => {
 
 		assert.deepEqual(projectActiveHerdrRuns(state), [{
 			id: "workflow-1",
+			coordinator: true,
 			agents: ["reviewer"],
 			taskLabel: "Review auth",
 			needsAttention: true,
 		}]);
 	});
 
+	it("counts a workflow async child once instead of also counting the coordinator", () => {
+		const state = stateForTest();
+		state.asyncJobs.set("workflow-1", {
+			asyncId: "workflow-1",
+			asyncDir: "/tmp/workflow-1",
+			status: "running",
+			mode: "workflow",
+			agents: ["workflow"],
+			steps: [],
+		});
+		state.asyncJobs.set("child-1", {
+			asyncId: "child-1",
+			asyncDir: "/tmp/child-1",
+			status: "running",
+			mode: "single",
+			agents: ["reviewer"],
+			parentWorkflowRunId: "workflow-1",
+		});
+
+		assert.deepEqual(projectActiveHerdrRuns(state), [
+			{ id: "workflow-1", coordinator: true, agents: [], needsAttention: false },
+			{ id: "child-1", agents: ["reviewer"], needsAttention: false },
+		]);
+	});
+
+	it("publishes foreground workflow child start and finish without the periodic refresh", async () => {
+		// Covers the bridge subscription only; the event is emitted by hand here.
+		const state = stateForTest();
+		state.asyncJobs.set("workflow-1", {
+			asyncId: "workflow-1", asyncDir: "/tmp/workflow-1", status: "running",
+			mode: "workflow", agents: ["workflow"],
+		});
+		const events = new FakeEvents();
+		const commands: string[][] = [];
+		const bridge = registerHerdrStatusBridge({
+			events,
+			env: { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1" },
+			getRuns: () => projectActiveHerdrRuns(state),
+			runHerdr: (args) => commands.push([...args]),
+			refreshMs: 0,
+		});
+		bridge.sessionStarted({ hasUI: true, runs: projectActiveHerdrRuns(state) });
+		await bridge.flush();
+		assert.ok(commands.at(-1)?.includes("summary=⏳ 0 subagents"));
+
+		state.foregroundControls.set("child-1", {
+			runId: "child-1", parentWorkflowRunId: "workflow-1", mode: "single",
+			startedAt: 10, updatedAt: 10,
+		});
+		const control = state.foregroundControls.get("child-1")!;
+		beginForegroundChild(control, { index: 0, agent: "reviewer", authoredTask: "review", effectivePrompt: "review", interrupt: () => true });
+		events.emit(HERDR_FOREGROUND_CONTROL_CHANGED_EVENT, { runId: "workflow-1" });
+		await bridge.flush();
+		assert.ok(commands.at(-1)?.includes("summary=⏳ 1 subagent (reviewer)"));
+
+		finishForegroundChild(control, 0);
+		events.emit(HERDR_FOREGROUND_CONTROL_CHANGED_EVENT, { runId: "workflow-1" });
+		await bridge.flush();
+		assert.ok(commands.at(-1)?.includes("summary=⏳ 0 subagents"));
+		bridge.dispose();
+	});
+
+	it("keeps child IDs live for attention and completion after a workflow refresh", async () => {
+		const events = new FakeEvents();
+		const commands: string[][] = [];
+		const coordinator = { id: "workflow-1", coordinator: true as const, agents: [] };
+		const child = { id: "child-1", agents: ["reviewer"] };
+		let authoritativeRuns: HerdrStatusRun[] = [coordinator];
+		const bridge = registerHerdrStatusBridge({
+			events,
+			env: { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1" },
+			getRuns: () => authoritativeRuns,
+			runHerdr: (args) => commands.push([...args]),
+			refreshMs: 0,
+		});
+		bridge.sessionStarted({ hasUI: true, runs: [coordinator] });
+		authoritativeRuns = [coordinator, child];
+		bridge.syncRuns();
+		await bridge.flush();
+		assert.ok(commands.at(-1)?.includes("summary=⏳ 1 subagent (reviewer)"));
+		events.emit(SUBAGENT_CONTROL_EVENT, {
+			source: "async", noticeText: "reviewer needs attention",
+			event: { type: "needs_attention", runId: "child-1" },
+		});
+		await bridge.flush();
+		assert.ok(commands.at(-1)?.includes("summary=⏳ 1 subagent (reviewer) ⚠"));
+		events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, { runId: "child-1" });
+		authoritativeRuns = [coordinator];
+		await bridge.flush();
+		assert.ok(commands.at(-1)?.includes("summary=⏳ 0 subagents"));
+		bridge.dispose();
+	});
+
 	it("synchronizes runs discovered outside lifecycle events", async () => {
 		const events = new FakeEvents();
 		const commands: string[][] = [];
@@ -130,6 +226,36 @@ describe("Herdr status bridge", () => {
 		bridge.dispose();
 	});
 
+	it("does not count the workflow coordinator's own start event as a running leaf", async () => {
+		const events = new FakeEvents();
+		const commands: string[][] = [];
+		const busyEvents: unknown[] = [];
+		events.on("herdr:busy", (payload) => busyEvents.push(payload));
+		const bridge = registerHerdrStatusBridge({
+			events,
+			env: { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1" },
+			runHerdr: (args) => commands.push([...args]),
+			refreshMs: 0,
+		});
+		bridge.sessionStarted({ hasUI: true, runs: [] });
+
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "workflow-1", mode: "workflow", agent: "workflow" });
+		await bridge.flush();
+
+		// The coordinator is active (busy stays raised) but contributes zero leaves.
+		assert.deepEqual(busyEvents, [{ active: true, label: "⏳ 0 subagents" }]);
+		assert.ok(commands[0]?.includes("summary=⏳ 0 subagents"));
+		assert.ok(!commands[0]?.join(" ").includes("workflow"));
+
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "child-1", agent: "reviewer" });
+		await bridge.flush();
+
+		assert.deepEqual(busyEvents.at(-1), { active: true, label: "⏳ 1 subagent (reviewer)" });
+		assert.ok(commands[1]?.includes("summary=⏳ 1 subagent (reviewer)"));
+
+		bridge.dispose();
+	});
+
 	it("reports an async run as visible and semantically busy", async () => {
 		const events = new FakeEvents();
 		const commands: string[][] = [];
@@ -218,27 +344,47 @@ describe("Herdr status bridge", () => {
 		bridge.dispose();
 	});
 
-	it("marks an async run blocked until the parent agent wakes", () => {
+	it("never raises Herdr's human-blocked state for child attention", async () => {
 		const events = new FakeEvents();
+		const commands: string[][] = [];
 		const blockedEvents: unknown[] = [];
 		events.on("herdr:blocked", (payload) => blockedEvents.push(payload));
 		const bridge = registerHerdrStatusBridge({
 			events,
 			env: { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1" },
-			runHerdr: () => {},
+			runHerdr: (args) => commands.push([...args]),
 			refreshMs: 0,
 		});
-		bridge.sessionStarted({ hasUI: true, runs: [] });
+		bridge.sessionStarted({ hasUI: true, runs: [{ id: "run-restored", agent: "reviewer", needsAttention: true }] });
+		await bridge.flush();
+		assert.ok(commands.at(-1)?.includes("summary=⏳ 1 subagent (reviewer) ⚠"));
 
+		bridge.agentStarted();
 		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "worker" });
 		events.emit(SUBAGENT_CONTROL_EVENT, {
 			source: "async",
-			noticeText: "worker needs attention",
-			event: {
-				type: "needs_attention",
-				runId: "run-1",
-			},
+			noticeText: "Worker is waiting for a supervisor reply",
+			event: { type: "needs_attention", runId: "run-1", reason: "supervisor_request" },
 		});
+		await bridge.flush();
+		assert.ok(commands.at(-1)?.includes("summary=⏳ 2 subagents (reviewer, worker) ⚠"));
+		assert.deepEqual(blockedEvents, []);
+
+		bridge.dispose();
+	});
+
+	it("marks attention in the label until the parent agent wakes", async () => {
+		const events = new FakeEvents();
+		const commands: string[][] = [];
+		const bridge = registerHerdrStatusBridge({
+			events,
+			env: { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1" },
+			runHerdr: (args) => commands.push([...args]),
+			refreshMs: 0,
+		});
+		bridge.sessionStarted({ hasUI: true, runs: [] });
+
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "worker" });
 		events.emit(SUBAGENT_CONTROL_EVENT, {
 			source: "async",
 			event: { type: "active_long_running", runId: "run-1" },
@@ -247,34 +393,37 @@ describe("Herdr status bridge", () => {
 			source: "foreground",
 			event: { type: "needs_attention", runId: "run-1" },
 		});
+		await bridge.flush();
+		assert.ok(commands.at(-1)?.includes("summary=⏳ 1 subagent (worker)"));
+		events.emit(SUBAGENT_CONTROL_EVENT, {
+			source: "async",
+			event: { type: "needs_attention", runId: "run-1" },
+		});
+		await bridge.flush();
+		assert.ok(commands.at(-1)?.includes("summary=⏳ 1 subagent (worker) ⚠"));
 		bridge.agentStarted();
-
-		assert.deepEqual(blockedEvents, [
-			{ active: true, label: "worker needs attention" },
-			{ active: false },
-		]);
+		await bridge.flush();
+		assert.ok(commands.at(-1)?.includes("summary=⏳ 1 subagent (worker)"));
 
 		bridge.dispose();
 	});
 
 	it("does not resurrect acknowledged attention during TTL reconciliation", async () => {
 		const events = new FakeEvents();
-		const blockedEvents: unknown[] = [];
+		const commands: string[][] = [];
 		const intervals = new FakeIntervals();
 		let authoritativeRuns = [{ id: "run-1", agent: "worker", needsAttention: false }];
-		events.on("herdr:blocked", (payload) => blockedEvents.push(payload));
 		const bridge = registerHerdrStatusBridge({
 			events,
 			env: { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1" },
 			getRuns: () => authoritativeRuns,
-			runHerdr: () => {},
+			runHerdr: (args) => commands.push([...args]),
 			refreshMs: 45_000,
 			timers: intervals.timers,
 		});
 		bridge.sessionStarted({ hasUI: true, runs: authoritativeRuns });
 		events.emit(SUBAGENT_CONTROL_EVENT, {
 			source: "async",
-			noticeText: "worker needs attention",
 			event: { type: "needs_attention", runId: "run-1" },
 		});
 		authoritativeRuns = [{ id: "run-1", agent: "worker", needsAttention: true }];
@@ -282,88 +431,42 @@ describe("Herdr status bridge", () => {
 
 		intervals.fireAll();
 		await bridge.flush();
-		assert.deepEqual(blockedEvents, [
-			{ active: true, label: "worker needs attention" },
-			{ active: false },
-		]);
+		assert.ok(commands.at(-1)?.includes("summary=⏳ 1 subagent (worker)"));
 
-		// A new explicit control event is a new attention transition and may
-		// raise the overlay again even if the tracker flag never dropped.
+		// A new explicit control event is a new attention transition even if
+		// the tracker flag never dropped.
 		events.emit(SUBAGENT_CONTROL_EVENT, {
 			source: "async",
-			noticeText: "worker still needs attention",
 			event: { type: "needs_attention", runId: "run-1" },
 		});
-		assert.deepEqual(blockedEvents.at(-1), {
-			active: true,
-			label: "worker still needs attention",
-		});
-
-		bridge.dispose();
-	});
-
-	it("releases blocked state when the affected run completes", () => {
-		const events = new FakeEvents();
-		const blockedEvents: unknown[] = [];
-		events.on("herdr:blocked", (payload) => blockedEvents.push(payload));
-		const bridge = registerHerdrStatusBridge({
-			events,
-			env: { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1" },
-			runHerdr: () => {},
-			refreshMs: 0,
-		});
-		bridge.sessionStarted({ hasUI: true, runs: [] });
-
-		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "worker" });
-		events.emit(SUBAGENT_CONTROL_EVENT, {
-			source: "async",
-			event: { type: "needs_attention", runId: "run-1", message: "stuck" },
-		});
-		events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, { runId: "run-1" });
-
-		assert.deepEqual(blockedEvents, [
-			{ active: true, label: "stuck" },
-			{ active: false },
-		]);
+		await bridge.flush();
+		assert.ok(commands.at(-1)?.includes("summary=⏳ 1 subagent (worker) ⚠"));
 
 		bridge.dispose();
 	});
 
-	it("keeps one accurate blocked overlay while multiple runs need attention", () => {
+	it("keeps the attention mark while any run still needs attention", async () => {
 		const events = new FakeEvents();
-		const blockedEvents: unknown[] = [];
-		events.on("herdr:blocked", (payload) => blockedEvents.push(payload));
+		const commands: string[][] = [];
 		const bridge = registerHerdrStatusBridge({
 			events,
 			env: { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1" },
-			runHerdr: () => {},
+			runHerdr: (args) => commands.push([...args]),
 			refreshMs: 0,
 		});
 		bridge.sessionStarted({ hasUI: true, runs: [] });
 		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "worker" });
 		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-2", agent: "reviewer" });
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-3", agent: "scout" });
 
-		events.emit(SUBAGENT_CONTROL_EVENT, {
-			source: "async",
-			noticeText: "worker needs attention",
-			event: { type: "needs_attention", runId: "run-1" },
-		});
-		events.emit(SUBAGENT_CONTROL_EVENT, {
-			source: "async",
-			noticeText: "reviewer needs attention",
-			event: { type: "needs_attention", runId: "run-2" },
-		});
+		events.emit(SUBAGENT_CONTROL_EVENT, { source: "async", event: { type: "needs_attention", runId: "run-1" } });
+		events.emit(SUBAGENT_CONTROL_EVENT, { source: "async", event: { type: "needs_attention", runId: "run-2" } });
 		events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, { runId: "run-2" });
+		await bridge.flush();
+		assert.ok(commands.at(-1)?.includes("summary=⏳ 2 subagents (worker, scout) ⚠"));
 		events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, { runId: "run-1" });
-
-		assert.deepEqual(blockedEvents, [
-			{ active: true, label: "worker needs attention" },
-			{ active: false },
-			{ active: true, label: "reviewer needs attention" },
-			{ active: false },
-			{ active: true, label: "worker needs attention" },
-			{ active: false },
-		]);
+		await bridge.flush();
+		assert.ok(commands.at(-1)?.includes("summary=⏳ 1 subagent (scout)"));
 
 		bridge.dispose();
 	});
@@ -372,9 +475,7 @@ describe("Herdr status bridge", () => {
 		const events = new FakeEvents();
 		const commands: string[][] = [];
 		const busyEvents: unknown[] = [];
-		const blockedEvents: unknown[] = [];
 		events.on("herdr:busy", (payload) => busyEvents.push(payload));
-		events.on("herdr:blocked", (payload) => blockedEvents.push(payload));
 		const bridge = registerHerdrStatusBridge({
 			events,
 			env: { HERDR_ENV: "1", HERDR_PANE_ID: "w1:p1" },
@@ -388,7 +489,6 @@ describe("Herdr status bridge", () => {
 				id: "run-restored",
 				agents: ["worker", "reviewer"],
 				needsAttention: true,
-				attentionLabel: "reviewer needs attention",
 			}],
 		});
 		await bridge.flush();
@@ -397,17 +497,12 @@ describe("Herdr status bridge", () => {
 			active: true,
 			label: "⏳ 2 subagents (worker, reviewer)",
 		}]);
-		assert.deepEqual(blockedEvents, [{
-			active: true,
-			label: "reviewer needs attention",
-		}]);
 		assert.ok(commands[0]?.includes("summary=⏳ 2 subagents (worker, reviewer) ⚠"));
 
 		bridge.dispose();
 		await bridge.flush();
 
 		assert.deepEqual(busyEvents.at(-1), { active: false });
-		assert.deepEqual(blockedEvents.at(-1), { active: false });
 		assert.ok(commands.at(-1)?.includes("--clear-state-labels"));
 	});
 
@@ -713,4 +808,4 @@ describe("Herdr status bridge", () => {
 		assert.deepEqual(commands, []);
 		assert.equal(getRunsCalls, 0);
 	});
-});
+});

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

@@ -95,7 +95,12 @@ test("every host peer package the detached async runner imports is aliased to th
 	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`);
+	// Optional subpaths (pi-agent-core/node, removed in Pi 1.0) are skipped when the host does not declare them.
+	const optional = new Set(HOST_PEER_ALIASES.filter((entry) => entry.optional).map((entry) => entry.specifier));
+	for (const specifier of aliased) {
+		if (optional.has(specifier) && resolved.aliases[specifier] === undefined) continue;
+		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", () => {
@@ -106,7 +111,7 @@ test("resolves pi-agent-core/node to its exact package export instead of appendi
 		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",
+			version: "0.85.1-test",
 			exports: {
 				".": "./dist/index.js",
 				"./node": "./dist/node.js",
@@ -116,8 +121,8 @@ test("resolves pi-agent-core/node to its exact package export instead of appendi
 		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.equal(resolved.aliases["@earendil-works/pi-agent-core"], fs.realpathSync(path.join(distDir, "index.js")));
+		assert.equal(resolved.aliases["@earendil-works/pi-agent-core/node"], fs.realpathSync(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 });
@@ -190,59 +195,73 @@ test("validateStructuredOutputValue validates values against a JSON Schema", asy
 	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-"));
+test("chord is omitted before 0.85, but required host-first on chord-era and unknown hosts (#2026)", () => {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-chord-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> = {}) {
+	const chord = "@earendil-works/chord";
+	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" };
+	const hostChord = path.join(host, "node_modules", chord);
 	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"));
+		const packages = new Map<string, Record<string, string>>();
+		for (const { pkg, subpath } of HOST_PEER_ALIASES) {
+			const exports = packages.get(pkg) ?? {};
+			exports[subpath] = `./${subpath.replaceAll("/", "-")}.mjs`;
+			packages.set(pkg, exports);
+		}
+		for (const [pkg, exports] of packages) {
+			writePackage(pkg === "@selesai/code" ? host : path.join(host, "node_modules", pkg), pkg, "0.84.3", exports);
 		}
-		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);
+		const hostExports = packages.get("@selesai/code")!;
+		const preChord = resolveHostPeerAliases(host);
+		assert.deepEqual(preChord.missing, []);
+		assert.equal(preChord.aliases[chord], undefined);
+		assert.equal(preChord.aliases[`${chord}/context`], undefined);
+		// An extension-local copy must never satisfy a missing host chord export.
+		writePackage(path.join(extension, "node_modules", chord), chord, "0.85.1", { ".": "./index.mjs", "./context": "./context.mjs" });
+		for (const version of ["0.85.0", "0.85.1", "1.0.0", "0.84.4-test", "unknown"]) {
+			writePackage(host, "@selesai/code", version, hostExports);
+			const result = resolveHostPeerAliases(host);
+			for (const specifier of [chord, `${chord}/context`]) assert.ok(result.missing.includes(specifier), version);
+		}
+		writePackage(host, "@selesai/code", "0.85.1", hostExports);
+		writePackage(hostChord, chord, "0.85.1", { ".": "./index.mjs", "./context": "./context.mjs" });
+		let result = resolveHostPeerAliases(host);
+		assert.deepEqual(result.missing, []);
+		assert.equal(result.aliases[chord], fs.realpathSync(path.join(hostChord, "index.mjs")));
+		assert.equal(result.aliases[`${chord}/context`], fs.realpathSync(path.join(hostChord, "context.mjs")));
+		fs.unlinkSync(path.join(hostChord, "context.mjs"));
+		assert.deepEqual(resolveHostPeerAliases(host).missing, [`${chord}/context`]);
+		writePackage(host, "@selesai/code", "0.84.3", hostExports);
+		fs.rmSync(path.join(host, "node_modules", "@earendil-works/pi-tui"), { recursive: true });
+		result = resolveHostPeerAliases(host);
+		assert.deepEqual(result.missing, ["@earendil-works/pi-tui"], "pre-chord hosts still require TUI");
+	} finally {
+		fs.rmSync(root, { recursive: true, force: true });
+	}
+});
+
+test("skips the pi-agent-core/node alias when the host package declares no ./node export", () => {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-agent-core-no-node-"));
+	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: "1.0.0",
+			exports: { ".": { types: "./dist/index.d.ts", import: "./dist/index.js" }, "./package.json": "./package.json" },
+		}), "utf-8");
+		fs.writeFileSync(path.join(distDir, "index.js"), "export {};\n", "utf-8");
+
+		const resolved = resolveHostPeerAliases(root);
+		assert.equal(resolved.aliases["@earendil-works/pi-agent-core"], fs.realpathSync(path.join(distDir, "index.js")));
+		assert.equal(resolved.aliases["@earendil-works/pi-agent-core/node"], undefined);
+		assert.ok(!resolved.missing.includes("@earendil-works/pi-agent-core/node"));
 	} finally {
 		fs.rmSync(root, { recursive: true, force: true });
 	}