@selesai/code 0.8.6 → 0.8.7

package/dist/extensions/pi-subagents/test/unit/mission-goal-driver.test.ts

@@ -7,6 +7,7 @@ import { handleMissionAction } from "../../src/missions/actions.ts";
 import { collectGoalContinuationNotices } from "../../src/missions/goal-driver.ts";
 import { createMission, readMission, resolveMissionStoreLocation, updateMission } from "../../src/missions/store.ts";
 import { missionStatePath } from "../../src/missions/workflow-state.ts";
+import type { RetainedChild } from "../../src/runs/background/retained-children.ts";
 
 function fixture() {
 	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-goal-mission-"));
@@ -46,7 +47,7 @@ describe("goal mission continuation", () => {
 			const resumed = collectGoalContinuationNotices({
 				location: test.location,
 				ownerSessionId: "session-1",
-				retainedChildren: [{ runId: "child-review", parentRunId: "workflow-1", agent: "reviewer", taskSummary: "Review", completedAt: 1, sessionPath: "/tmp/child.jsonl" }],
+				retainedChildren: [{ runId: "child-review", parentRunId: "workflow-1", state: "complete", agent: "reviewer", taskSummary: "Review", completedAt: 1, sessionPath: "/tmp/child.jsonl", resumability: { state: "resumable", sessionPath: "/tmp/child.jsonl" } }],
 				turnId: 3,
 			});
 			assert.equal(resumed.length, 1);
@@ -85,8 +86,8 @@ describe("goal mission continuation", () => {
 				location: test.location,
 				ownerSessionId: "session-1",
 				retainedChildren: [
-					{ runId: "child-old", parentRunId: "workflow-old", agent: "reviewer", taskSummary: "Old", completedAt: 2, sessionPath: "/tmp/old.jsonl" },
-					{ runId: "child-new", parentRunId: "workflow-new", agent: "reviewer", taskSummary: "New", completedAt: 1, sessionPath: "/tmp/new.jsonl" },
+					{ runId: "child-old", parentRunId: "workflow-old", state: "complete", agent: "reviewer", taskSummary: "Old", completedAt: 2, sessionPath: "/tmp/old.jsonl", resumability: { state: "resumable", sessionPath: "/tmp/old.jsonl" } },
+					{ runId: "child-new", parentRunId: "workflow-new", state: "complete", agent: "reviewer", taskSummary: "New", completedAt: 1, sessionPath: "/tmp/new.jsonl", resumability: { state: "resumable", sessionPath: "/tmp/new.jsonl" } },
 				],
 				turnId: 1,
 			});
@@ -99,6 +100,69 @@ describe("goal mission continuation", () => {
 		}
 	});
 
+	it("resumes a mission-linked child older than ten unrelated children", () => {
+		const test = fixture();
+		try {
+			const mission = createMission(test.location, {
+				title: "Continue linked work",
+				objective: "Resume the linked worker",
+				goal: true,
+				budget: { tokens: 100 },
+				status: "active",
+				ownerSessionId: "session-1",
+			});
+			updateMission(test.location, mission.id, { addRuns: [{ runId: "workflow-mission", mode: "workflow", status: "complete" }] });
+			const retainedChildren: RetainedChild[] = [
+				...Array.from({ length: 10 }, (_, offset) => {
+					const index = 10 - offset;
+					return { runId: `child-${index}`, parentRunId: `workflow-unrelated-${index}`, state: "complete" as const, agent: "worker", taskSummary: "Unrelated", completedAt: index, resumability: { state: "resumable" as const, sessionPath: `/tmp/child-${index}.jsonl` } };
+				}),
+				{ runId: "child-0", parentRunId: "workflow-mission", state: "complete", agent: "worker", taskSummary: "Linked", completedAt: 0, resumability: { state: "resumable", sessionPath: "/tmp/child-0.jsonl" } },
+			];
+			const notices = collectGoalContinuationNotices({
+				location: test.location,
+				ownerSessionId: "session-1",
+				retainedChildren,
+				turnId: 1,
+			});
+
+			assert.equal(retainedChildren.length, 11);
+			assert.equal(notices.length, 1);
+			assert.match(notices[0]!.message, /Resume retained child child-0 \(worker\)/);
+			assert.doesNotMatch(notices[0]!.message, /child-10/);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
+	it("does not resume non-resumable retained children from goal notices", () => {
+		const test = fixture();
+		try {
+			const mission = createMission(test.location, {
+				title: "Ship auth refresh",
+				objective: "Implement and validate token refresh",
+				goal: true,
+				budget: { tokens: 100 },
+				status: "active",
+				ownerSessionId: "session-1",
+			});
+			updateMission(test.location, mission.id, { addRuns: [{ runId: "workflow-stopped", mode: "workflow", status: "complete" }] });
+
+			const notices = collectGoalContinuationNotices({
+				location: test.location,
+				ownerSessionId: "session-1",
+				retainedChildren: [{ runId: "child-stopped", parentRunId: "workflow-stopped", state: "stopped", agent: "worker", taskSummary: "Stopped", completedAt: 1, resumability: { state: "not-resumable", reason: "stopped run" } }],
+				turnId: 1,
+			});
+
+			assert.equal(notices.length, 1);
+			assert.doesNotMatch(notices[0]!.message, /Resume retained child/);
+			assert.match(notices[0]!.message, /Next ready action: Continue objective: Implement and validate token refresh/);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
 	it("supports pause, resume, and opt-out through mission.update", () => {
 		const test = fixture();
 		try {

package/dist/extensions/pi-subagents/test/unit/mission-lifecycle.test.ts

@@ -17,7 +17,7 @@ function projectFixture() {
 	const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-mission-lifecycle-"));
 	const projectRoot = path.join(root, "project");
 	fs.mkdirSync(projectRoot, { recursive: true });
-	return { root, projectRoot, missionConfig: { globalIndexDir: path.join(root, "global-index") } };
+	return { root, projectRoot, missionConfig: { directory: ".pi-subagents/missions", globalIndexDir: path.join(root, "global-index") } };
 }
 
 describe("mission launch lifecycle", () => {

package/dist/extensions/pi-subagents/test/unit/mission-store.test.ts

@@ -34,6 +34,20 @@ async function waitForFile(filePath: string, timeoutMs = 10_000): Promise<void>
 }
 
 describe("mission store", () => {
+	it("stores default missions outside the project and preserves configured project storage", () => {
+		const test = fixture();
+		try {
+			assert.equal(path.relative(test.projectRoot, test.location.missionDir).startsWith(".."), true);
+			assert.equal(test.location.missionDir.startsWith(path.join(test.agentDir, "missions", "projects")), true);
+			assert.equal(
+				resolveMissionStoreLocation({ projectRoot: test.projectRoot, agentDir: test.agentDir, config: { directory: ".pi/subagents/missions" } }).missionDir,
+				path.join(test.projectRoot, ".pi/subagents", "missions"),
+			);
+		} finally {
+			fs.rmSync(test.root, { recursive: true, force: true });
+		}
+	});
+
 	it("creates, reads, updates, lists, and globally indexes project missions", () => {
 		const test = fixture();
 		try {

package/dist/extensions/pi-subagents/test/unit/model-fallback.test.ts

@@ -68,6 +68,13 @@ describe("model fallback helpers", () => {
 		);
 	});
 
+	it("rejects fallback models that the active registry cannot resolve", () => {
+		assert.throws(
+			() => buildModelCandidates("gpt-5-mini", ["does-not-exist"], availableModels),
+			/Unknown subagent model 'does-not-exist'/,
+		);
+	});
+
 	it("detects retryable provider/model failures", () => {
 		assert.equal(isRetryableModelFailure("rate limit exceeded for provider"), true);
 		assert.equal(isRetryableModelFailure("model unavailable"), true);
@@ -161,6 +168,17 @@ describe("resolveSubagentModelOverride (cross-session inherit, issue #266)", ()
 		);
 	});
 
+	it("rejects explicit models that the active registry cannot resolve", () => {
+		assert.throws(
+			() => resolveSubagentModelOverride("does-not-exist", parentModel, availableModels),
+			/Unknown subagent model 'does-not-exist'/,
+		);
+		assert.throws(
+			() => resolveSubagentModelOverride("does-not-exist:high", parentModel, availableModels),
+			/Unknown subagent model 'does-not-exist:high'/,
+		);
+	});
+
 	it("returns undefined when inheriting but no parent model is known", () => {
 		// No parent session model available: fall back to the prior behavior of
 		// emitting no override rather than inventing an invalid one.

package/dist/extensions/pi-subagents/test/unit/native-supervisor-channel.test.ts

@@ -150,7 +150,7 @@ describe("native supervisor channel", () => {
 		channel.start();
 		channel.dispose();
 
-		assert.deepEqual(registeredTools, [NATIVE_SUPERVISOR_TOOL_NAME, "intercom"]);
+		assert.deepEqual(registeredTools, [NATIVE_SUPERVISOR_TOOL_NAME]);
 		assert.deepEqual(sent.map(({ message }) => message.details?.id), [matchingId]);
 		assert.deepEqual(sent[0]?.options, { triggerTurn: true });
 		assert.equal(channel.pending.has(matchingId), false, "disposed channel clears pending requests");
@@ -553,7 +553,7 @@ describe("native supervisor channel", () => {
 				registeredTools.set(tool.name, tool);
 			},
 		};
-		registerNativeSupervisorClient(pi as never, { includeIntercomFallback: false });
+		registerNativeSupervisorClient(pi as never);
 		const controller = new AbortController();
 		controller.abort();
 

package/dist/extensions/pi-subagents/test/unit/nested-events.test.ts

@@ -39,9 +39,23 @@ const savedEnv = {
 	[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV]: process.env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV],
 };
 
-afterEach(() => {
+async function removeDirWithRetry(dir: string): Promise<void> {
+	let lastError: unknown;
+	for (let attempt = 0; attempt < 5; attempt++) {
+		try {
+			fs.rmSync(dir, { recursive: true, force: true });
+			return;
+		} catch (error) {
+			lastError = error;
+			await new Promise((resolve) => setTimeout(resolve, 10));
+		}
+	}
+	throw lastError;
+}
+
+afterEach(async () => {
 	for (const route of routes.splice(0)) {
-		fs.rmSync(path.dirname(route.eventSink), { recursive: true, force: true });
+		await removeDirWithRetry(path.dirname(route.eventSink));
 	}
 	for (const [key, value] of Object.entries(savedEnv)) {
 		if (value === undefined) delete process.env[key];
@@ -97,6 +111,15 @@ describe("nested route index", () => {
 		const tokens = new Set([first.capabilityToken, second.capabilityToken]);
 		assert.ok(tokens.has(indexed.capabilityToken), "indexed route must be one of the two created routes");
 	});
+
+	it("recovers a route from its index when the route file is missing", () => {
+		const route = trackRoute("late-route-root");
+		const routeFile = path.join(path.dirname(route.eventSink), "route.json");
+		fs.rmSync(routeFile);
+
+		assert.equal(buildNestedRouteIndex().get("late-route-root")?.capabilityToken, route.capabilityToken);
+		assert.equal(JSON.parse(fs.readFileSync(routeFile, "utf-8")).capabilityToken, route.capabilityToken);
+	});
 });
 
 describe("nested event route validation", () => {

package/dist/extensions/pi-subagents/test/unit/node-executable.test.ts

@@ -0,0 +1,26 @@
+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 { resolveNodeExecutable } from "../../src/shared/node-executable.ts";
+
+describe("Node executable resolution", () => {
+	it("uses an executable Node path", () => {
+		assert.equal(resolveNodeExecutable(process.execPath), process.execPath);
+	});
+
+	it("falls back to PATH node for a standalone Pi executable", () => {
+		assert.equal(resolveNodeExecutable(path.join(os.tmpdir(), process.platform === "win32" ? "pi.exe" : "pi")), process.platform === "win32" ? "node.exe" : "node");
+	});
+
+	it("falls back to PATH node for a stale Node path", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-node-executable-"));
+		try {
+			const staleNode = path.join(root, process.platform === "win32" ? "node.exe" : "node");
+			assert.equal(resolveNodeExecutable(staleNode), process.platform === "win32" ? "node.exe" : "node");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+});

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

@@ -134,6 +134,14 @@ describe("registerSubagentNotify", () => {
 		});
 	});
 
+	it("does not attach async status snapshots to subagent-notify details", async () => {
+		const { notifier, sent } = createPi("session-a");
+		assert.equal(await notifier.deliver(completionResult({ id: "direct-no-snapshot" })), true);
+		const message = sent[0]?.message as { customType?: string; details?: Record<string, unknown> } | undefined;
+		assert.equal(message?.customType, "subagent-notify");
+		assert.equal(message?.details?.asyncSnapshot, undefined);
+	});
+
 	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);

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

@@ -0,0 +1,348 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { afterEach, test } from "node:test";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { createOrcaProgressTab, resolveOrcaCommand, resolvePiSessionId } from "../../src/runs/shared/orca-progress-tabs.ts";
+import { TEMP_ROOT_DIR } from "../../src/shared/types.ts";
+import { writeNodeCommand } from "../support/node-command.ts";
+
+const tempDirs: string[] = [];
+
+function removeProgressFiles(prefix: string): void {
+	const root = path.join(TEMP_ROOT_DIR, "orca-progress");
+	if (!fs.existsSync(root)) return;
+	for (const name of fs.readdirSync(root)) {
+		if (name.startsWith(prefix)) fs.rmSync(path.join(root, name), { force: true });
+	}
+}
+
+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);
+		fs.rmSync(path.join(progressRoot, `counter-${key}`), { force: true });
+		fs.rmSync(path.join(progressRoot, `counter-${key}.lock`), { recursive: true, force: true });
+		fs.rmSync(dir, { recursive: true, force: true });
+	}
+	removeProgressFiles("progress-");
+	removeProgressFiles("disabled-run-");
+	removeProgressFiles("standalone-pi-");
+});
+
+function tempDir(): string {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-orca-tabs-test-"));
+	tempDirs.push(dir);
+	return dir;
+}
+
+async function waitForFile(file: string): Promise<void> {
+	const deadline = Date.now() + 5_000;
+	while (!fs.existsSync(file)) {
+		if (Date.now() >= deadline) throw new Error(`Timed out waiting for ${file}`);
+		await new Promise((resolve) => setTimeout(resolve, 20));
+	}
+}
+
+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));
+	assert.ok(name, `Expected ${suffix} file for ${prefix}`);
+	return path.join(root, name);
+}
+
+function captureCommand(command: string, cwd: string): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, { cwd, shell: true, stdio: ["ignore", "pipe", "pipe"] });
+		let output = "";
+		child.stdout.setEncoding("utf-8");
+		child.stdout.on("data", (chunk: string) => { output += chunk; });
+		child.once("error", reject);
+		child.once("close", (code) => code === 0 ? resolve(output) : reject(new Error(`Viewer exited ${code}: ${output}`)));
+	});
+}
+
+function writeCaptureOrca(dir: string): string {
+	return writeNodeCommand(dir, "orca", "require('fs').writeFileSync(process.env.ORCA_TEST_CAPTURE, JSON.stringify(process.argv.slice(2)))");
+}
+
+test("Orca progress tabs are disabled on Windows", { skip: process.platform === "win32" ? undefined : "Windows-only platform boundary" }, () => {
+	const dir = tempDir();
+	assert.equal(createOrcaProgressTab({
+		cwd: dir,
+		runId: "windows-disabled",
+		agent: "worker",
+		index: 0,
+		config: { enabled: true },
+		command: process.execPath,
+	}), undefined);
+});
+
+test("resolveOrcaCommand only returns executable commands", () => {
+	const dir = tempDir();
+	const executable = writeNodeCommand(dir, "orca", "process.exit(0)");
+	assert.equal(resolveOrcaCommand({ PATH: dir, PATHEXT: ".CMD" }), executable);
+	assert.equal(resolveOrcaCommand({ PATH: "", SELESAI_SUBAGENT_ORCA_BINARY: path.join(dir, "missing") }), undefined);
+});
+
+test("an unavailable Orca command leaves native execution untouched", () => {
+	const dir = tempDir();
+	assert.equal(createOrcaProgressTab({
+		cwd: dir,
+		runId: "missing-orca",
+		agent: "worker",
+		index: 0,
+		config: { enabled: true },
+		env: { PATH: "", SELESAI_SUBAGENT_ORCA_BINARY: path.join(dir, "missing") },
+	}), undefined);
+});
+
+test("standalone Pi executables use PATH Node for the watchdog and viewer", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+	const dir = tempDir();
+	const capture = path.join(dir, "capture.json");
+	const fakeOrca = writeCaptureOrca(dir);
+	const fakePi = path.join(dir, "pi");
+	const originalExecPath = process.execPath;
+	try {
+		process.execPath = fakePi;
+		const tab = createOrcaProgressTab({
+			cwd: dir,
+			runId: "standalone-pi",
+			agent: "worker",
+			index: 0,
+			config: { enabled: true },
+			command: fakeOrca,
+			env: { ...process.env, ORCA_TEST_CAPTURE: capture },
+		});
+		assert.ok(tab);
+		tab.finish("failed");
+		await waitForFile(capture);
+		const args = JSON.parse(fs.readFileSync(capture, "utf-8")) as string[];
+		const viewer = args[args.indexOf("--command") + 1]!;
+		assert.match(viewer, /^'node' '-e' /);
+		assert.equal(viewer.includes(fakePi), false);
+		assert.match(await captureCommand(viewer, dir), /failed/);
+	} finally {
+		process.execPath = originalExecPath;
+	}
+});
+
+test("hung Orca terminal creation does not delay the owning process", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+	const dir = tempDir();
+	const fakeOrca = writeNodeCommand(dir, "orca", "require('fs').writeFileSync(process.env.ORCA_TEST_PID, String(process.pid));setInterval(()=>{},1000)");
+	const pidFile = path.join(dir, "orca.pid");
+	const moduleUrl = new URL("../../src/runs/shared/orca-progress-tabs.ts", import.meta.url).href;
+	const ownerScript = `import {createOrcaProgressTab} from ${JSON.stringify(moduleUrl)};const tab=createOrcaProgressTab({cwd:${JSON.stringify(dir)},runId:'progress-hung-owner',agent:'worker',index:0,config:{enabled:true},command:${JSON.stringify(fakeOrca)},env:{...process.env,ORCA_TEST_PID:${JSON.stringify(pidFile)}}});if(!tab)throw new Error('tab unavailable');`;
+	const startedAt = Date.now();
+	const owner = spawn(process.execPath, ["--experimental-strip-types", "--input-type=module", "--eval", ownerScript], { cwd: dir, stdio: "ignore" });
+	const ownerClosed = new Promise<number | null>((resolve, reject) => {
+		owner.once("error", reject);
+		owner.once("close", resolve);
+	});
+	let fakePid: number | undefined;
+	try {
+		assert.equal(await ownerClosed, 0);
+		assert.ok(Date.now() - startedAt < 2_000, "the Orca observer delayed runner completion");
+		await waitForFile(pidFile);
+		fakePid = Number.parseInt(fs.readFileSync(pidFile, "utf-8"), 10);
+		process.kill(fakePid, 0);
+	} finally {
+		if (fakePid !== undefined) {
+			try { process.kill(fakePid, "SIGKILL"); } catch { /* already stopped */ }
+		}
+		if (owner.exitCode === null) owner.kill("SIGKILL");
+	}
+});
+
+test("malformed optional observer metadata cannot break child execution", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+	const dir = tempDir();
+	const capture = path.join(dir, "capture.json");
+	const fakeOrca = writeCaptureOrca(dir);
+	const tab = createOrcaProgressTab({
+		cwd: dir,
+		runId: undefined,
+		agent: undefined,
+		index: undefined,
+		config: { enabled: true },
+		command: fakeOrca,
+		env: { ...process.env, ORCA_TEST_CAPTURE: capture },
+	} as never);
+	assert.ok(tab);
+	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");
+	removeProgressFiles("run-0-");
+});
+
+test("disabled Orca progress tabs do not invoke Orca", async () => {
+	const dir = tempDir();
+	const capture = path.join(dir, "capture.json");
+	const fakeOrca = writeCaptureOrca(dir);
+	const tab = createOrcaProgressTab({
+		cwd: dir,
+		runId: "disabled-run",
+		agent: "worker",
+		index: 0,
+		config: { enabled: false },
+		command: fakeOrca,
+		env: { ...process.env, ORCA_TEST_CAPTURE: capture },
+	});
+	assert.equal(tab, undefined);
+	await new Promise((resolve) => setTimeout(resolve, 100));
+	assert.equal(fs.existsSync(capture), false);
+});
+
+test("enabled tabs use a worktree sequence and successful Pi sessions get cleanup guidance", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+	const dir = tempDir();
+	const capture = path.join(dir, "capture.json");
+	const secondCapture = path.join(dir, "capture-2.json");
+	const fakeOrca = writeCaptureOrca(dir);
+	fs.mkdirSync(path.join(dir, ".git"));
+	const runId = `progress-${Date.now()}`;
+	const tab = createOrcaProgressTab({
+		cwd: dir,
+		runId,
+		agent: "worker",
+		index: 2,
+		config: { enabled: true },
+		command: fakeOrca,
+		env: { ...process.env, ORCA_TEST_CAPTURE: capture },
+	});
+	assert.ok(tab);
+	tab.append("starting\n");
+	tab.event({ type: "tool_execution_start", toolName: "read", args: { path: "README.md" } });
+	tab.event({ type: "message_end", message: { role: "assistant", content: [{ type: "text", text: "done output" }] } as never });
+	const sessionId = "019ffd40-4859-7015-94e4-7d15c31885ef";
+	const sessionFile = path.join(dir, `session file's ${sessionId}.jsonl`);
+	fs.writeFileSync(sessionFile, `${JSON.stringify({ type: "session", version: 3, id: sessionId })}\n`);
+	assert.equal(resolvePiSessionId(sessionFile), sessionId);
+	assert.equal(resolvePiSessionId(path.join(dir, `missing_${sessionId}.jsonl`)), undefined);
+	tab.finish("completed", sessionFile);
+
+	await waitForFile(capture);
+	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");
+	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 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");
+	assert.match(text, /starting/);
+	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.doesNotMatch(text, /find ~\/\.pi\/agent\/sessions/);
+
+	const nestedCwd = path.join(dir, "packages", "app");
+	fs.mkdirSync(nestedCwd, { recursive: true });
+	const secondTab = createOrcaProgressTab({
+		cwd: nestedCwd,
+		runId: `${runId}-second`,
+		agent: "worker",
+		index: 0,
+		config: { enabled: true },
+		command: fakeOrca,
+		env: { ...process.env, ORCA_TEST_CAPTURE: secondCapture },
+	});
+	assert.ok(secondTab);
+	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");
+	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");
+	assert.match(secondText, /failed/);
+	assert.doesNotMatch(secondText, /To remove the Pi session/);
+});
+
+test("viewer strips split terminal control sequences across poll ticks", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+	const dir = tempDir();
+	const capture = path.join(dir, "capture.json");
+	const fakeOrca = writeCaptureOrca(dir);
+	const runId = `progress-sanitize-${Date.now()}`;
+	const tab = createOrcaProgressTab({
+		cwd: dir,
+		runId,
+		agent: "worker",
+		index: 0,
+		config: { enabled: true },
+		command: fakeOrca,
+		env: { ...process.env, ORCA_TEST_CAPTURE: capture },
+	});
+	assert.ok(tab);
+	await waitForFile(capture);
+	const args = JSON.parse(fs.readFileSync(capture, "utf-8")) as string[];
+	const viewer = args[args.indexOf("--command") + 1]!;
+	const outputPromise = captureCommand(viewer, dir);
+	await new Promise((resolve) => setTimeout(resolve, 200));
+	tab.append("safe CSI \u001b[");
+	await new Promise((resolve) => setTimeout(resolve, 200));
+	tab.append("31mred OSC \u001b]0;secret");
+	await new Promise((resolve) => setTimeout(resolve, 200));
+	tab.append(" title\u0007visible\u0000\u0001\r\t\u007f\n");
+	tab.finish("failed");
+	const output = await outputPromise;
+	assert.match(output, /safe CSI red OSC visible\n/);
+	assert.doesNotMatch(output, /\u001b|31m|secret|title|\u0000|\u0001|\r|\t|\u007f/);
+});
+
+test("mirror output keeps small writes that hit stream backpressure before the byte limit", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+	const dir = tempDir();
+	const capture = path.join(dir, "capture.json");
+	const fakeOrca = writeCaptureOrca(dir);
+	const runId = `progress-backpressure-${Date.now()}`;
+	const tab = createOrcaProgressTab({
+		cwd: dir,
+		runId,
+		agent: "worker",
+		index: 0,
+		config: { enabled: true },
+		command: fakeOrca,
+		env: { ...process.env, ORCA_TEST_CAPTURE: capture },
+	});
+	assert.ok(tab);
+	for (let index = 0; index < 2_000; index++) tab.append(`line-${index.toString().padStart(4, "0")} ${"x".repeat(80)}\n`);
+	tab.finish("completed");
+	const log = progressFile(`${runId}-0-`, ".log");
+	await waitForFile(log.replace(/\.log$/, ".done"));
+	const text = fs.readFileSync(log, "utf-8");
+	assert.match(text, /line-1999/);
+	assert.doesNotMatch(text, /progress mirror truncated/);
+});
+
+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");
+	const fakeOrca = writeCaptureOrca(dir);
+	const runId = `progress-bounded-${Date.now()}`;
+	const tab = createOrcaProgressTab({
+		cwd: dir,
+		runId,
+		agent: "worker",
+		index: 0,
+		config: { enabled: true },
+		command: fakeOrca,
+		env: { ...process.env, ORCA_TEST_CAPTURE: capture },
+	});
+	assert.ok(tab);
+	tab.append("x".repeat(2 * 1024 * 1024));
+	tab.append("must be dropped");
+	tab.finish("completed");
+	const log = progressFile(`${runId}-0-`, ".log");
+	await waitForFile(log.replace(/\.log$/, ".done"));
+	assert.ok(fs.statSync(log).size <= 1024 * 1024);
+	const text = fs.readFileSync(log, "utf-8");
+	assert.match(text, /progress mirror truncated at 1048576 bytes/);
+	assert.doesNotMatch(text, /must be dropped/);
+});

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

@@ -69,8 +69,11 @@ test("published extension APIs use supported package entrypoints", async () => {
 	assert.equal(backgroundWork.BACKGROUND_WORK_PROTOCOL_VERSION, 1);
 	assert.equal(backgroundWork.BACKGROUND_WORK_REGISTRY_KEY, "pi-subagents.background-work.v1");
 	const externalRuns = await import("pi-subagents/external-runs");
-	assert.equal(externalRuns.EXTERNAL_RUN_REGISTRY_VERSION, 1);
-	assert.equal(typeof externalRuns.registerExternalRunProvider, "function");
+	assert.equal(externalRuns.EXTERNAL_RUN_REGISTRY_VERSION, 2);
+	assert.equal(typeof externalRuns.registerExternalRun, "function");
+	assert.equal(typeof externalRuns.updateExternalRun, "function");
+	assert.equal(typeof externalRuns.snapshotExternalRuns, "function");
+	assert.equal(typeof externalRuns.unregisterExternalRun, "function");
 	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");

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

@@ -825,7 +825,7 @@ describe("buildPiArgs system prompt mode wiring", () => {
 			tools: reviewer.tools,
 		});
 
-		assert.equal(args[args.indexOf("--tools") + 1], "read,grep,find,ls,intercom");
+		assert.equal(args[args.indexOf("--tools") + 1], "read,grep,find,ls");
 		assert.doesNotMatch(args[args.indexOf("--tools") + 1] ?? "", /\b(?:bash|edit|write)\b/);
 	});