@selesai/code 0.9.10 → 0.9.12

package/dist/extensions/pi-subagents/test/integration/async-job-tracker.test.ts

@@ -3,7 +3,9 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { afterEach, describe, it } from "node:test";
 import { getArtifactsDir } from "../../src/shared/artifacts.ts";
+import { SUBAGENT_CHILD_STATUS_EVENT } from "../../src/shared/types.ts";
 import { updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
+import { SubagentFleetComponent } from "../../src/tui/fleet.ts";
 import { createNestedRoute } from "../../src/runs/shared/nested-events.ts";
 import { createTempDir, removeTempDir, tryImport } from "../support/helpers.ts";
 
@@ -17,6 +19,9 @@ interface AsyncJobTrackerModule {
 			pollIntervalMs?: number;
 			resultsDir?: string;
 			widgetEnabled?: boolean;
+			platform?: NodeJS.Platform;
+			onJobTerminal?: () => void;
+			watch?: typeof fs.watch;
 			kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
 			now?: () => number;
 		},
@@ -36,6 +41,7 @@ type AsyncJobTracker = ReturnType<AsyncJobTrackerModule["createAsyncJobTracker"]
 const activeTrackers = new Set<AsyncJobTracker>();
 
 function createTracker(...args: Parameters<AsyncJobTrackerModule["createAsyncJobTracker"]>): AsyncJobTracker {
+	args[3] = { platform: "linux", ...(args[3] ?? {}) };
 	const tracker = trackerMod!.createAsyncJobTracker(...args);
 	activeTrackers.add(tracker);
 	return tracker;
@@ -247,6 +253,34 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		}
 	});
 
