@selesai/code 0.9.11 → 0.9.12

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

@@ -11,6 +11,8 @@ import registerSubagentNotify, {
 } from "../../src/runs/background/notify.ts";
 import { SUBAGENT_ASYNC_COMPLETE_EVENT, SUBAGENT_FOREGROUND_COMPLETE_EVENT } from "../../src/shared/types.ts";
 
+const COMPLETION_OWNER_ID = "completion-owner-a";
+
 function createEventBus() {
 	const emitter = new EventEmitter();
 	return {
@@ -39,7 +41,7 @@ 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.
-	const notifier = registerSubagentNotify(pi as never, { currentSessionId }, { batchConfig: { enabled: false }, ...registerOptions });
+	const notifier = registerSubagentNotify(pi as never, { currentSessionId, completionOwnerId: COMPLETION_OWNER_ID }, { batchConfig: { enabled: false }, ...registerOptions });
 
 	return { events, sent, notifier, dispose: () => notifier.dispose() };
 }
@@ -53,7 +55,7 @@ function createBatchingPi(clock: ReturnType<typeof createFakeClock>, currentSess
 			sent.push({ message, options });
 		},
 	};
-	const notifier = registerSubagentNotify(pi as never, { currentSessionId }, {
+	const notifier = registerSubagentNotify(pi as never, { currentSessionId, completionOwnerId: COMPLETION_OWNER_ID }, {
 		batchConfig: { enabled: true, debounceMs: 150, maxWaitMs: 1000, stragglerDebounceMs: 75, stragglerMaxWaitMs: 400, stragglerWindowMs: 2000 },
 		timers: clock.api,
 		now: clock.now,
@@ -105,6 +107,7 @@ function completionResult(overrides: Record<string, unknown> = {}) {
 		exitCode: 0,
 		timestamp: 123,
 		sessionId: "session-a",
+		completionOwnerId: COMPLETION_OWNER_ID,
 		...overrides,
 	};
 }
@@ -121,6 +124,7 @@ describe("registerSubagentNotify", () => {
 			exitCode: 0,
 			timestamp: 123,
 			sessionId: "session-1",
+			completionOwnerId: COMPLETION_OWNER_ID,
 		});
 
 		assert.equal(sent.length, 1);
@@ -148,6 +152,13 @@ describe("registerSubagentNotify", () => {
 		assert.equal(sent.length, 1);
 	});
 
+	it("rejects async completion delivery for a missing or different parent owner", async () => {
+		const { notifier, sent } = createPi("session-a");
+		assert.equal(await notifier.deliver(completionResult({ id: "missing-owner", completionOwnerId: undefined })), false);
+		assert.equal(await notifier.deliver(completionResult({ id: "different-owner", completionOwnerId: "completion-owner-b" })), false);
+		assert.equal(sent.length, 0);
+	});
+
 	it("does not wake the session when background delivery explicitly disables triggerTurn", async () => {
 		const { notifier, sent } = createPi("session-a");
 		assert.equal(await notifier.deliver(completionResult({ id: "direct-silent", triggerTurn: false })), true);
@@ -224,6 +235,7 @@ describe("registerSubagentNotify", () => {
 			taskIndex: 1,
 			totalTasks: 3,
 			sessionId: "session-1",
+			completionOwnerId: COMPLETION_OWNER_ID,
 		});
 
 		assert.equal(sent.length, 1);
@@ -249,6 +261,7 @@ describe("registerSubagentNotify", () => {
 			timestamp: 456,
 			sessionFile: "/tmp/session.jsonl",
 			sessionId: "session-1",
+			completionOwnerId: COMPLETION_OWNER_ID,
 		});
 
 		assert.deepEqual(sent, [{
@@ -272,6 +285,7 @@ describe("registerSubagentNotify", () => {
 			summary: "Paused after interrupt. Waiting for explicit next action.",
 			timestamp: 789,
 			sessionId: "session-1",
+			completionOwnerId: COMPLETION_OWNER_ID,
 		});
 
 		assert.equal(sent.length, 1);
@@ -285,6 +299,34 @@ describe("registerSubagentNotify", () => {
 		});
 	});
 
+	it("labels detached-only workflow completions as paused and prints workflow child ids", () => {
+		const { events, sent } = createPi();
+
+		events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
+			id: "workflow-1",
+			runId: "workflow-1",
+			mode: "workflow",
+			agent: "workflow",
+			success: false,
+			state: "paused",
+			summary: "Run 'detaches' detached for intercom coordination.",
+			results: [{ workflowKey: "detaches", agent: "worker", runId: "child-1", status: "paused", success: false }],
+			timestamp: 790,
+			sessionId: "session-1",
+			completionOwnerId: COMPLETION_OWNER_ID,
+		});
+
+		assert.equal(sent.length, 1);
+		assert.deepEqual(sent[0], {
+			message: {
+				customType: "subagent-notify",
+				content: "Background task paused: **workflow**\n\nRun 'detaches' detached for intercom coordination.\n\nWorkflow run: workflow-1\nChild runs: detaches=child-1 (paused)",
+				display: true,
+			},
+			options: { triggerTurn: true },
+		});
+	});
+
 	it("ignores completions for other or missing session ids", () => {
 		const { events, sent } = createPi("session-owner");
 
@@ -484,6 +526,29 @@ describe("completion formatting helpers", () => {
 		);
 	});
 
+	it("round-trips workflow correlation metadata", () => {
+		const details = buildCompletionDetails({
+			id: "workflow-2",
+			runId: "workflow-2",
+			mode: "workflow",
+			agent: "workflow",
+			success: false,
+			state: "paused",
+			summary: "Run 'review' detached for supervisor handoff.",
+			reconciledFromDetachedChild: "child-2",
+			results: [{ workflowKey: "review", agent: "reviewer", runId: "child-2", status: "paused" }],
+		});
+
+		assert.equal(details.status, "paused");
+		assert.equal(details.workflowRunId, "workflow-2");
+		assert.deepEqual(details.childRuns, [{ runId: "child-2", workflowKey: "review", agent: "reviewer", status: "paused" }]);
+		assert.equal(details.reconciledFromDetachedChild, "child-2");
+		const parsed = parseSubagentNotifyContent(formatSingleCompletion(details));
+		assert.equal(parsed?.workflowRunId, "workflow-2");
+		assert.deepEqual(parsed?.childRuns, [{ runId: "child-2", workflowKey: "review", status: "paused" }]);
+		assert.equal(parsed?.reconciledFromDetachedChild, "child-2");
+	});
+
 	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 } });
@@ -517,3 +582,42 @@ describe("completion formatting helpers", () => {
 		assert.equal(details.status, "completed");
 	});
 });
