@selesai/code 0.8.6 → 0.8.8

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

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { afterEach, describe, it } from "node:test";
-import { getProjectArtifactsDir } from "../../src/shared/artifacts.ts";
+import { getArtifactsDir } from "../../src/shared/artifacts.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";
@@ -151,6 +151,55 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		}
 	});
 
+	it("stores only parent-registered session roots from async start events", () => {
+		const asyncRoot = createTempDir("pi-async-job-tracker-session-root-");
+		try {
+			const state = createState();
+			const recorder = createEventRecorder();
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot);
+			const sessionRoot = path.join(asyncRoot, "custom-sessions");
+			state.liveAsyncSessionRoots = new Map([["run-custom-session", sessionRoot]]);
+
+			tracker.handleStarted({ id: "run-custom-session", asyncDir: path.join(asyncRoot, "run-custom-session"), agent: "worker", sessionRoot: path.join(asyncRoot, "forged") });
+
+			assert.equal(state.asyncJobs.get("run-custom-session")?.sessionRoot, sessionRoot);
+			assert.equal(state.liveAsyncSessionRoots.has("run-custom-session"), false);
+		} finally {
+			removeTempDir(asyncRoot);
+		}
+	});
+
+	it("ignores unregistered session roots from async start events", () => {
+		const asyncRoot = createTempDir("pi-async-job-tracker-forged-session-root-");
+		try {
+			const state = createState();
+			const recorder = createEventRecorder();
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot);
+
+			tracker.handleStarted({ id: "run-forged-session", asyncDir: path.join(asyncRoot, "run-forged-session"), agent: "worker", sessionRoot: path.join(asyncRoot, "forged") });
+
+			assert.equal(state.asyncJobs.get("run-forged-session")?.sessionRoot, undefined);
+		} finally {
+			removeTempDir(asyncRoot);
+		}
+	});
+
+	it("clears pending live session roots on reset", () => {
+		const asyncRoot = createTempDir("pi-async-job-tracker-reset-session-root-");
+		try {
+			const state = createState();
+			const recorder = createEventRecorder();
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot);
+			state.liveAsyncSessionRoots = new Map([["run-pending", path.join(asyncRoot, "sessions")]]);
+
+			tracker.resetJobs();
+
+			assert.equal(state.liveAsyncSessionRoots.size, 0);
+		} finally {
+			removeTempDir(asyncRoot);
+		}
+	});
+
 	it("removes completed jobs after retention and requests a rerender", async () => {
 		const asyncRoot = createTempDir("pi-async-job-tracker-");
 		try {
@@ -204,10 +253,12 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		try {
 			const runDir = path.join(asyncRoot, "run-restored");
 			const customCwd = path.join(asyncRoot, "custom-cwd");
-			const artifactsRoot = getProjectArtifactsDir(customCwd);
+			const sessionFile = path.join(asyncRoot, "sessions", "session-restored.jsonl");
+			const artifactsRoot = getArtifactsDir(sessionFile, customCwd);
 			const transcriptPath = path.join(artifactsRoot, "run-restored_reviewer_transcript.jsonl");
 			fs.mkdirSync(runDir, { recursive: true });
 			fs.mkdirSync(artifactsRoot, { recursive: true });
+			fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
 			fs.writeFileSync(transcriptPath, `${JSON.stringify({ recordType: "message", role: "assistant", text: "Restored custom cwd transcript" })}\n`, "utf-8");
 			fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
 				runId: "run-restored",
@@ -215,6 +266,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				state: "running",
 				sessionId: "session-restored",
 				cwd: customCwd,
+				sessionFile,
 				startedAt: 1000,
 				lastUpdate: 2000,
 				currentStep: 1,
@@ -292,8 +344,9 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		const routeRoot = path.dirname(nestedRoute.eventSink);
 		try {
 			const runDir = path.join(asyncRoot, "run-restored-nested");
+			const statusPath = path.join(runDir, "status.json");
 			fs.mkdirSync(runDir, { recursive: true });
-			fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
+			const statusPayload = {
 				runId: "run-restored-nested",
 				mode: "single",
 				state: "running",
@@ -301,7 +354,8 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				startedAt: 1000,
 				lastUpdate: 2000,
 				steps: [{ agent: "worker", status: "running" }],
-			}), "utf-8");
+			};
+			fs.writeFileSync(statusPath, JSON.stringify(statusPayload), "utf-8");
 			updateActiveRunIndex(runDir, "running");
 			const state = createState();
 			state.currentSessionId = "session-restored-nested";
@@ -327,8 +381,9 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 					agent: "nested-worker",
 				},
 			}), "utf-8");