+	it("rebuilds the async widget on quiet animation ticks without a UI requestRender bridge", async () => {
+		const asyncRoot = createTempDir("pi-async-job-widget-animation-");
+		try {
+			const state = createState();
+			const ui = createUiContext();
+			const recorder = createEventRecorder();
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, { pollIntervalMs: 10 });
+			const ctx = {
+				...ui.ctx,
+				ui: {
+					...ui.ctx.ui,
+					requestRender: undefined,
+				},
+			};
+
+			tracker.resetJobs(ctx as never);
+			tracker.handleStarted({ id: "run-animating", asyncDir: path.join(asyncRoot, "run-animating"), agent: "worker" });
+			await waitForCondition(() => state.asyncJobs.get("run-animating")?.status === "running", "initial running status refresh");
+			const widgetCount = ui.widgets.length;
+
+			await waitForCondition(() => ui.widgets.length > widgetCount, "animation tick widget rebuild", 1300);
+			assert.equal(ui.renderRequests, 0, "test fixture requestRender bridge must stay unavailable");
+			assert.notEqual(ui.widgets.at(-1), undefined, "running widget should be rebuilt, not cleared");
+		} finally {
+			removeTempDir(asyncRoot);
+		}
+	});
+
 	it("restores active async runs into the widget after reset", async () => {
 		const asyncRoot = createTempDir("pi-async-job-restore-");
 		try {
@@ -316,6 +350,20 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			assert.ok(state.poller, "expected restored active jobs to start polling");
 			assert.ok(ui.renderRequests >= 2, "expected reset and restore to request widget renders");
 			assert.equal(typeof ui.widgets.at(-1), "function", "expected restored jobs to render the widget");
+
+			const component = new SubagentFleetComponent(
+				{ terminal: { rows: 28, columns: 100 }, requestRender() {} } as never,
+				ui.ctx.ui.theme as never,
+				state as never,
+				() => {},
+				{ refreshMs: 60_000 },
+			);
+			try {
+				assert.ok(component.render(100).some((line) => line.includes("Restored custom cwd transcript")));
+			} finally {
+				component.dispose();
+			}
+
 			await new Promise((resolve) => setTimeout(resolve, 30));
 			assert.equal(recorder.events.length, 0, "historical control events should not be replayed during restore");
 		} finally {
@@ -388,6 +436,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				mode: "workflow",
 				state: "running",
 				sessionId: "session-workflow",
+				sessionRoot: "/trusted/workflow-sessions",
 				startedAt: 1000,
 				lastUpdate: 2000,
 				steps: [{ agent: "scan", label: "scan", status: "running" }],
@@ -399,6 +448,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, { pollIntervalMs: 60_000 });
 			tracker.restoreActiveJobs();
 			assert.deepEqual(state.asyncJobs.get("workflow-run")?.workflow?.emits, [{ stage: "scan" }]);
+			assert.equal(state.asyncJobs.get("workflow-run")?.sessionRoot, "/trusted/workflow-sessions");
 
 			fs.writeFileSync(statusPath, JSON.stringify({
 				runId: "workflow-run",
@@ -446,6 +496,83 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		}
 	});
 
+	it("does not request quiet running widget renders on every liveness tick", async () => {
+		const asyncRoot = createTempDir("pi-async-job-quiet-widget-");
+		try {
+			const runDir = path.join(asyncRoot, "quiet-run");
+			fs.mkdirSync(runDir, { recursive: true });
+			fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
+				runId: "quiet-run",
+				mode: "single",
+				state: "running",
+				startedAt: 1000,
+				lastUpdate: 1000,
+				steps: [{ agent: "worker", status: "running" }],
+			}), "utf-8");
+			const state = createState();
+			const ui = createUiContext();
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, { pollIntervalMs: 10 });
+			tracker.resetJobs(ui.ctx as never);
+			tracker.handleStarted({ id: "quiet-run", asyncDir: runDir, agent: "worker" });
+
+			await waitForCondition(() => state.asyncJobs.get("quiet-run")?.status === "running", "quiet running job refresh");
+			const renderRequests = ui.renderRequests;
+			await new Promise((resolve) => setTimeout(resolve, 120));
+
+			assert.equal(ui.renderRequests, renderRequests);
+			tracker.resetJobs();
+		} finally {
+			removeTempDir(asyncRoot);
+		}
+	});
+
+	it("uses polling without native watchers on Darwin and fires terminal delivery hooks once", async () => {
+		const asyncRoot = createTempDir("pi-async-job-darwin-poll-");
+		try {
+			const runDir = path.join(asyncRoot, "darwin-run");
+			fs.mkdirSync(runDir, { recursive: true });
+			fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
+				runId: "darwin-run",
+				mode: "single",
+				state: "running",
+				startedAt: 1000,
+				lastUpdate: 1000,
+				steps: [{ agent: "worker", status: "running" }],
+			}), "utf-8");
+			const state = createState();
+			let nativeWatchCalls = 0;
+			let terminalHooks = 0;
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, {
+				platform: "darwin",
+				pollIntervalMs: 10,
+				onJobTerminal: () => terminalHooks++,
+				watch: (() => {
+					nativeWatchCalls++;
+					throw new Error("Darwin tracker must not create native watchers");
+				}) as typeof fs.watch,
+			});
+			tracker.handleStarted({ id: "darwin-run", asyncDir: runDir, agent: "worker" });
+
+			await waitForCondition(() => state.asyncJobs.get("darwin-run")?.status === "running", "darwin polling started");
+			fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
+				runId: "darwin-run",
+				mode: "single",
+				state: "complete",
+				startedAt: 1000,
+				lastUpdate: 2000,
+				steps: [{ agent: "worker", status: "complete" }],
+			}), "utf-8");
+
+			await waitForCondition(() => state.asyncJobs.get("darwin-run")?.status === "complete", "darwin terminal refresh");
+			await new Promise((resolve) => setTimeout(resolve, 30));
+			assert.equal(nativeWatchCalls, 0);
+			assert.equal(terminalHooks, 1);
+			tracker.resetJobs();
+		} finally {
+			removeTempDir(asyncRoot);
+		}
+	});
+
 	it("refreshes nested async children from event files before the liveness sweep", async () => {
 		const asyncRoot = createTempDir("pi-async-job-nested-events-");
 		const nestedRoute = createNestedRoute("run-nested-events");
@@ -705,7 +832,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		}
 	});
 
