@selesai/code 0.5.20 → 0.5.21

package/dist/extensions/pi-subagents/test/unit/notify.test.ts

@@ -5,13 +5,30 @@ import registerSubagentNotify, {
 	buildCompletionDetails,
 	formatGroupedCompletion,
 	formatSingleCompletion,
+	parseSubagentNotifyContent,
 	type RegisterSubagentNotifyOptions,
 	type SubagentNotifyDetails,
 } from "../../src/runs/background/notify.ts";
-import { SUBAGENT_ASYNC_COMPLETE_EVENT } from "../../src/shared/types.ts";
+import { SUBAGENT_ASYNC_COMPLETE_EVENT, SUBAGENT_FOREGROUND_COMPLETE_EVENT } from "../../src/shared/types.ts";
+
+function createEventBus() {
+	const emitter = new EventEmitter();
+	return {
+		on(event: string, listener: (...args: unknown[]) => void) {
+			emitter.on(event, listener);
+			return () => emitter.off(event, listener);
+		},
+		emit(event: string, ...args: unknown[]) {
+			return emitter.emit(event, ...args);
+		},
+		listenerCount(event: string) {
+			return emitter.listenerCount(event);
+		},
+	};
+}
 
 function createPi(currentSessionId = "session-1", registerOptions: RegisterSubagentNotifyOptions = {}) {
-	const events = new EventEmitter();
+	const events = createEventBus();
 	const sent: Array<{ message: unknown; options: unknown }> = [];
 	const pi = {
 		events,
@@ -22,13 +39,13 @@ function createPi(currentSessionId = "session-1", registerOptions: RegisterSubag
 
 	// Formatting-focused tests run with batching disabled so single completions
 	// emit synchronously. Batching behavior is covered by the dedicated suite below.
-	registerSubagentNotify(pi as never, { currentSessionId }, { batchConfig: { enabled: false }, ...registerOptions });
+	const notifier = registerSubagentNotify(pi as never, { currentSessionId }, { batchConfig: { enabled: false }, ...registerOptions });
 
-	return { events, sent };
+	return { events, sent, notifier, dispose: () => notifier.dispose() };
 }
 
 function createBatchingPi(clock: ReturnType<typeof createFakeClock>, currentSessionId = "session-a") {
-	const events = new EventEmitter();
+	const events = createEventBus();
 	const sent: Array<{ message: unknown; options: unknown }> = [];
 	const pi = {
 		events,
@@ -36,12 +53,12 @@ function createBatchingPi(clock: ReturnType<typeof createFakeClock>, currentSess
 			sent.push({ message, options });
 		},
 	};
-	registerSubagentNotify(pi as never, { currentSessionId }, {
+	const notifier = registerSubagentNotify(pi as never, { currentSessionId }, {
 		batchConfig: { enabled: true, debounceMs: 150, maxWaitMs: 1000, stragglerDebounceMs: 75, stragglerMaxWaitMs: 400, stragglerWindowMs: 2000 },
 		timers: clock.api,
 		now: clock.now,
 	});
-	return { events, sent };
+	return { events, sent, notifier, dispose: () => notifier.dispose() };
 }
 
 interface FakeJob {
@@ -117,6 +134,62 @@ describe("registerSubagentNotify", () => {
 		});
 	});
 
+	it("acknowledges direct delivery only after sendMessage accepts it", async () => {
+		const { notifier, sent } = createPi("session-a");
+		assert.equal(await notifier.deliver(completionResult({ id: "direct-accepted" })), true);
+		assert.equal(sent.length, 1);
+	});
+
+	it("rejects a pending batch when the notifier is disposed", async () => {
+		const clock = createFakeClock();
+		const { notifier, sent } = createBatchingPi(clock);
+		const pending = notifier.deliver(completionResult({ id: "dispose-pending" }));
+		notifier.dispose();
+		assert.equal(await pending, false);
+		clock.advance(1000);
+		assert.equal(sent.length, 0);
+	});
+
+	it("wakes the originating session with recovered detached foreground output", () => {
+		const { events, sent } = createPi();
+
+		events.emit(SUBAGENT_FOREGROUND_COMPLETE_EVENT, {
+			id: "foreground-run:0",
+			runId: "foreground-run",
+			source: "foreground",
+			agent: "reviewer",
+			success: true,
+			summary: "Recovered final review",
+			exitCode: 0,
+			timestamp: 123,
+			sessionId: "session-1",
+		});
+
+		assert.equal(sent.length, 1);
+		assert.deepEqual(sent[0], {
+			message: {
+				customType: "subagent-notify",
+				content: "Detached foreground task completed: **reviewer**\n\nRecovered final review",
+				display: true,
+			},
+			options: { triggerTurn: true },
+		});
+	});
+
+	it("does not deliver detached foreground completion to another active session", () => {
+		const { events, sent } = createPi("session-2");
+		events.emit(SUBAGENT_FOREGROUND_COMPLETE_EVENT, {
+			id: "foreground-run:0",
+			source: "foreground",
+			agent: "reviewer",
+			success: true,
+			summary: "Recovered final review",
+			timestamp: 123,
+			sessionId: "session-1",
+		});
+		assert.equal(sent.length, 0);
+	});
+
 	it("preserves non-empty completion summaries", () => {
 		const { events, sent } = createPi();
 		const summary = "  Done streaming\nAll clear  ";
@@ -277,9 +350,71 @@ describe("registerSubagentNotify", () => {
 		assert.match((sent[0]!.message as { content: string }).content, /^Background task completed: \*\*alpha\*\*/);
 		assert.doesNotMatch((sent[0]!.message as { content: string }).content, /boom/);
 	});
+
+	it("disposes queued completions without emitting and is idempotent", () => {
+		const clock = createFakeClock();
+		const { events, sent, dispose } = createBatchingPi(clock);
+
+		events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, completionResult({ id: "dispose-held-1" }));
+		assert.equal(sent.length, 0);
+		assert.equal(events.listenerCount(SUBAGENT_ASYNC_COMPLETE_EVENT), 1);
+		assert.equal(events.listenerCount(SUBAGENT_FOREGROUND_COMPLETE_EVENT), 1);
+
+		dispose();
+		dispose();
+		assert.equal(events.listenerCount(SUBAGENT_ASYNC_COMPLETE_EVENT), 0);
+		assert.equal(events.listenerCount(SUBAGENT_FOREGROUND_COMPLETE_EVENT), 0);
+
+		clock.advance(1000);
+		assert.equal(sent.length, 0);
+	});
+
+	it("does not let a disposed notifier affect another runtime", () => {
+		const oldClock = createFakeClock();
+		const oldRegistration = createBatchingPi(oldClock);
+		oldRegistration.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, completionResult({ id: "old-owner-held-1" }));
+
+		const newClock = createFakeClock();
+		const newRegistration = createBatchingPi(newClock);
+		oldRegistration.dispose();
+		oldClock.advance(1000);
+		assert.equal(oldRegistration.sent.length, 0);
+
+		newRegistration.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, completionResult({ id: "new-owner-1" }));
+		newClock.advance(150);
+		assert.equal(newRegistration.sent.length, 1);
+		newRegistration.dispose();
+	});
 });
 
 describe("completion formatting helpers", () => {
+	it("formats and parses a parallel handoff without folding it into the result preview", () => {
+		const content = formatSingleCompletion({
+			agent: "worker",
+			status: "completed",
+			resultPreview: "Done",
+			handoffPath: "/tmp/run/handoff.json",
+			sessionLabel: "Session file",
+			sessionValue: "/tmp/session.jsonl",
+		});
+		assert.equal(content, "Background task completed: **worker**\n\nDone\n\nParallel handoff: /tmp/run/handoff.json\n\nSession file: /tmp/session.jsonl");
+		assert.deepEqual(parseSubagentNotifyContent(content), {
+			agent: "worker",
+			status: "completed",
+			resultPreview: "Done",
+			handoffPath: "/tmp/run/handoff.json",
+			sessionLabel: "session file",
+			sessionValue: "/tmp/session.jsonl",
+		});
+		assert.equal(buildCompletionDetails({
+			id: "run",
+			agent: "worker",
+			success: true,
+			summary: "Done",
+			parallelHandoff: { path: "/tmp/run/handoff.json" },
+		}).handoffPath, "/tmp/run/handoff.json");
+	});
+
 	it("formatSingleCompletion mirrors the in-handler single message shape", () => {
 		const content = formatSingleCompletion({
 			agent: "worker",
@@ -292,6 +427,25 @@ describe("completion formatting helpers", () => {
 		assert.equal(content, "Background task completed: **worker** (2/3)\n\nDone\n\nSession file: /tmp/session.jsonl");
 	});
 
+	it("parses detached foreground notification content for the custom renderer", () => {
+		const content = formatSingleCompletion({
+			agent: "reviewer",
+			status: "failed",
+			source: "foreground",
+			resultPreview: "Acceptance rejected",
+			sessionLabel: "Session file",
+			sessionValue: "/tmp/reviewer.jsonl",
+		});
+		assert.deepEqual(parseSubagentNotifyContent(content), {
+			agent: "reviewer",
+			status: "failed",
+			source: "foreground",
+			resultPreview: "Acceptance rejected",
+			sessionLabel: "session file",
+			sessionValue: "/tmp/reviewer.jsonl",
+		});
+	});
+
 	it("formatGroupedCompletion lists each agent with its summary and session", () => {
 		const content = formatGroupedCompletion([
 			{ agent: "alpha", status: "completed", resultPreview: "alpha done" },
@@ -305,6 +459,13 @@ describe("completion formatting helpers", () => {
 		);
 	});
 
+	it("reports false when Pi rejects sendMessage synchronously", async () => {
+		const pi = { events: createEventBus(), sendMessage() { throw new Error("runtime inactive"); } };
+		const notifier = registerSubagentNotify(pi as never, { currentSessionId: "session-a" }, { batchConfig: { enabled: false } });
+		assert.equal(await notifier.deliver(completionResult({ id: "direct-rejected" })), false);
+		notifier.dispose();
+	});
+
 	it("buildCompletionDetails derives paused status from state and summary", () => {
 		assert.equal(buildCompletionDetails({ id: "x", agent: "w", success: false, state: "paused", summary: "Paused after interrupt.", timestamp: 1 }).status, "paused");
 		assert.equal(buildCompletionDetails({ id: "x", agent: "w", success: false, summary: "boom", exitCode: 1, timestamp: 1 }).status, "failed");

package/dist/extensions/pi-subagents/test/unit/package-manifest.test.ts

@@ -11,32 +11,84 @@ const oldPiScopePattern = /@mariozechner\/pi-/;
 const piPackageJsonSubpathPattern = /@earendil-works\/pi-[^"']+\/package\.json/;
 const cjsPiPackageResolutionPattern = /require(?:\.resolve)?\(\s*["']@earendil-works\/pi-/;
 const exactVersionPattern = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
+const hostPeerPackages = [
+	"@earendil-works/pi-agent-core",
+	"@earendil-works/pi-ai",
+	"@selesai/code",
+	"@earendil-works/pi-tui",
+] as const;
+const expectedHostPeerRanges = {
+	"@earendil-works/pi-agent-core": "*",
+	"@earendil-works/pi-ai": ">=0.80.0",
+	"@selesai/code": "*",
+	"@earendil-works/pi-tui": "*",
+} satisfies Record<(typeof hostPeerPackages)[number], string>;
+const expectedHostDevVersions = {
+	"@earendil-works/pi-agent-core": "0.81.0",
+	"@earendil-works/pi-ai": "0.81.0",
+	"@selesai/code": "0.81.0",
+	"@earendil-works/pi-tui": "0.81.0",
+} satisfies Record<(typeof hostPeerPackages)[number], string>;
 
-function collectTsFiles(dir: string): string[] {
+function collectSourceFiles(dir: string): string[] {
 	const files: string[] = [];
 	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
 		const entryPath = path.join(dir, entry.name);
 		if (entry.isDirectory()) {
-			collectTsFiles(entryPath).forEach((file) => files.push(file));
-		} else if (entry.name.endsWith(".ts")) {
+			collectSourceFiles(entryPath).forEach((file) => files.push(file));
+		} else if (entry.name.endsWith(".ts") || entry.name.endsWith(".mjs")) {
 			files.push(entryPath);
 		}
 	}
 	return files;
 }
 
+test("published extension APIs use supported package entrypoints", async () => {
+	const packageJson = JSON.parse(fs.readFileSync(path.join(projectRoot, "package.json"), "utf-8"));
+
+	assert.deepEqual(packageJson.pi?.extensions, ["./index.ts"]);
+	assert.equal(packageJson.files?.includes("index.ts"), true);
+	assert.equal(
+		fs.readFileSync(path.join(projectRoot, "index.ts"), "utf-8").trim(),
+		'export { default } from "./src/extension/index.ts";',
+	);
+	assert.equal(fs.existsSync(path.join(projectRoot, "src", "api", "delegation.ts")), true);
+	assert.deepEqual(packageJson.exports, {
+		".": "./index.ts",
+		"./background-work": "./src/api/background-work.ts",
+		"./capability-ceiling": "./src/api/capability-ceiling.ts",
+		"./delegation": "./src/api/delegation.ts",
+		"./preflight": "./src/api/preflight.ts",
+	});
+	const backgroundWork = await import("pi-subagents/background-work");
+	assert.equal(backgroundWork.BACKGROUND_WORK_PROTOCOL_VERSION, 1);
+	assert.equal(backgroundWork.BACKGROUND_WORK_REGISTRY_KEY, "pi-subagents.background-work.v1");
+	const capability = await import("pi-subagents/capability-ceiling");
+	assert.equal(capability.SUBAGENT_CAPABILITY_CEILING_VERSION, 1);
+	assert.equal(capability.SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY, "pi-subagents.capability-ceiling.v1");
+	const delegation = await import("pi-subagents/delegation");
+	assert.equal(delegation.SUBAGENT_DELEGATION_PROTOCOL_VERSION, 1);
+	assert.equal(delegation.SUBAGENT_DELEGATION_V2_PROTOCOL_VERSION, 2);
+	assert.equal(delegation.SUBAGENT_DELEGATION_REQUEST_EVENT, "prompt-template:subagent:request");
+	const preflight = await import("pi-subagents/preflight");
+	assert.equal(preflight.SUBAGENT_LAUNCH_CONTRACT_VERSION, 2);
+	assert.equal(typeof preflight.resolveSubagentLaunchContract, "function");
+});
+
 test("direct @earendil-works runtime imports are declared for CI installs", () => {
 	const packageJson = JSON.parse(fs.readFileSync(path.join(projectRoot, "package.json"), "utf-8"));
 	const declared = new Set([
 		...Object.keys(packageJson.dependencies ?? {}),
 		...Object.keys(packageJson.devDependencies ?? {}),
+		...Object.keys(packageJson.peerDependencies ?? {}),
 	]);
 	const imported = new Set<string>();
 
-	for (const file of [...collectTsFiles(path.join(projectRoot, "src")), ...collectTsFiles(path.join(projectRoot, "test"))]) {
+	for (const file of [...collectSourceFiles(path.join(projectRoot, "src")), ...collectSourceFiles(path.join(projectRoot, "test"))]) {
 		const source = fs.readFileSync(file, "utf-8");
 		for (const match of source.matchAll(sourceImportPattern)) {
-			imported.add(match[1] ?? match[2]!);
+			const specifier = match[1] ?? match[2]!;
+			imported.add(specifier.split("/").slice(0, 2).join("/"));
 		}
 	}
 
@@ -54,15 +106,41 @@ test("direct dependency declarations are exact version pins", () => {
 	}
 });
 
+test("host-owned packages are optional peers with supported ranges, not production dependencies", () => {
+	const packageJson = JSON.parse(fs.readFileSync(path.join(projectRoot, "package.json"), "utf-8"));
+
+	for (const name of hostPeerPackages) {
+		assert.equal(packageJson.peerDependencies?.[name], expectedHostPeerRanges[name], `${name} should use its supported peer range`);
+		assert.equal(packageJson.dependencies?.[name], undefined, `${name} should not be a production dependency`);
+		assert.deepEqual(packageJson.peerDependenciesMeta?.[name], { optional: true }, `${name} should be an optional peer`);
+	}
+});
+test("typebox is a bundled runtime dependency", () => {
+	const packageJson = JSON.parse(fs.readFileSync(path.join(projectRoot, "package.json"), "utf-8"));
+
+	assert.equal(packageJson.dependencies?.typebox, "1.1.38");
+	assert.equal(packageJson.peerDependencies?.typebox, undefined);
+	assert.equal(packageJson.peerDependenciesMeta?.typebox, undefined);
+	assert.equal(packageJson.devDependencies?.typebox, undefined);
+});
+
+test("host-owned development packages use the supported SDK baseline", () => {
+	const packageJson = JSON.parse(fs.readFileSync(path.join(projectRoot, "package.json"), "utf-8"));
+
+	for (const [name, version] of Object.entries(expectedHostDevVersions)) {
+		assert.equal(packageJson.devDependencies?.[name], version, `${name} should use ${version}`);
+	}
+});
+
 test("old pi package scope is not used by source or tests", () => {
-	for (const file of [...collectTsFiles(path.join(projectRoot, "src")), ...collectTsFiles(path.join(projectRoot, "test"))]) {
+	for (const file of [...collectSourceFiles(path.join(projectRoot, "src")), ...collectSourceFiles(path.join(projectRoot, "test"))]) {
 		const source = fs.readFileSync(file, "utf-8");
 		assert.equal(oldPiScopePattern.test(source), false, file);
 	}
 });
 
 test("Pi package resolution stays export-map safe", () => {
-	for (const file of [...collectTsFiles(path.join(projectRoot, "src")), ...collectTsFiles(path.join(projectRoot, "test"))]) {
+	for (const file of [...collectSourceFiles(path.join(projectRoot, "src")), ...collectSourceFiles(path.join(projectRoot, "test"))]) {
 		const source = fs.readFileSync(file, "utf-8");
 		assert.equal(piPackageJsonSubpathPattern.test(source), false, `${file} should not resolve unexported package.json subpaths`);
 		assert.equal(cjsPiPackageResolutionPattern.test(source), false, `${file} should not use CommonJS resolution for ESM-only Pi packages`);

package/dist/extensions/pi-subagents/test/unit/parallel-handoff.test.ts

@@ -0,0 +1,175 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import {
+	formatParallelHandoffReference,
+	writeParallelHandoffGroup,
+} from "../../src/runs/shared/parallel-handoff.ts";
+import type { ParallelHandoffManifest } from "../../src/shared/types.ts";
+import type { WorktreeCleanupReport, WorktreeDiff, WorktreeSetup } from "../../src/runs/shared/worktree.ts";
+
+function setup(repoRoot: string, baseCommit: string): WorktreeSetup {
+	return { cwd: repoRoot, baseCommit, worktrees: [] };
+}
+
+function diff(dir: string, index: number, agent: string, changed: boolean): WorktreeDiff {
+	const patchPath = path.join(dir, `task-${index}-${agent}.patch`);
+	fs.mkdirSync(path.dirname(patchPath), { recursive: true });
+	fs.writeFileSync(patchPath, changed ? "diff --git a/a b/a\n" : "", "utf-8");
+	return {
+		index,
+		agent,
+		branch: `branch-${index}`,
+		diffStat: changed ? " a | 1 +" : "",
+		filesChanged: changed ? 1 : 0,
+		insertions: changed ? 1 : 0,
+		deletions: 0,
+		patchPath,
+	};
+}
+
+function cleanup(state: "complete" | "partial" = "complete"): WorktreeCleanupReport {
+	return {
+		state,
+		pruned: state === "complete",
+		tasks: [{
+			index: 0,
+			path: "/tmp/worktree-0",
+			branch: "branch-0",
+			worktreeRemoved: true,
+			branchRemoved: state === "complete",
+			...(state === "partial" ? { errors: ["branch removal failed"] } : {}),
+		}],
+	};
+}
+
+describe("parallel handoff", () => {
+	it("writes and aggregates versioned worktree handoff groups", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-parallel-handoff-"));
+		try {
+			const manifestPath = path.join(dir, "handoff.json");
+			const first = writeParallelHandoffGroup({
+				manifestPath,
+				runId: "run-1",
+				mode: "chain",
+				source: "async",
+				cwd: "/repo",
+				stepIndex: 2,
+				flatStartIndex: 3,
+				setup: setup("/repo", "base-1"),
+				diffs: [diff(dir, 0, "worker", true)],
+				cleanup: cleanup(),
+				results: [{
+					agent: "worker",
+					status: "completed",
+					summary: "implemented",
+					outputPath: "/artifacts/output.md",
+					structuredOutput: { ok: true },
+					structuredOutputPath: "/artifacts/structured.json",
+					sessionPath: "/sessions/worker.jsonl",
+				}],
+				now: 100,
+			});
+			assert.deepEqual(first, {
+				version: 1,
+				path: manifestPath,
+				groupCount: 1,
+				childCount: 1,
+				changedPatches: 1,
+				cleanupState: "complete",
+			});
+
+			const second = writeParallelHandoffGroup({
+				manifestPath,
+				runId: "run-1",
+				mode: "chain",
+				source: "async",
+				cwd: "/repo",
+				stepIndex: 1,
+				flatStartIndex: 1,
+				setup: setup("/repo", "base-1"),
+				diffs: [diff(dir, 1, "reviewer", false)],
+				cleanup: cleanup("partial"),
+				results: [{ agent: "reviewer", status: "failed", summary: "blocked" }],
+				now: 200,
+			});
+			assert.equal(second.groupCount, 2);
+			assert.equal(second.childCount, 2);
+			assert.equal(second.changedPatches, 1);
+			assert.equal(second.cleanupState, "partial");
+			assert.match(formatParallelHandoffReference(second), /2 children, 1 changed patches, cleanup partial/);
+
+			const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8")) as ParallelHandoffManifest;
+			assert.equal(manifest.createdAt, 100);
+			assert.equal(manifest.updatedAt, 200);
+			assert.deepEqual(manifest.groups.map((group) => group.stepIndex), [1, 2]);
+			assert.equal(manifest.groups[0]!.children[0]!.index, 1);
+			assert.equal(manifest.groups[1]!.children[0]!.index, 3);
+			assert.deepEqual(manifest.groups[1]!.children[0]!.structuredOutput, { ok: true });
+			assert.equal(manifest.groups[1]!.children[0]!.patch.changed, true);
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("records missing diff artifacts instead of throwing", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-parallel-handoff-missing-diff-"));
+		try {
+			const manifestPath = path.join(dir, "handoff.json");
+			const reference = writeParallelHandoffGroup({
+				manifestPath,
+				runId: "run-missing-diff",
+				mode: "parallel",
+				source: "foreground",
+				cwd: "/repo",
+				stepIndex: 0,
+				flatStartIndex: 0,
+				setup: {
+					...setup("/repo", "base-1"),
+					worktrees: [{ path: "/tmp/worktree-0", agentCwd: "/tmp/worktree-0", branch: "branch-0", index: 0, nodeModulesLinked: false, syntheticPaths: [] }],
+				},
+				diffs: [],
+				cleanup: cleanup(),
+				results: [{ agent: "bad/name agent", status: "completed", summary: "done" }],
+			});
+			assert.equal(reference.childCount, 1);
+			assert.equal(reference.changedPatches, 0);
+			const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8")) as ParallelHandoffManifest;
+			const patch = manifest.groups[0]!.children[0]!.patch;
+			assert.equal(patch.changed, false);
+			assert.match(patch.error ?? "", /diff artifact unavailable/);
+			assert.equal(path.basename(patch.path), "missing-diff-step-0-task-0-bad_name_agent.patch");
+			assert.equal(fs.existsSync(patch.path), true);
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects reusing a manifest path for another run", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-parallel-handoff-owner-"));
+		try {
+			const manifestPath = path.join(dir, "handoff.json");
+			const common = {
+				manifestPath,
+				mode: "parallel" as const,
+				source: "foreground" as const,
+				cwd: "/repo",
+				stepIndex: 0,
+				flatStartIndex: 0,
+				setup: setup("/repo", "base-1"),
+				diffs: [diff(dir, 0, "worker", false)],
+				cleanup: cleanup(),
+				results: [{ agent: "worker", status: "completed" as const, summary: "done" }],
+			};
+			writeParallelHandoffGroup({ ...common, runId: "run-1" });
+			assert.throws(
+				() => writeParallelHandoffGroup({ ...common, runId: "run-2" }),
+				/belongs to a different run/,
+			);
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+});

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

@@ -54,7 +54,7 @@ describe("Path resolution for .agents and ~/.agents", () => {
 		assert.strictEqual(resolved?.path, path.join(userSkillsDir, "test-skill-2.md"));
 	});
 
-	test("should resolve project agents from both .agents and .pi/agents", () => {
+	test("should resolve project agents from both .agents and .selesai/agents", () => {
 		const legacyDir = path.join(cwdDir, ".agents");
 		const agentsDir = path.join(cwdDir, ".selesai", "agents");
 		fs.mkdirSync(path.join(cwdDir, ".agents", "skills"), { recursive: true });