+			fs.writeFileSync(statusPath, JSON.stringify({ ...statusPayload, lastUpdate: 3001 }), "utf-8");
 
-			await waitForCondition(() => state.asyncJobs.get("run-restored-nested")?.nestedChildren?.[0]?.id === "nested-child", "restored evented nested child refresh", 1000);
+			await waitForCondition(() => state.asyncJobs.get("run-restored-nested")?.nestedChildren?.[0]?.id === "nested-child", "restored evented nested child refresh", 3000);
 			assert.equal(state.asyncJobs.get("run-restored-nested")?.steps?.[0]?.children?.[0]?.id, "nested-child");
 			tracker.resetJobs();
 		} finally {
@@ -413,14 +468,16 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		try {
 			const runDir = path.join(asyncRoot, "run-nested-events");
 			fs.mkdirSync(runDir, { recursive: true });
-			fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
+			const statusPath = path.join(runDir, "status.json");
+			const statusPayload = {
 				runId: "run-nested-events",
 				mode: "single",
 				state: "running",
 				startedAt: 1000,
 				lastUpdate: 2000,
 				steps: [{ agent: "worker", status: "running" }],
-			}), "utf-8");
+			};
+			fs.writeFileSync(statusPath, JSON.stringify(statusPayload), "utf-8");
 			const state = createState();
 			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, { pollIntervalMs: 60_000 });
 			tracker.handleStarted({ id: "run-nested-events", asyncDir: runDir, agent: "worker", nestedRoute });
@@ -443,8 +500,9 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 					agent: "nested-worker",
 				},
 			}), "utf-8");
+			fs.writeFileSync(statusPath, JSON.stringify({ ...statusPayload, lastUpdate: 3000 }), "utf-8");
 
-			await waitForCondition(() => state.asyncJobs.get("run-nested-events")?.nestedChildren?.[0]?.id === "nested-child", "evented nested child refresh", 1000);
+			await waitForCondition(() => state.asyncJobs.get("run-nested-events")?.nestedChildren?.[0]?.id === "nested-child", "evented nested child refresh", 3000);
 			assert.equal(state.asyncJobs.get("run-nested-events")?.steps?.[0]?.children?.[0]?.id, "nested-child");
 			tracker.resetJobs();
 		} finally {
@@ -798,6 +856,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				runId: "run-stale",
 				mode: "single",
 				state: "running",
+				sessionId: "session-stale",
 				pid: 12345,
 				startedAt: Date.now() - 1000,
 				lastUpdate: Date.now() - 1000,
@@ -815,7 +874,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				now: () => Date.now(),
 			});
 			tracker.resetJobs(ui.ctx as never);
-			tracker.handleStarted({ id: "run-stale", asyncDir: runDir, agent: "worker" });
+			tracker.handleStarted({ id: "run-stale", asyncDir: runDir, agent: "worker", sessionId: "session-stale" });
 
 			await waitForCondition(() => state.asyncJobs.size === 0, "stale async job cleanup");
 

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