-	it("repaints unchanged running widgets without rebuilding them and stops at terminal status", async () => {
+	it("rebuilds unchanged running widgets for quiet animation ticks and stops at terminal status", async () => {
 		const asyncRoot = createTempDir("pi-async-job-tracker-");
 		let tracker: ReturnType<AsyncJobTrackerModule["createAsyncJobTracker"]> | undefined;
 		try {
@@ -750,8 +877,8 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				},
 			})}\n`, "utf-8");
 			await waitForCondition(() => recorder.events.some((event) => event.channel === "subagent:control-event"), "control event delivery");
-			await waitForCondition(() => ui.renderRequests > requestsAfterStatusLoaded, "running widget cadence repaint");
-			assert.equal(ui.widgets.length, widgetsAfterStatusLoaded, "unchanged running status must not replace the widget component");
+			await waitForCondition(() => ui.widgets.length > widgetsAfterStatusLoaded, "running widget cadence rebuild");
+			assert.ok(ui.renderRequests > requestsAfterStatusLoaded, "running widget cadence rebuild should request a repaint when the bridge supports it");
 
 			writeStatus(3000, 1);
 			await waitForCondition(() => state.asyncJobs.get("run-unchanged")?.toolCount === 1, "changed status load");
@@ -759,8 +886,10 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 
 			writeStatus(4000, 1, "complete");
 			await waitForCondition(() => state.asyncJobs.get("run-unchanged")?.status === "complete", "terminal status load");
+			const widgetsAfterTerminal = ui.widgets.length;
 			const requestsAfterTerminal = ui.renderRequests;
 			await new Promise((resolve) => setTimeout(resolve, 35));
+			assert.equal(ui.widgets.length, widgetsAfterTerminal, "terminal-only jobs must not rebuild on the cadence");
 			assert.equal(ui.renderRequests, requestsAfterTerminal, "terminal-only jobs must not request cadence repaints");
 		} finally {
 			tracker?.resetJobs();
@@ -893,19 +1022,21 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				asyncDir: runDir,
 				pid: 12345,
 				sessionId: "session-current",
+				completionOwnerId: "owner-current",
 				mode: "parallel",
 				agents: ["scout", "reviewer", "worker"],
 				chainStepCount: 1,
 				parallelGroups: [{ start: 0, count: 3, stepIndex: 0 }],
 			});
 
-			await new Promise((resolve) => setTimeout(resolve, 80));
+			await waitForCondition(() => state.asyncJobs.size === 0, "startup-crash repair cleanup");
 
 			assert.equal(state.asyncJobs.size, 0);
 			const status = JSON.parse(fs.readFileSync(path.join(runDir, "status.json"), "utf-8"));
 			const result = JSON.parse(fs.readFileSync(path.join(resultsDir, "run-no-status.json"), "utf-8"));
 			assert.equal(status.state, "failed");
 			assert.equal(status.sessionId, "session-current");
+			assert.equal(status.completionOwnerId, "owner-current");
 			assert.equal(status.mode, "parallel");
 			assert.equal(status.currentStep, 0);
 			assert.equal(status.chainStepCount, 1);
@@ -917,6 +1048,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			]);
 			assert.equal(result.success, false);
 			assert.equal(result.sessionId, "session-current");
+			assert.equal(result.completionOwnerId, "owner-current");
 			assert.ok(ui.renderRequests > 0, "expected startup-crash repair cleanup to request a rerender");
 		} finally {
 			removeTempDir(asyncRoot);
@@ -1538,4 +1670,62 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			removeTempDir(asyncRoot);
 		}
 	});
+
+	it("bridges async child status events from events.jsonl to the parent event bus", async () => {
+		const asyncRoot = createTempDir("pi-async-job-tracker-");
+		try {
+			const runDir = path.join(asyncRoot, "run-child-status");
+			fs.mkdirSync(runDir, { recursive: true });
+			fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
+				runId: "run-child-status",
+				mode: "parallel",
+				state: "running",
+				startedAt: Date.now() - 1000,
+				lastUpdate: Date.now(),
+				steps: [{ agent: "worker", status: "running", workflowKey: "slow" }],
+			}), "utf-8");
+			fs.writeFileSync(path.join(runDir, "events.jsonl"), `${JSON.stringify({
+				type: "subagent.child-status",
+				version: 1,
+				runId: "run-child-status",
+				childId: "slow",
+				status: "stopped",
+				ts: 123,
+				reason: "user",
+				stepIndex: 0,
+				agent: "worker",
+				workflowKey: "slow",
+			})}\n`, "utf-8");
+
+			const state = createState();
+			const recorder = createEventRecorder();
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
+				pollIntervalMs: 10,
+			});
+			tracker.handleStarted({ id: "run-child-status", asyncDir: runDir, agent: "workflow" });
+
+			await waitForCondition(
+				() => recorder.events.some((event) => event.channel === SUBAGENT_CHILD_STATUS_EVENT),
+				"child status event",
+			);
+
+			const event = recorder.events.find((entry) => entry.channel === SUBAGENT_CHILD_STATUS_EVENT)!;
+			assert.deepEqual(event.data, {
+				type: "subagent.child-status",
+				version: 1,
+				runId: "run-child-status",
+				childId: "slow",
+				status: "stopped",
+				ts: 123,
+				reason: "user",
+				source: "async",
+				asyncDir: runDir,
+				stepIndex: 0,
+				agent: "worker",
+				workflowKey: "slow",
+			});
+		} finally {
+			removeTempDir(asyncRoot);
+		}
+	});
 });

package/dist/extensions/pi-subagents/test/integration/async-status.test.ts

@@ -1,17 +1,21 @@
 import assert from "node:assert/strict";
-import * as fs from "node:fs";
+import fsDefault, * as fs from "node:fs";
+import { syncBuiltinESMExports } from "node:module";
 import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
 import { formatAsyncRunList, listAsyncRuns } from "../../src/runs/background/async-status.ts";
 import { ACTIVE_RUN_INDEX_DIR, DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS, updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
+import { encodeIndexSegment } from "../../src/runs/background/index-segment.ts";
+import { TERMINAL_RUN_INDEX_DIR } from "../../src/runs/background/terminal-run-index.ts";
 import { claimRunFanoutBatch, createRunFanoutBudget, writeRunFanoutBudgetDescriptor } from "../../src/runs/shared/run-fanout-budget.ts";
 
 function createAsyncDir(root: string, id: string, status: Record<string, unknown>): string {
 	const dir = path.join(root, id);
 	fs.mkdirSync(dir, { recursive: true });
-	fs.writeFileSync(path.join(dir, "status.json"), JSON.stringify(status), "utf-8");
-	if (status.state === "queued" || status.state === "running") updateActiveRunIndex(dir, status.state);
+	const persisted = status.sessionId === undefined ? { ...status, sessionId: "session-a" } : status;
+	fs.writeFileSync(path.join(dir, "status.json"), JSON.stringify(persisted), "utf-8");
+	updateActiveRunIndex(dir, persisted.state as "queued" | "running" | "complete" | "failed" | "paused" | "stopped" | "rejected");
 	return dir;
 }
 
@@ -341,7 +345,7 @@ describe("async status helpers", () => {
 		fs.writeFileSync(path.join(dir, "status.json"), "{not-json", "utf-8");
 		try {
 			assert.throws(
-				() => listAsyncRuns(root),
+				() => listAsyncRuns(root, { repairScan: true }),
 				/Failed to parse async status file/,
 			);
 		} finally {
@@ -608,6 +612,57 @@ describe("async status helpers", () => {
 		}
 	});
 
+	it("lists recent terminal runs from time-sortable session markers", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-terminal-index-"));
+		try {
+			for (let index = 1; index <= 3; index++) {
+				createAsyncDir(root, `terminal-${index}`, {
+					runId: `terminal-${index}`,
+					sessionId: "session-a",
+					mode: "single",
+					state: "complete",
+					startedAt: index,
+					endedAt: index * 100,
+					steps: [{ agent: "worker", status: "complete" }],
+				});
+			}
+
+			const runs = listAsyncRuns(root, { sessionId: "session-a", states: ["complete"], entryLimit: 2, reconcile: false });
+			assert.deepEqual(runs.map((run) => run.id), ["terminal-3", "terminal-2"]);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("removes invalid terminal markers while reading the advisory index", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-terminal-heal-"));
+		try {
+			const marker = path.join(root, TERMINAL_RUN_INDEX_DIR, encodeIndexSegment("session-a"), "0000000000000100-missing.json");
+			fs.mkdirSync(path.dirname(marker), { recursive: true });
+			fs.writeFileSync(marker, JSON.stringify({ version: 1, runId: "missing", sessionId: "session-a", endedAt: 100 }));
+
+			assert.deepEqual(listAsyncRuns(root, { sessionId: "session-a", states: ["complete"], reconcile: false }), []);
+			assert.equal(fs.existsSync(marker), false);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("does not enumerate the async root for full-id or unsafe-prefix misses", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-exact-miss-"));
+		const originalReaddirSync = fsDefault.readdirSync;
+		try {
+			fsDefault.readdirSync = (() => { throw new Error("async root enumerated"); }) as typeof fsDefault.readdirSync;
+			syncBuiltinESMExports();
+			assert.deepEqual(listAsyncRuns(root, { runId: "12345678-1234-1234-1234-123456789012", reconcile: false }), []);
+			assert.deepEqual(listAsyncRuns(root, { runId: "short", reconcile: false }), []);
+		} finally {
+			fsDefault.readdirSync = originalReaddirSync;
+			syncBuiltinESMExports();
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("keeps terminal active markers until observed process-terminal proof releases them", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-index-prune-"));
 		try {

package/dist/extensions/pi-subagents/test/integration/error-handling.test.ts

@@ -25,14 +25,11 @@ import {
 // Top-level await
 const utils = await tryImport<any>("./src/shared/utils.ts");
 const execution = await tryImport<any>("./src/runs/foreground/execution.ts");
-const chainMod = await tryImport<any>("./src/runs/foreground/chain-execution.ts");
 
 const piAvailable = !!(execution && utils);
-const chainAvailable = !!chainMod;
 
 const runSync = execution?.runSync;
 const detectSubagentError = utils?.detectSubagentError;
-const executeChain = chainMod?.executeChain;
 
 // ---------------------------------------------------------------------------
 // detectSubagentError
@@ -226,77 +223,3 @@ describe("runSync error handling", { skip: !piAvailable ? "pi packages not avail
 		assert.ok(elapsed < 5000, `should abort early, took ${elapsed}ms`);
 	});
 });
-
-// ---------------------------------------------------------------------------
-// Chain error propagation
-// ---------------------------------------------------------------------------
-
-describe("chain error propagation", { skip: !chainAvailable ? "chain module not available" : undefined }, () => {
-	let tempDir: string;
-	let mockPi: MockPi;
-
-	before(() => {
-		mockPi = createMockPi();
-		mockPi.install();
-	});
-
-	after(() => {
-		mockPi.uninstall();
-	});
-
-	beforeEach(() => {
-		tempDir = createTempDir();
-		mockPi.reset();
-	});
-
-	afterEach(() => {
-		removeTempDir(tempDir);
-	});
-
-	function makeChainParams(chain: any[], agents: any[]) {
-		return {
-			chain,
-			agents,
-			ctx: makeMinimalCtx(tempDir),
-			runId: "test-err",
-			shareEnabled: false,
-			sessionDirForIndex: () => undefined,
-			artifactsDir: path.join(tempDir, "artifacts"),
-			artifactConfig: { enabled: false },
-			clarify: false,
-		};
-	}
-
-	it("preserves error context from failed step", async () => {
-		mockPi.onCall({ exitCode: 1, stderr: "Step 1 exploded" });
-		const agents = [makeAgent("step1"), makeAgent("step2")];
-
-		const result = await executeChain(
-			makeChainParams(
-				[{ agent: "step1", task: "Fail here" }, { agent: "step2" }],
-				agents,
-			),
-		);
-
-		assert.ok(result.isError);
-		const failedResult = result.details.results[0];
-		assert.equal(failedResult.exitCode, 1);
-		assert.ok(failedResult.error?.includes("exploded"));
-	});
-
-	it("reports currentStepIndex on failure", async () => {
-		mockPi.onCall({ exitCode: 1 });
-		const agents = [makeAgent("a"), makeAgent("b"), makeAgent("c")];
-
-		const result = await executeChain(
-			makeChainParams(
-				[{ agent: "a", task: "First" }, { agent: "b" }, { agent: "c" }],
-				agents,
-			),
-		);
-
-		assert.ok(result.isError);
-		assert.equal(result.details.currentStepIndex, 0);
-		assert.equal(result.details.results.length, 1);
-	});
-});

package/dist/extensions/pi-subagents/test/integration/external-cli-runner.test.ts

@@ -4,16 +4,32 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { afterEach, describe, it } from "node:test";
-import { fileURLToPath } from "node:url";
+import { resultFilesForSession } from "../../src/runs/background/result-files.ts";
+import { TEMP_ROOT_DIR } from "../../src/shared/types.ts";
+import { writeNodeCommand } from "../support/node-command.ts";
 
 const tempDirs: string[] = [];
 afterEach(() => {
 	for (const dir of tempDirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
+	const progressDir = path.join(TEMP_ROOT_DIR, "orca-progress");
+	if (fs.existsSync(progressDir)) {
+		for (const name of fs.readdirSync(progressDir)) {
+			if (name.startsWith("orca-observer-external-")) fs.rmSync(path.join(progressDir, name), { force: true });
+		}
+	}
 });
 
-function runProcess(command: string, args: string[], cwd: string): Promise<number | null> {
+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 runProcess(command: string, args: string[], cwd: string, env: NodeJS.ProcessEnv = process.env): Promise<number | null> {
 	return new Promise((resolve, reject) => {
-		const child = spawn(command, args, { cwd, stdio: "inherit", shell: false });
+		const child = spawn(command, args, { cwd, stdio: "inherit", shell: false, env });
 		child.once("error", reject);
 		child.once("close", resolve);
 	});
@@ -29,6 +45,7 @@ describe("external CLI async lifecycle", () => {
 		const configPath = path.join(dir, "config.json");
 		fs.writeFileSync(configPath, JSON.stringify({
 			id: "external-lifecycle",
+			sessionId: "session-external",
 			steps: [{
 				agent: "external",
 				task: "Task text",
@@ -40,15 +57,13 @@ describe("external CLI async lifecycle", () => {
 			}],
 			resultPath,
 			cwd: dir,
-			sessionId: "session-external",
 			placeholder: "{previous}",
 			artifactConfig: { enabled: false },
 			asyncDir,
 			resultMode: "single",
 		}));
 		const repo = path.resolve(import.meta.dirname, "../..");
-		const jitiCli = path.join(path.dirname(fileURLToPath(import.meta.resolve("jiti/package.json"))), "lib", "jiti-cli.mjs");
-		const exitCode = await runProcess(process.execPath, [jitiCli, path.join(repo, "src/runs/background/subagent-runner.ts"), configPath], repo);
+		const exitCode = await runProcess(process.execPath, [path.join(repo, "node_modules/jiti/lib/jiti-cli.mjs"), path.join(repo, "src/runs/background/subagent-runner.ts"), configPath], repo);
 		assert.equal(exitCode, 0);
 		const status = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8"));
 		assert.equal(status.state, "complete");
@@ -62,4 +77,90 @@ describe("external CLI async lifecycle", () => {
 		assert.equal(result.success, true);
 		assert.equal(result.results[0].runner.type, "external-cli");
 	});
+
+	it("keeps terminal status recoverable when public result publish fails", async () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-external-pending-result-"));
+		tempDirs.push(dir);
+		const asyncDir = path.join(dir, "async");
+		fs.mkdirSync(asyncDir);
+		const resultPath = path.join(dir, "result.json");
+		fs.mkdirSync(resultPath);
+		const configPath = path.join(dir, "config.json");
+		fs.writeFileSync(configPath, JSON.stringify({
+			id: "external-pending-result",
+			sessionId: "session-external",
+			steps: [{
+				agent: "external",
+				task: "Task text",
+				runner: { type: "external-cli", command: process.execPath, args: ["-e", "process.stdout.write('ok')"] },
+				inheritProjectContext: false,
+				inheritSkills: false,
+			}],
+			resultPath,
+			cwd: dir,
+			placeholder: "{previous}",
+			artifactConfig: { enabled: false },
+			asyncDir,
+			resultMode: "single",
+		}));
+		const repo = path.resolve(import.meta.dirname, "../..");
+		const exitCode = await runProcess(process.execPath, [path.join(repo, "node_modules/jiti/lib/jiti-cli.mjs"), path.join(repo, "src/runs/background/subagent-runner.ts"), configPath], repo);
+		assert.equal(exitCode, 0);
+		const status = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf-8"));
+		assert.equal(status.state, "complete");
+
+		fs.rmSync(resultPath, { recursive: true, force: true });
+		assert.deepEqual(resultFilesForSession(dir, "session-external"), ["result.json"]);
+		const result = JSON.parse(fs.readFileSync(resultPath, "utf-8"));
+		assert.equal(result.success, true);
+	});
+
+	it("mirrors a child into Orca without replacing its configured runner", { skip: process.platform === "win32" ? "Orca progress tabs are not supported on Windows" : undefined }, async () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-orca-observer-"));
+		tempDirs.push(dir);
+		const asyncDir = path.join(dir, "async");
+		const agentDir = path.join(dir, "agent-dir");
+		const capture = path.join(dir, "orca-args.json");
+		const fakeOrca = writeNodeCommand(dir, "orca", "require('fs').writeFileSync(process.env.ORCA_TEST_CAPTURE, JSON.stringify(process.argv.slice(2)))");
+		fs.mkdirSync(asyncDir);
+		fs.mkdirSync(path.join(agentDir, "extensions", "subagent"), { recursive: true });
+		fs.writeFileSync(path.join(agentDir, "extensions", "subagent", "config.json"), JSON.stringify({ orcaProgressTabs: { enabled: true } }));
+		const resultPath = path.join(dir, "result.json");
+		const configPath = path.join(dir, "config.json");
+		fs.writeFileSync(configPath, JSON.stringify({
+			id: "orca-observer-external",
+			sessionId: "session-orca-external",
+			steps: [{
+				agent: "external",
+				task: "Task text",
+				runner: { type: "external-cli", command: process.execPath, args: ["-e", "process.stdout.write('native runner output')"] },
+				systemPrompt: "System text",
+				systemPromptMode: "replace",
+				inheritProjectContext: false,
+				inheritSkills: false,
+			}],
+			resultPath,
+			cwd: dir,
+			placeholder: "{previous}",
+			artifactConfig: { enabled: false },
+			asyncDir,
+			resultMode: "single",
+		}));
+		const repo = path.resolve(import.meta.dirname, "../..");
+		const exitCode = await runProcess(
+			process.execPath,
+			[path.join(repo, "node_modules/jiti/lib/jiti-cli.mjs"), path.join(repo, "src/runs/background/subagent-runner.ts"), configPath],
+			repo,
+			{ ...process.env, SELESAI_CODING_AGENT_DIR: agentDir, SELESAI_SUBAGENT_ORCA_BINARY: fakeOrca, ORCA_TEST_CAPTURE: capture },
+		);
+		assert.equal(exitCode, 0);
+		const result = JSON.parse(fs.readFileSync(resultPath, "utf-8"));
+		assert.equal(result.results[0].runner.type, "external-cli");
+		assert.match(result.results[0].output, /native runner output/);
+		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.match(args[args.indexOf("--title") + 1], /subagents · external/);
+	});
 });