+
+describe("scheduled completions", () => {
+	// A schedule fires with nobody watching, so its completion has to be visible to
+	// the operator and attributable by the agent that receives it.
+	const scheduledResult = {
+		id: "run-1",
+		source: "async" as const,
+		agent: "workflow",
+		success: true,
+		summary: "Workflow completed with 1 child run(s).",
+		scheduleOrigin: { id: "45daa203", name: "authz-facts-efficacy" },
+	};
+
+	it("carries the schedule origin from the result into the notice", () => {
+		const details = buildCompletionDetails(scheduledResult);
+		assert.deepEqual(details.scheduleOrigin, { id: "45daa203", name: "authz-facts-efficacy" });
+		assert.match(formatSingleCompletion(details), /Scheduled run from \*\*authz-facts-efficacy\*\* \(schedule 45daa203\)\./);
+	});
+
+	it("round-trips the origin without absorbing it into the result preview", () => {
+		const parsed = parseSubagentNotifyContent(formatSingleCompletion(buildCompletionDetails(scheduledResult)));
+		assert.deepEqual(parsed?.scheduleOrigin, { id: "45daa203", name: "authz-facts-efficacy" });
+		assert.equal(parsed?.resultPreview, "Workflow completed with 1 child run(s).");
+	});
+
+	it("keeps attribution when a scheduled run is batched with other completions", () => {
+		const { scheduleOrigin: _origin, ...plain } = scheduledResult;
+		const grouped = formatGroupedCompletion([buildCompletionDetails({ ...plain, agent: "worker" }), buildCompletionDetails(scheduledResult)]);
+		assert.match(grouped, /2\. workflow — scheduled run from authz-facts-efficacy \(schedule 45daa203\)/);
+		assert.doesNotMatch(grouped, /1\. worker —/);
+	});
+
+	it("leaves an ordinary successful completion without an origin", () => {
+		const { scheduleOrigin: _origin, ...withoutSchedule } = scheduledResult;
+		const parsed = parseSubagentNotifyContent(formatSingleCompletion(buildCompletionDetails(withoutSchedule)));
+		assert.equal(parsed?.scheduleOrigin, undefined);
+		assert.equal(parsed?.resultPreview, "Workflow completed with 1 child run(s).");
+	});
+});