@@ -4,7 +4,7 @@ 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, updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
+import { ACTIVE_RUN_INDEX_DIR, DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS, updateActiveRunIndex } from "../../src/runs/background/active-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 {
@@ -376,6 +376,7 @@ describe("async status helpers", () => {
 		try {
 			const asyncDir = createAsyncDir(root, "run-stale", {
 				runId: "run-stale",
+				sessionId: "session-stale",
 				mode: "single",
 				state: "running",
 				pid: 12345,
@@ -640,4 +641,29 @@ describe("async status helpers", () => {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
 	});
+
+	it("prunes old terminal active markers without process-terminal proof", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-status-index-aged-prune-"));
+		try {
+			const asyncDir = createAsyncDir(root, "finished", {
+				runId: "finished",
+				mode: "single",
+				state: "complete",
+				startedAt: 100,
+				lastUpdate: 200,
+				displayDismissedAt: 250,
+				processTerminal: { version: 1, state: "unknown", runId: "finished", runnerProcessInstanceId: "runner", reason: "process-tree-unverified" },
+				steps: [{ agent: "worker", status: "complete" }],
+			});
+			updateActiveRunIndex(asyncDir, "running");
+			const markerPath = path.join(root, ACTIVE_RUN_INDEX_DIR, "finished");
+			const oldTime = new Date(1_000);
+			fs.utimesSync(markerPath, oldTime, oldTime);
+
+			assert.deepEqual(listAsyncRuns(root, { states: ["running"], reconcile: false, now: () => 1_000 + DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS + 1 }), []);
+			assert.equal(fs.existsSync(markerPath), false);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
 });

package/dist/extensions/pi-subagents/test/integration/chain-execution.test.ts

@@ -538,7 +538,7 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 				{
 					ctx: {
 						...makeMinimalCtx(tempDir),
-						model: { provider: "github-copilot" },
+						model: { provider: "github-copilot", id: "gpt-5-mini" },
 						modelRegistry: {
 							getAvailable: () => [
 								{ provider: "openai", id: "gpt-5-mini" },

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

@@ -160,6 +160,55 @@ describe("runSync error handling", { skip: !piAvailable ? "pi packages not avail
 		assert.ok(result.error?.includes("connection refused"));
 	});
 
+	it("kills a wedged foreground tool at the configured per-tool timeout", { skip: process.platform === "win32" ? "timeout signal delivery intermittent on Windows CI" : undefined }, async () => {
+		mockPi.onCall({
+			steps: [
+				{ jsonl: [events.toolStart("bash")] },
+				{ delay: 30_000 },
+			],
+		});
+		const agents = makeAgentConfigs(["slow"]);
+
+		const result = await runSync(tempDir, agents, "slow", "Wait", {
+			toolTimeoutMs: 1_000,
+			timeoutMs: 8_000,
+		});
+
+		assert.equal(result.timedOut, true);
+		assert.match(result.error ?? "", /Tool 'bash' exceeded its timeout of 1000ms\./);
+	});
+
+	it("emits foreground open-tool attention for an earlier overlapping tool", async () => {
+		mockPi.onCall({
+			steps: [
+				{ jsonl: [{ type: "tool_execution_start", toolCallId: "bash-1", toolName: "bash", args: { command: "sleep 2" } }] },
+				{ delay: 50, jsonl: [
+					{ type: "tool_execution_start", toolCallId: "read-1", toolName: "read", args: { path: "README.md" } },
+					{ type: "tool_execution_end", toolCallId: "read-1", toolName: "read" },
+				] },
+				{ delay: 1_200, jsonl: [
+					{ type: "tool_execution_end", toolCallId: "bash-1", toolName: "bash" },
+					events.toolResult("bash", "done"),
+					events.assistantMessage("Done"),
+				] },
+			],
+		});
+		const agents = makeAgentConfigs(["slow"]);
+		const controlEvents: Array<{ type?: string; reason?: string; currentTool?: string; message?: string }> = [];
+
+		const result = await runSync(tempDir, agents, "slow", "Wait", {
+			runId: "foreground-overlap-attention",
+			controlConfig: { enabled: true, needsAttentionAfterMs: 999_999, activeNoticeAfterMs: 100, notifyOn: ["needs_attention"] },
+			onControlEvent: (event: { type?: string; reason?: string; currentTool?: string; message?: string }) => controlEvents.push(event),
+		});
+
+		const attention = controlEvents.find((event) => event.reason === "tool_open_threshold");
+		assert.equal(result.exitCode, 0);
+		assert.equal(attention?.type, "needs_attention");
+		assert.equal(attention?.currentTool, "bash");
+		assert.match(attention?.message ?? "", /tool 'bash' open/);
+	});
+
 	it("handles abort signal (completes faster than delay)", async () => {
 		mockPi.onCall({ delay: 10000 });
 		const agents = makeAgentConfigs(["slow"]);

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

@@ -40,6 +40,7 @@ describe("external CLI async lifecycle", () => {
 			}],
 			resultPath,
 			cwd: dir,
+			sessionId: "session-external",
 			placeholder: "{previous}",
 			artifactConfig: { enabled: false },
 			asyncDir,

package/dist/extensions/pi-subagents/test/integration/intercom-result-delivery.test.ts

@@ -286,6 +286,30 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		assert.doesNotMatch(result.content[0]?.text ?? "", /Delivered single subagent result via intercom\./);
 	});
 
+	it("keeps a workflow child bridge override isolated and preserves final output", async () => {
+		mockPi.onCall({ matchArgIncludes: "isolated task", output: "Isolated child output" });
+		mockPi.onCall({ matchArgIncludes: "normal task", output: "Normal child output" });
+		const { executor, events } = makeExecutor({ resultDelivery: true, agents: [makeAgent("worker", { tools: ["read"] })] });
+
+		const result = await executor.execute(
+			"workflow-intercom-override",
+			{
+				workflowScript: `const isolated = await runs.run("isolated", { agent: "worker", task: "isolated task", intercomBridge: { mode: "off" } }); const normal = await runs.run("normal", { agent: "worker", task: "normal task" }); return { isolated: isolated.output, normal: normal.output };`,
+				async: false,
+			},
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+
+		const isolatedArgs = await readMockCallArgs(0);
+		const normalArgs = await readMockCallArgs(1);
+		assert.equal(isolatedArgs[isolatedArgs.indexOf("--tools") + 1], "read");
+		assert.equal(normalArgs[normalArgs.indexOf("--tools") + 1], "read,contact_supervisor");
+		assert.equal(events.emitted.filter((entry) => entry.channel === "subagent:result-intercom").length, 1);
+		assert.deepEqual(result.details?.workflow?.value, { isolated: "Isolated child output", normal: "Normal child output" });
+	});
+
 	it("waits for retained workflow resume loops and returns each completed revived child", async () => {
 		mockPi.onCall({ output: "Completed retained follow-up one" });
 		mockPi.onCall({ output: "Completed retained follow-up two" });
@@ -959,7 +983,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		}
 	});
 
-	it("revives from the persisted contract when the agent definition was removed", async () => {
+	it("revives a removed agent with its persisted bridge override", async () => {
 		mockPi.onCall({ output: "descriptor-backed answer" });
 		const runId = `resume-descriptor-${Date.now()}`;
 		const asyncDir = path.join(ASYNC_DIR, runId);
@@ -976,6 +1000,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 				model: "anthropic/claude-sonnet-4:high",
 				tools: ["read"],
 				systemPrompt: "Original persisted prompt",
+				intercomBridge: { mode: "off" },
 				maxSubagentDepth: 1,
 			});
 			const { executor } = makeExecutor({ agents: [] });

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

@@ -0,0 +1,144 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, describe, it } from "node:test";
+import { TEMP_ROOT_DIR } from "../../src/shared/types.ts";
+import { writeNodeCommand } from "../support/node-command.ts";
+
+const tempDirs: string[] = [];
+afterEach(() => {
+	const progressDir = 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(progressDir, `counter-${key}`), { force: true });
+		fs.rmSync(path.join(progressDir, `counter-${key}.lock`), { recursive: true, force: true });
+		fs.rmSync(dir, { recursive: true, force: true });
+	}
+	if (fs.existsSync(progressDir)) {
+		for (const name of fs.readdirSync(progressDir)) {
+			if (name.startsWith("orca-observer-native-") || name.startsWith("concurrent-sequence-")) fs.rmSync(path.join(progressDir, name), { force: true });
+		}
+	}
+});
+
+function runProcess(command: string, args: string[], cwd: string, env: NodeJS.ProcessEnv): Promise<number | null> {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, { cwd, stdio: "inherit", shell: false, env });
+		child.once("error", reject);
+		child.once("close", resolve);
+	});
+}
+
+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));
+	}
+}
+
+async function waitForFileCount(dir: string, count: number): Promise<void> {
+	const deadline = Date.now() + 5_000;
+	while (fs.readdirSync(dir).length < count) {
+		if (Date.now() >= deadline) throw new Error(`Timed out waiting for ${count} files in ${dir}`);
+		await new Promise((resolve) => setTimeout(resolve, 20));
+	}
+}
+
+describe("Orca progress-tab observer", () => {
+	it("mirrors a native Pi child without replacing its execution path", { 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-native-"));
+		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 childEvents = [
+			{ type: "tool_execution_start", toolName: "read", args: { path: "README.md" } },
+			{ type: "tool_execution_end", toolName: "read" },
+			{ type: "message_end", message: { role: "assistant", content: [{ type: "text", text: "native Pi result" }], stopReason: "stop", usage: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0, cost: { total: 0 } } } },
+			{ type: "agent_settled" },
+		];
+		const fakePi = writeNodeCommand(dir, "pi", `for (const event of ${JSON.stringify(childEvents)}) process.stdout.write(JSON.stringify(event)+'\\n')`);
+
+		const resultPath = path.join(dir, "result.json");
+		const configPath = path.join(dir, "config.json");
+		fs.writeFileSync(configPath, JSON.stringify({
+			id: "orca-observer-native",
+			sessionId: "session-orca-native",
+			steps: [{
+				agent: "worker",
+				task: "Read the repository",
+				systemPrompt: "Use native Pi",
+				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(path.dirname(fileURLToPath(import.meta.resolve("jiti/package.json"))), "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,
+				SELESAI_SUBAGENT_PI_BINARY: fakePi,
+				ORCA_TEST_CAPTURE: capture,
+			},
+		);
+		assert.equal(exitCode, 0);
+		const result = JSON.parse(fs.readFileSync(resultPath, "utf-8"));
+		assert.equal(result.success, true);
+		assert.equal(result.results[0].runner, undefined);
+		assert.match(result.results[0].output, /native Pi result/);
+		assert.match(fs.readFileSync(path.join(asyncDir, "output-0.log"), "utf-8"), /read: README\.md[\s\S]*native Pi result/);
+
+		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");
+	});
+
+	it("allocates unique worktree-wide numbers across concurrent processes and nested cwd values", { 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-counter-"));
+		tempDirs.push(dir);
+		fs.mkdirSync(path.join(dir, ".git"));
+		const nested = path.join(dir, "packages", "app");
+		fs.mkdirSync(nested, { recursive: true });
+		const captures = path.join(dir, "captures");
+		fs.mkdirSync(captures);
+		const fakeOrca = writeNodeCommand(dir, "orca", "const fs=require('fs'),path=require('path');const args=process.argv.slice(2);fs.writeFileSync(path.join(process.env.ORCA_TEST_CAPTURE_DIR, process.pid+'.json'),JSON.stringify(args))");
+		const repo = path.resolve(import.meta.dirname, "../..");
+		const moduleUrl = new URL("../../src/runs/shared/orca-progress-tabs.ts", import.meta.url).href;
+		const childScript = `import {createOrcaProgressTab} from ${JSON.stringify(moduleUrl)};const tab=createOrcaProgressTab({cwd:process.env.CHILD_CWD,runId:'concurrent-sequence',agent:'worker',index:0,config:{enabled:true}});if(!tab)throw new Error('tab unavailable');setTimeout(()=>tab.finish('failed'),100);setTimeout(()=>{},180);`;
+		const processes = Array.from({ length: 8 }, (_, index) => runProcess(
+			process.execPath,
+			["--experimental-strip-types", "--input-type=module", "--eval", childScript],
+			repo,
+			{ ...process.env, SELESAI_SUBAGENT_ORCA_BINARY: fakeOrca, ORCA_TEST_CAPTURE_DIR: captures, CHILD_CWD: index % 2 === 0 ? dir : nested },
+		));
+		assert.deepEqual(await Promise.all(processes), Array(8).fill(0));
+		await waitForFileCount(captures, 8);
+		const titles = fs.readdirSync(captures).map((name) => {
+			const args = JSON.parse(fs.readFileSync(path.join(captures, name), "utf-8")) as string[];
+			return args[args.indexOf("--title") + 1];
+		}).sort((left, right) => Number(left.split(" · ").at(-1)) - Number(right.split(" · ").at(-1)));
+		assert.deepEqual(titles, Array.from({ length: 8 }, (_, index) => `subagent · worker · ${index + 1}`));
+	});
+});

package/dist/extensions/pi-subagents/test/integration/render-widget.test.ts

@@ -209,6 +209,32 @@ describe("subagent async widget rendering", () => {
 		assert.ok(lines.length <= 10, "collapsed component should stay under Pi's string-widget cap even though it bypasses it");
 	});
 
+	it("uses a bounded string-array snapshot widget in RPC mode", () => {
+		const ui = createUiContext();
+		(ui.ctx as { mode?: string }).mode = "rpc";
+		renderWidget(ui.ctx as never, [{
+			asyncId: "run-rpc",
+			asyncDir: "/tmp/private-run-rpc",
+			cwd: "/repo/private",
+			status: "running",
+			mode: "single",
+			agents: ["worker"],
+			currentTool: "bash",
+			steps: [{ agent: "worker", status: "running", currentToolArgs: "private args" }],
+		}]);
+
+		const widget = ui.widgets.at(-1);
+		assert.ok(Array.isArray(widget), "RPC mode should install a string-array widget payload");
+		const [line] = widget as string[];
+		assert.ok(line?.startsWith("SELESAI_SUBAGENT_ASYNC_JSON:"));
+		const snapshot = JSON.parse(line.slice("SELESAI_SUBAGENT_ASYNC_JSON:".length));
+		assert.equal(snapshot.kind, "pi-subagents.async-status-snapshot");
+		assert.equal(snapshot.version, 1);
+		assert.equal(snapshot.runs[0].id, "run-rpc");
+		assert.equal(JSON.stringify(snapshot).includes("/tmp/private-run-rpc"), false);
+		assert.equal(JSON.stringify(snapshot).includes("private args"), false);
+	});
+
 	it("honors the component render width instead of the terminal width", () => {
 		resetWidgetLayout();
 		withStdoutSize(50, 120, () => {