package/dist/extensions/pi-subagents/test/unit/orca-progress-tabs.test.ts

@@ -22,9 +22,16 @@ function removeProgressFiles(prefix: string): void {
 afterEach(() => {
 	const progressRoot = path.join(TEMP_ROOT_DIR, "orca-progress");
 	for (const dir of tempDirs.splice(0)) {
-		const key = createHash("sha256").update(path.resolve(dir)).digest("hex").slice(0, 20);
+		let scope = path.resolve(dir);
+		try { scope = fs.realpathSync(dir); } catch { /* use the lexical path */ }
+		const key = createHash("sha256").update(scope).digest("hex").slice(0, 20);
 		fs.rmSync(path.join(progressRoot, `counter-${key}`), { force: true });
 		fs.rmSync(path.join(progressRoot, `counter-${key}.lock`), { recursive: true, force: true });
+		if (fs.existsSync(progressRoot)) {
+			for (const name of fs.readdirSync(progressRoot)) {
+				if (name.startsWith(`create-${key}-`) && (name.endsWith(".ready") || name.endsWith(".pending"))) fs.rmSync(path.join(progressRoot, name), { force: true });
+			}
+		}
 		fs.rmSync(dir, { recursive: true, force: true });
 	}
 	removeProgressFiles("progress-");
@@ -38,14 +45,26 @@ function tempDir(): string {
 	return dir;
 }
 
-async function waitForFile(file: string): Promise<void> {
-	const deadline = Date.now() + 5_000;
+async function waitForFile(file: string, timeoutMs = 5_000): Promise<void> {
+	const deadline = Date.now() + timeoutMs;
 	while (!fs.existsSync(file)) {
 		if (Date.now() >= deadline) throw new Error(`Timed out waiting for ${file}`);
 		await new Promise((resolve) => setTimeout(resolve, 20));
 	}
 }
 
+async function readManifestWithState(file: string, state: string, timeoutMs = 5_000): Promise<Record<string, unknown>> {
+	const deadline = Date.now() + timeoutMs;
+	let lastState: unknown;
+	while (Date.now() < deadline) {
+		const manifest = JSON.parse(fs.readFileSync(file, "utf-8")) as Record<string, unknown>;
+		lastState = manifest.state;
+		if (lastState === state) return manifest;
+		await new Promise((resolve) => setTimeout(resolve, 20));
+	}
+	throw new Error(`Timed out waiting for ${file} state ${state}; last state ${String(lastState)}`);
+}
+
 function progressFile(prefix: string, suffix: ".log" | ".done"): string {
 	const root = path.join(TEMP_ROOT_DIR, "orca-progress");
 	const name = fs.readdirSync(root).find((candidate) => candidate.startsWith(prefix) && candidate.endsWith(suffix));
@@ -68,6 +87,10 @@ function writeCaptureOrca(dir: string): string {
 	return writeNodeCommand(dir, "orca", "require('fs').writeFileSync(process.env.ORCA_TEST_CAPTURE, JSON.stringify(process.argv.slice(2)))");
 }
 
+function shellQuote(value: string): string {
+	return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+
 test("Orca progress tabs are disabled on Windows", { skip: process.platform === "win32" ? undefined : "Windows-only platform boundary" }, () => {
 	const dir = tempDir();
 	assert.equal(createOrcaProgressTab({
@@ -173,7 +196,7 @@ test("malformed optional observer metadata cannot break child execution", { skip
 	tab.finish("completed");
 	await waitForFile(capture);
 	const args = JSON.parse(fs.readFileSync(capture, "utf-8")) as string[];
-	assert.equal(args[args.indexOf("--title") + 1], "subagent · subagent · 1");
+	assert.equal(args[args.indexOf("--title") + 1], "subagents · subagent · 1");
 	removeProgressFiles("run-0-");
 });
 
@@ -226,13 +249,21 @@ test("enabled tabs use a worktree sequence and successful Pi sessions get cleanu
 	const args = JSON.parse(fs.readFileSync(capture, "utf-8")) as string[];
 	assert.deepEqual(args.slice(0, 2), ["terminal", "create"]);
 	assert.equal(args[args.indexOf("--worktree") + 1], `path:${path.resolve(dir)}`);
-	assert.equal(args[args.indexOf("--title") + 1], "subagent · worker · 1");
+	assert.equal(args[args.indexOf("--title") + 1], "subagents · worker · 1");
 	const viewer = args[args.indexOf("--command") + 1];
 	assert.ok(viewer.includes(process.execPath));
 	assert.doesNotMatch(viewer, /(?:^|;)\s*exec\s/);
 	assert.doesNotMatch(viewer, /(?:&|;)\s*exit(?:\s|$)/);
 
 	const progressDir = path.join(TEMP_ROOT_DIR, "orca-progress");
+	const manifestDir = path.join(dir, ".selesai", "subagents", "views", "orca");
+	const manifestName = fs.readdirSync(manifestDir).find((name) => name.startsWith(`${runId}-2-`) && name.endsWith(".json"));
+	assert.ok(manifestName);
+	const manifest = await readManifestWithState(path.join(manifestDir, manifestName), "open");
+	assert.equal(manifest.kind, "orca-observer-view");
+	assert.equal(manifest.role, "run");
+	assert.equal(manifest.title, "subagents · worker · 1");
+	assert.equal(manifest.state, "open");
 	const log = fs.readdirSync(progressDir).find((name) => name.startsWith(`${runId}-2-`) && name.endsWith(".log"));
 	assert.ok(log);
 	const text = fs.readFileSync(path.join(progressDir, log), "utf-8");
@@ -240,7 +271,7 @@ test("enabled tabs use a worktree sequence and successful Pi sessions get cleanu
 	assert.match(text, /› read: README\.md/);
 	assert.match(text, /done output/);
 	const quotedSessionFile = `'${fs.realpathSync(sessionFile).replace(/'/g, `'"'"'`)}'`;
-	assert.ok(text.includes(`completed. To remove the Pi session of this subagent, run rm -- ${quotedSessionFile}`));
+	assert.ok(text.includes(`completed. To remove the Pi session for this run, run rm -- ${quotedSessionFile}`));
 	assert.doesNotMatch(text, /find ~\/\.pi\/agent\/sessions/);
 
 	const nestedCwd = path.join(dir, "packages", "app");
@@ -258,7 +289,7 @@ test("enabled tabs use a worktree sequence and successful Pi sessions get cleanu
 	secondTab.finish("failed", sessionFile);
 	await waitForFile(secondCapture);
 	const secondArgs = JSON.parse(fs.readFileSync(secondCapture, "utf-8")) as string[];
-	assert.equal(secondArgs[secondArgs.indexOf("--title") + 1], "subagent · worker · 2");
+	assert.equal(secondArgs[secondArgs.indexOf("--title") + 1], "subagents · worker · 2");
 	const secondLog = fs.readdirSync(progressDir).find((name) => name.startsWith(`${runId}-second-0-`) && name.endsWith(".log"));
 	assert.ok(secondLog);
 	const secondText = fs.readFileSync(path.join(progressDir, secondLog), "utf-8");
@@ -321,6 +352,172 @@ test("mirror output keeps small writes that hit stream backpressure before the b
 	assert.doesNotMatch(text, /progress mirror truncated/);
 });
 
+test("same-worktree Orca creates wait for the previous numbered tab", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+	const dir = tempDir();
+	fs.mkdirSync(path.join(dir, ".git"));
+	const order = path.join(dir, "order.txt");
+	const firstCapture = path.join(dir, "first.json");
+	const secondCapture = path.join(dir, "second.json");
+	const fakeOrca = writeNodeCommand(dir, "orca", [
+		"const fs=require('fs');",
+		"const args=process.argv.slice(2);",
+		"const title=args[args.indexOf('--title')+1];",
+		"if(title.endsWith(' · 1')){const until=Date.now()+400;while(Date.now()<until){};fs.writeFileSync(process.env.ORCA_TEST_FIRST,JSON.stringify(args));}",
+		"else fs.writeFileSync(process.env.ORCA_TEST_SECOND,JSON.stringify(args));",
+		"fs.appendFileSync(process.env.ORCA_TEST_ORDER,title+'\\n');",
+	].join(""));
+	const first = createOrcaProgressTab({
+		cwd: dir,
+		runId: "ordered-first",
+		agent: "worker",
+		index: 0,
+		config: { enabled: true },
+		command: fakeOrca,
+		env: { ...process.env, ORCA_TEST_FIRST: firstCapture, ORCA_TEST_SECOND: secondCapture, ORCA_TEST_ORDER: order },
+	});
+	const second = createOrcaProgressTab({
+		cwd: dir,
+		runId: "ordered-second",
+		agent: "reviewer",
+		index: 0,
+		config: { enabled: true },
+		command: fakeOrca,
+		env: { ...process.env, ORCA_TEST_FIRST: firstCapture, ORCA_TEST_SECOND: secondCapture, ORCA_TEST_ORDER: order },
+	});
+	assert.ok(first);
+	assert.ok(second);
+	await waitForFile(secondCapture);
+	const titles = fs.readFileSync(order, "utf-8").trim().split("\n");
+	assert.deepEqual(titles, ["subagents · worker · 1", "subagents · reviewer · 2"]);
+	first.finish("failed");
+	second.finish("failed");
+});
+
+test("a missing predecessor marker does not delay the next tab", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+	const dir = tempDir();
+	fs.mkdirSync(path.join(dir, ".git"));
+	const key = createHash("sha256").update(fs.realpathSync(dir)).digest("hex").slice(0, 20);
+	const progressRoot = path.join(TEMP_ROOT_DIR, "orca-progress");
+	fs.mkdirSync(progressRoot, { recursive: true, mode: 0o700 });
+	const stalePending = path.join(progressRoot, `create-${key}-stale.pending`);
+	fs.writeFileSync(path.join(progressRoot, `counter-${key}`), `4\n${stalePending}\n`, { encoding: "utf-8", mode: 0o600 });
+	const capture = path.join(dir, "capture.json");
+	const fakeOrca = writeCaptureOrca(dir);
+	const startedAt = Date.now();
+	const tab = createOrcaProgressTab({
+		cwd: dir,
+		runId: "stale-predecessor",
+		agent: "worker",
+		index: 0,
+		config: { enabled: true },
+		command: fakeOrca,
+		env: { ...process.env, ORCA_TEST_CAPTURE: capture },
+	});
+	assert.ok(tab);
+	await waitForFile(capture);
+	assert.ok(Date.now() - startedAt < 2_000, "a missing predecessor delayed tab creation");
+	const args = JSON.parse(fs.readFileSync(capture, "utf-8")) as string[];
+	assert.equal(args[args.indexOf("--title") + 1], "subagents · worker · 5");
+	tab.finish("failed");
+});
+
+test("queued same-worktree creates start their timeout when the predecessor becomes active", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+	const dir = tempDir();
+	fs.mkdirSync(path.join(dir, ".git"));
+	const order = path.join(dir, "order.txt");
+	const active = path.join(dir, "active.lock");
+	const overlap = path.join(dir, "overlap.txt");
+	const firstCapture = path.join(dir, "first.json");
+	const secondCapture = path.join(dir, "second.json");
+	const thirdCapture = path.join(dir, "third.json");
+	const fakeOrca = writeNodeCommand(dir, "orca", [
+		"const fs=require('fs');",
+		"const args=process.argv.slice(2);",
+		"const title=args[args.indexOf('--title')+1];",
+		"let ownsLock=false;try{fs.writeFileSync(process.env.ORCA_TEST_ACTIVE,title,{flag:'wx'});ownsLock=true}catch{fs.appendFileSync(process.env.ORCA_TEST_OVERLAP,title+'\\n')}",
+		"fs.appendFileSync(process.env.ORCA_TEST_ORDER,'start '+title+'\\n');",
+		"const delay=title.endsWith(' · 1')||title.endsWith(' · 2')?14000:0;",
+		"setTimeout(()=>{",
+		" const capture=title.endsWith(' · 1')?process.env.ORCA_TEST_FIRST:title.endsWith(' · 2')?process.env.ORCA_TEST_SECOND:process.env.ORCA_TEST_THIRD;",
+		" fs.writeFileSync(capture,JSON.stringify(args));",
+		" fs.appendFileSync(process.env.ORCA_TEST_ORDER,'end '+title+'\\n');",
+		" if(ownsLock)fs.rmSync(process.env.ORCA_TEST_ACTIVE,{force:true});",
+		"},delay);",
+	].join(""));
+	const env = { ...process.env, ORCA_TEST_FIRST: firstCapture, ORCA_TEST_SECOND: secondCapture, ORCA_TEST_THIRD: thirdCapture, ORCA_TEST_ORDER: order, ORCA_TEST_ACTIVE: active, ORCA_TEST_OVERLAP: overlap };
+	const first = createOrcaProgressTab({ cwd: dir, runId: "queued-first", agent: "worker", index: 0, config: { enabled: true }, command: fakeOrca, env });
+	const second = createOrcaProgressTab({ cwd: dir, runId: "queued-second", agent: "reviewer", index: 0, config: { enabled: true }, command: fakeOrca, env });
+	const third = createOrcaProgressTab({ cwd: dir, runId: "queued-third", agent: "scout", index: 0, config: { enabled: true }, command: fakeOrca, env });
+	assert.ok(first);
+	assert.ok(second);
+	assert.ok(third);
+	await waitForFile(thirdCapture, 35_000);
+	assert.equal(fs.existsSync(overlap), false, "same-worktree Orca create invocations overlapped");
+	const events = fs.readFileSync(order, "utf-8").trim().split("\n");
+	assert.deepEqual(events, [
+		"start subagents · worker · 1",
+		"end subagents · worker · 1",
+		"start subagents · reviewer · 2",
+		"end subagents · reviewer · 2",
+		"start subagents · scout · 3",
+		"end subagents · scout · 3",
+	]);
+	first.finish("failed");
+	second.finish("failed");
+	third.finish("failed");
+});
+
+test("queued tabs defer cleanup until their terminal create settles", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+	const dir = tempDir();
+	fs.mkdirSync(path.join(dir, ".git"));
+	const firstCapture = path.join(dir, "first.json");
+	const secondCapture = path.join(dir, "second.json");
+	const cleanupLog = path.join(dir, "cleanup.log");
+	const fakeOrca = writeNodeCommand(dir, "orca", [
+		"const fs=require('fs');",
+		"const args=process.argv.slice(2);",
+		"const title=args[args.indexOf('--title')+1];",
+		"const capture=title.endsWith(' · 1')?process.env.ORCA_TEST_FIRST:process.env.ORCA_TEST_SECOND;",
+		"const delay=title.endsWith(' · 1')?800:0;",
+		"setTimeout(()=>fs.writeFileSync(capture,JSON.stringify(args)),delay);",
+	].join(""));
+	const fakePi = path.join(dir, "pi");
+	fs.writeFileSync(fakePi, "#!/bin/sh\nexit 0\n", { encoding: "utf-8", mode: 0o755 });
+	const fakeNode = path.join(dir, "node");
+	fs.writeFileSync(fakeNode, [
+		"#!/bin/sh",
+		"case \"$2\" in",
+		`*"deadline=Date.now()+Number(process.argv[1])"*) printf 'cleanup\\n' >> "\${ORCA_TEST_CLEANUP_LOG}" ;;`,
+		"esac",
+		`exec ${shellQuote(process.execPath)} "$@"`,
+		"",
+	].join("\n"), { encoding: "utf-8", mode: 0o755 });
+	const originalExecPath = process.execPath;
+	const originalCleanupLog = process.env.ORCA_TEST_CLEANUP_LOG;
+	const originalPath = process.env.PATH;
+	try {
+		process.execPath = fakePi;
+		process.env.PATH = `${dir}${path.delimiter}${originalPath ?? ""}`;
+		process.env.ORCA_TEST_CLEANUP_LOG = cleanupLog;
+		const env = { ...process.env, ORCA_TEST_FIRST: firstCapture, ORCA_TEST_SECOND: secondCapture, ORCA_TEST_CLEANUP_LOG: cleanupLog };
+		const first = createOrcaProgressTab({ cwd: dir, runId: "cleanup-first", agent: "worker", index: 0, config: { enabled: true }, command: fakeOrca, env });
+		const second = createOrcaProgressTab({ cwd: dir, runId: "cleanup-second", agent: "reviewer", index: 0, config: { enabled: true }, command: fakeOrca, env });
+		assert.ok(first);
+		assert.ok(second);
+		second.finish("completed");
+		await new Promise((resolve) => setTimeout(resolve, 300));
+		assert.equal(fs.existsSync(cleanupLog), false, "cleanup started before queued terminal creation settled");
+		await waitForFile(secondCapture);
+		await waitForFile(cleanupLog);
+		first.finish("failed");
+	} finally {
+		process.execPath = originalExecPath;
+		process.env.PATH = originalPath;
+		if (originalCleanupLog === undefined) delete process.env.ORCA_TEST_CLEANUP_LOG;
+		else process.env.ORCA_TEST_CLEANUP_LOG = originalCleanupLog;
+	}
+});
+
 test("mirror output truncates at a finite byte bound", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
 	const dir = tempDir();
 	const capture = path.join(dir, "capture.json");

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

@@ -1,5 +1,7 @@
 import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import test from "node:test";
@@ -29,6 +31,50 @@ const expectedHostDevVersions = {
 	"@earendil-works/pi-tui": "0.81.0",
 } satisfies Record<Exclude<(typeof hostPeerPackages)[number], "@selesai/code">, string>;
 
+test("the root entrypoint exposes the runtime error flag to TypeScript consumers", () => {
+	const consumerRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-types-"));
+	try {
+		fs.writeFileSync(path.join(consumerRoot, "consumer.ts"), `
+import "pi-subagents";
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+
+const result: AgentToolResult<undefined> = {
+	content: [],
+	details: undefined,
+	isError: true,
+};
+
+void result.isError;
+`, "utf-8");
+		fs.writeFileSync(path.join(consumerRoot, "tsconfig.json"), JSON.stringify({
+			compilerOptions: {
+				target: "ES2023",
+				module: "NodeNext",
+				moduleResolution: "NodeNext",
+				strict: true,
+				noEmit: true,
+				types: ["node"],
+				typeRoots: [path.join(projectRoot, "node_modules", "@types")],
+				skipLibCheck: true,
+				allowImportingTsExtensions: true,
+				baseUrl: consumerRoot,
+				paths: {
+					"pi-subagents": [path.join(projectRoot, "index.ts")],
+				"@earendil-works/pi-agent-core": [path.join(projectRoot, "node_modules", "@earendil-works", "pi-agent-core", "dist", "index.d.ts")],
+				},
+			},
+			files: [path.join(consumerRoot, "consumer.ts")],
+		}, null, 2), "utf-8");
+
+		execFileSync(process.execPath, [path.join(projectRoot, "node_modules", "typescript", "bin", "tsc"), "--project", path.join(consumerRoot, "tsconfig.json")], {
+			cwd: consumerRoot,
+			stdio: "pipe",
+		});
+	} finally {
+		fs.rmSync(consumerRoot, { recursive: true, force: true });
+	}
+});
+
 function collectSourceFiles(dir: string): string[] {
 	const files: string[] = [];
 	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
@@ -47,14 +93,19 @@ test("published extension APIs use supported package entrypoints", async () => {
 
 	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(packageJson.files?.includes("*.mjs"), true);
+	assert.equal(fs.existsSync(path.join(projectRoot, "async-retention-discovery-worker.mjs")), true);
+	const entrySource = fs.readFileSync(path.join(projectRoot, "index.ts"), "utf-8");
+	assert.match(entrySource, /import type \{\} from "\.\/src\/types\/pi-runtime-compat\.d\.ts";/);
+	assert.equal(entrySource.includes('export { default } from "./src/extension/index.ts";'), false);
+	assert.match(entrySource, /process\.env\.SELESAI_SUBAGENT_CHILD === "1"/);
+	assert.match(entrySource, /await import\("\.\/src\/extension\/index\.ts"\)/);
 	assert.equal(fs.existsSync(path.join(projectRoot, "src", "api", "delegation.ts")), true);
 	assert.deepEqual(packageJson.exports, {
 		".": "./index.ts",
+		"./agents": "./src/api/agents.ts",
 		"./background-work": "./src/api/background-work.ts",
+		"./external-job-provider": "./src/api/external-job-provider.ts",
 		"./external-runs": "./src/api/external-runs.ts",
 		"./capability-ceiling": "./src/api/capability-ceiling.ts",
 		"./delegation": "./src/api/delegation.ts",
@@ -68,6 +119,10 @@ test("published extension APIs use supported package entrypoints", async () => {
 	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 externalJobProvider = await import("pi-subagents/external-job-provider");
+	assert.equal(externalJobProvider.EXTERNAL_JOB_PROVIDER_PROTOCOL_VERSION, 1);
+	assert.equal(externalJobProvider.EXTERNAL_JOB_PROVIDER_REGISTRY_KEY, "pi-subagents.external-job-providers.v1");
+	assert.equal(typeof externalJobProvider.registerExternalJobProvider, "function");
 	const externalRuns = await import("pi-subagents/external-runs");
 	assert.equal(externalRuns.EXTERNAL_RUN_REGISTRY_VERSION, 2);
 	assert.equal(typeof externalRuns.registerExternalRun, "function");

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

@@ -6,20 +6,17 @@ import { describe, it } from "node:test";
  * Tests for cross-platform path handling patterns used throughout the codebase.
  * These tests document the correct patterns after fixes were applied.
  *
- * Fixed locations:
- * - chain-execution.ts — uses path.isAbsolute() for absolute path detection
- * - settings.ts — uses path.join() for path construction
+ * Use path.isAbsolute() for absolute path detection and path.join() for path construction.
  */
 
 describe("path.isAbsolute vs startsWith('/')", () => {
-	// chain-execution.ts:496 uses startsWith("/") to detect absolute paths.
 	// On Windows, absolute paths look like "C:\\..." or "C:/..." — neither starts with "/".
 
 	it("startsWith('/') misses Windows absolute paths", () => {
 		const windowsAbsolute = "C:\\dev\\pi-subagents\\output.md";
 		const windowsAbsoluteForward = "C:/dev/pi-subagents/output.md";
 
-		// This is what the current code does (chain-execution.ts:496):
+		// A startsWith check is not portable:
 		assert.equal(windowsAbsolute.startsWith("/"), false,
 			"Windows backslash absolute path not detected by startsWith('/')");
 		assert.equal(windowsAbsoluteForward.startsWith("/"), false,
@@ -60,7 +57,6 @@ describe("path.join vs template string concatenation", () => {
 	// This works but produces inconsistent separators on Windows.
 
 	it("template concatenation produces forward slashes regardless of platform", () => {
-		// chain-execution.ts:496 uses startsWith("/") to detect absolute paths.
 		const chainDir = "C:\\Users\\marc\\temp\\chain-abc";
 		const file = "progress.md";
 

package/dist/extensions/pi-subagents/test/unit/pi-args-permission-system.test.ts

@@ -221,7 +221,7 @@ describe("resolvePermissionSystemExtension", () => {
 });
 
 describe("resolvePiLaunchToolPlan with permission system", () => {
-	it("adds the permission system extension to buildPiArgs when installed", () => {
+	it("does not inject the permission system when no native permission rules are set", () => {
 		const { agentDir } = createFixture();
 		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
 		const extDir = path.join(agentDir, "extensions", "pi-permission-system");
@@ -245,9 +245,41 @@ describe("resolvePiLaunchToolPlan with permission system", () => {
 		const extensionArgs = args.filter(
 			(arg, index) => args[index - 1] === "--extension",
 		);
+		assert.equal(
+			extensionArgs.includes(path.join(extDir, "src", "index.ts")),
+			false,
+			"permission system extension should not be emitted without native rules",
+		);
+	});
+
+	it("injects the permission system when explicit native permission rules are set", () => {
+		const { agentDir } = createFixture();
+		process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+		const extDir = path.join(agentDir, "extensions", "pi-permission-system");
+		fs.mkdirSync(path.join(extDir, "src"), { recursive: true });
+		fs.writeFileSync(
+			path.join(extDir, "src", "index.ts"),
+			"export default () => {};",
+		);
+		fs.writeFileSync(
+			path.join(extDir, "package.json"),
+			JSON.stringify({ name: "test", pi: { extensions: ["./src/index.ts"] } }),
+		);
+
+		const { args } = buildPiArgs({
+			baseArgs: ["-p"],
+			task: "test task",
+			sessionEnabled: false,
+			inheritProjectContext: false,
+			inheritSkills: false,
+			permissionRules: { write: "ask" },
+		});
+		const extensionArgs = args.filter(
+			(arg, index) => args[index - 1] === "--extension",
+		);
 		assert.ok(
 			extensionArgs.includes(path.join(extDir, "src", "index.ts")),
-			"permission system extension should be emitted as an extension argument",
+			"permission system extension should be emitted when native rules are active",
 		);
 	});