@selesai/code 0.13.40 → 0.14.3

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

@@ -14,6 +14,7 @@ import {
 	subagentRpcReplyEvent,
 	type SubagentRpcReplyEnvelope,
 } from "../../src/extension/rpc.ts";
+import type { SubagentParamsLike } from "../../src/runs/foreground/subagent-executor.ts";
 import { DIRS, SUBAGENT_CHILD_STATUS_EVENT, type Details, type SubagentChildStatusEvent, type SubagentState } from "../../src/shared/types.ts";
 
 class FakeEvents {
@@ -118,7 +119,10 @@ describe("subagent extension RPC bridge", () => {
 			(reply as { data: { capabilities?: { statusProjection?: unknown } } }).data.capabilities?.statusProjection,
 			{ version: 1, untargeted: "in-memory-when-ready", targeted: "executor" },
 		);
-		assert.deepEqual((reply as { data: { capabilities?: { cost?: unknown } } }).data.capabilities?.cost, { version: 1 });
+		assert.deepEqual(
+			(reply as { data: { capabilities?: { cost?: unknown } } }).data.capabilities?.cost,
+			{ version: 1 },
+		);
 		assert.ok((reply as { data: { methods?: string[] } }).data.methods?.includes("cost"));
 
 		bridge.dispose();
@@ -295,6 +299,65 @@ describe("subagent extension RPC bridge", () => {
 		bridge.dispose();
 	});
 
+	it("forwards RPC schedule.run quiet:true to launch and keeps omitted quiet noisy", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-rpc-schedule-quiet-"));
+		const project = path.join(root, "project");
+		fs.mkdirSync(project);
+		const scheduleCtx = {
+			cwd: project,
+			sessionManager: {
+				getSessionId: () => "session-a",
+				getSessionFile: () => path.join(project, "session-a.jsonl"),
+			},
+		} as const;
+		type Launch = {
+			params: Record<string, unknown>;
+			resolve(result: { content: Array<{ type: "text"; text: string }>; details: Record<string, unknown> }): void;
+		};
+		const launches: Launch[] = [];
+		const { createScheduledRunManager } = await import("../../src/runs/background/scheduled-runs.ts");
+		const manager = createScheduledRunManager({
+			config: { scheduledRuns: { enabled: true } },
+			storeRoot: path.join(root, "stores"),
+			now: () => Date.parse("2030-01-01T00:00:00Z"),
+			launch: (params) => new Promise((resolve) => launches.push({ params: params as Record<string, unknown>, resolve: resolve as Launch["resolve"] })) as never,
+		});
+		manager.bindSession(scheduleCtx as never);
+		const created = await manager.handleToolCall({
+			action: "schedule.create",
+			id: "quiet-hourly",
+			every: "1h",
+			quiet: true,
+			workflowScript: "return runs.run('main', { agent: 'worker', task: 'Maintain backlog' })",
+		}, scheduleCtx as never);
+		assert.equal(created.isError, undefined);
+
+		const events = new FakeEvents();
+		const bridge = registerSubagentRpcBridge({
+			events,
+			getContext: () => scheduleCtx as never,
+			execute: async (_id, params, _signal, _hook, execCtx) => manager.handleToolCall(params, execCtx),
+		});
+		try {
+			const noisy = request(events, "run-noisy", "manage", { action: "schedule.run", id: "quiet-hourly" });
+			for (let i = 0; i < 8; i++) await Promise.resolve();
+			assert.equal("quiet" in (launches[0]?.params.scheduleOrigin as Record<string, unknown>), false);
+			launches[0]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "rpc-loud" } });
+			assert.equal((await noisy).success, true);
+			manager.handleAsyncCompletion({ runId: "rpc-loud", success: true, summary: "Done" });
+
+			const quiet = request(events, "run-quiet", "manage", { action: "schedule.run", id: "quiet-hourly", quiet: true });
+			for (let i = 0; i < 8; i++) await Promise.resolve();
+			assert.deepEqual(launches[1]?.params.scheduleOrigin, { id: "quiet-hourly", name: "workflow -> agent worker", quiet: true });
+			launches[1]!.resolve({ content: [{ type: "text", text: "Async" }], details: { mode: "single", results: [], asyncId: "rpc-quiet" } });
+			assert.equal((await quiet).success, true);
+		} finally {
+			bridge.dispose();
+			manager.stop();
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("projects bounded display-safe active fleet records without internal ids", async () => {
 		const events = new FakeEvents();
 		const state = {
@@ -507,29 +570,43 @@ describe("subagent extension RPC bridge", () => {
 		bridge.dispose();
 	});
 
-	it("forces spawn requests onto the existing async execution path", async () => {
+	it("forces spawn requests onto the existing async execution path and takes scripts as script or a workflow path", async () => {
 		const events = new FakeEvents();
-		let executedParams: any;
+		const executed: SubagentParamsLike[] = [];
 		const bridge = registerSubagentRpcBridge({
 			events,
 			getContext: () => ctx(),
 			execute: async (_id, params) => {
-				executedParams = params;
+				executed.push(params);
 				return {
 					content: [{ type: "text", text: "Async: worker [run-1]" }],
 					details: { mode: "single", results: [], asyncId: "run-1", asyncDir: "/tmp/run-1" },
-				} as any;
+				};
 			},
 		});
 
-		const reply = await request(events, "spawn-1", "spawn", { workflowScript: "return runs.run('main', { agent: 'worker', task: 'Do work' })" });
+		const reply = await request(events, "spawn-1", "spawn", { script: "return runs.run('main', { agent: 'worker', task: 'Do work' })" });
 
 		assert.equal(reply.success, true);
-		assert.equal(executedParams.workflowScript, "return runs.run('main', { agent: 'worker', task: 'Do work' })");
-		assert.equal(executedParams.async, true);
-		assert.equal("clarify" in executedParams, false);
+		assert.equal(executed[0]?.workflowScript, "return runs.run('main', { agent: 'worker', task: 'Do work' })");
+		assert.equal(executed[0]?.async, true);
+		assert.equal("clarify" in executed[0]!, false);
 		assert.equal((reply as { data: { details?: { asyncId?: string } } }).data.details?.asyncId, "run-1");
 
+		assert.equal((await request(events, "spawn-path", "spawn", { workflow: "./ci/sweep.js" })).success, true);
+		assert.deepEqual([executed[1]?.workflow, executed[1]?.workflowScript], ["./ci/sweep.js", undefined]);
+		for (const [params, message] of [
+			[{ workflowScript: "return 1" }, /workflowScript was removed; pass inline script text as script/],
+			[{ workflowScriptPath: "ci/sweep.js" }, /workflowScriptPath was removed; pass the file as workflow: "\.\/path\/to\/script\.js"/],
+			[{ workflow: true }, /no reply block for workflow: true/],
+			[{ workflow: "true" }, /no reply block for workflow: true/],
+			[{ script: "return 1", workflow: "./ci/sweep.js" }, /script cannot be combined with workflow/],
+		] as const) {
+			const rejected = await request(events, "spawn-rejected", "spawn", params);
+			assert.equal(rejected.success, false);
+			assert.match((rejected as { error?: { message?: string } }).error?.message ?? "", message);
+		}
+		assert.equal(executed.length, 2);
 		bridge.dispose();
 	});
 
@@ -545,7 +622,7 @@ describe("subagent extension RPC bridge", () => {
 			},
 		});
 
-		const reply = await request(events, "spawn-worktree", "spawn", { workflowScript: "return runs.run('main', { agent: 'worker', task: 'Do work' })", worktree: true });
+		const reply = await request(events, "spawn-worktree", "spawn", { script: "return runs.run('main', { agent: 'worker', task: 'Do work' })", worktree: true });
 
 		assert.equal(reply.success, true);
 		assert.equal(executedParams.worktree, true);
@@ -569,7 +646,7 @@ describe("subagent extension RPC bridge", () => {
 		assert.equal(chainReply.success, false);
 		assert.equal(parallelReply.success, false);
 		assert.equal(worktreeReply.success, false);
-		assert.match((chainReply as { error?: { message?: string } }).error?.message ?? "", /workflowScript/);
+		assert.match((chainReply as { error?: { message?: string } }).error?.message ?? "", /removed; use a workflow script/);
 		assert.equal(executeCalls, 0);
 		bridge.dispose();
 	});
@@ -1156,14 +1233,33 @@ describe("subagent extension RPC bridge", () => {
 		const childUsage = { input: 8, output: 3, cacheRead: 5, cacheWrite: 0, cost: 0.25, turns: 1 };
 		const branch = [
 			{ type: "message", message: { role: "assistant", usage: { input: 15, output: 3, cacheRead: 30, cacheWrite: 0, cost: { total: 0.25 } } } },
-			{ type: "message", message: { role: "toolResult", toolName: "subagent", details: { mode: "single", results: [{ agent: "reviewer", runId: "run-a", usage: childUsage, sessionFile: "/sessions/child-a.jsonl" }] } } },
-			{ type: "message", message: { role: "toolResult", toolName: "bg_wait", details: { mode: "single", results: [], completions: [{ mode: "single", runId: "run-a", results: [{ agent: "reviewer", runId: "run-a", usage: childUsage }] }] } } },
+			{
+				type: "message",
+				message: {
+					role: "toolResult",
+					toolName: "subagent",
+					details: { mode: "single", results: [{ agent: "reviewer", runId: "run-a", usage: childUsage, sessionFile: "/sessions/child-a.jsonl" }] },
+				},
+			},
+			// The same child completing through bg_wait must not be counted twice.
+			{
+				type: "message",
+				message: {
+					role: "toolResult",
+					toolName: "bg_wait",
+					details: { mode: "single", results: [], completions: [{ mode: "single", runId: "run-a", results: [{ agent: "reviewer", runId: "run-a", usage: childUsage }] }] },
+				},
+			},
 		];
 		const bridge = registerSubagentRpcBridge({
 			events,
 			getContext: () => ({
 				cwd: "/repo",
-				sessionManager: { getSessionId: () => "session-123", getSessionFile: () => "/sessions/parent.jsonl", getBranch: () => branch },
+				sessionManager: {
+					getSessionId: () => "session-123",
+					getSessionFile: () => "/sessions/parent.jsonl",
+					getBranch: () => branch,
+				},
 			}) as any,
 			execute: async () => assert.fail("cost should not call executor"),
 			state: { baseCwd: "/repo" } as SubagentState,
@@ -1172,7 +1268,7 @@ describe("subagent extension RPC bridge", () => {
 		const reply = await request(events, "cost-1", "cost");
 		assert.equal(reply.success, true);
 		assert.equal(reply.method, "cost");
-		const data = (reply as { data: { version: number; parent: Record<string, number>; children: Array<{ agent?: string; runId?: string }>; childTotal: Record<string, number>; total: Record<string, number>; unresolvedAsyncChildren: number } }).data;
+		const data = (reply as { data: { version: number; parent: Record<string, number>; children: Array<{ agent?: string; runId?: string; usage: Record<string, number> }>; childTotal: Record<string, number>; total: Record<string, number>; unresolvedAsyncChildren: number } }).data;
 		assert.equal(data.version, 1);
 		assert.deepEqual(data.parent, { input: 15, output: 3, cacheRead: 30, cacheWrite: 0, cost: 0.25, turns: 1 });
 		assert.equal(data.children.length, 1, "run identity deduplicates the bg_wait completion");
@@ -1185,6 +1281,7 @@ describe("subagent extension RPC bridge", () => {
 		const rejected = await request(events, "cost-2", "cost", "not-an-object");
 		assert.equal(rejected.success, false);
 		assert.equal((rejected as { error: { code: string } }).error.code, "invalid_params");
+
 		bridge.dispose();
 	});
 
@@ -1204,7 +1301,10 @@ describe("subagent extension RPC bridge", () => {
 			fs.mkdirSync(asyncDir, { recursive: true });
 			fs.mkdirSync(path.dirname(metadataPath), { recursive: true });
 			fs.writeFileSync(path.join(asyncDir, "workflow-receipt.json"), JSON.stringify({
-				version: 1, workflowRunId, state: "complete", createdAt: Date.now(),
+				version: 1,
+				workflowRunId,
+				state: "complete",
+				createdAt: Date.now(),
 				entries: {
 					recovered: { key: "recovered", agent: "reviewer", latestRunId: recoveredRunId, continuation: { runIds: [recoveredRunId] }, resumability: { state: "resumable" } },
 					unresolved: { key: "unresolved", agent: "worker", latestRunId: unresolvedRunId, continuation: { runIds: [unresolvedRunId] }, resumability: { state: "resumable" } },
@@ -1222,7 +1322,10 @@ describe("subagent extension RPC bridge", () => {
 					sessionManager: {
 						getSessionId: () => "session-async-cost",
 						getSessionFile: () => sessionFile,
-						getBranch: () => [{ type: "message", message: { role: "toolResult", toolName: "subagent", details: { mode: "workflow", runId: workflowRunId, results: [] } } }],
+						getBranch: () => [{
+							type: "message",
+							message: { role: "toolResult", toolName: "subagent", details: { mode: "workflow", runId: workflowRunId, asyncId: workflowRunId, results: [] } },
+						}],
 					},
 				}) as any,
 				execute: async () => assert.fail("cost should not call executor"),
@@ -1245,7 +1348,11 @@ describe("subagent extension RPC bridge", () => {
 
 	it("cost requires an active session context like every non-ping method", async () => {
 		const events = new FakeEvents();
-		const bridge = registerSubagentRpcBridge({ events, getContext: () => null, execute: async () => assert.fail("cost should not call executor") });
+		const bridge = registerSubagentRpcBridge({
+			events,
+			getContext: () => null,
+			execute: async () => assert.fail("cost should not call executor"),
+		});
 		const reply = await request(events, "cost-3", "cost");
 		assert.equal(reply.success, false);
 		assert.equal((reply as { error: { code: string } }).error.code, "no_active_session");

package/dist/extensions/pi-subagents/test/unit/run-child-session.test.ts

@@ -0,0 +1,230 @@
+import assert from "node:assert/strict";
+import { it } from "node:test";
+import { fauxAssistantMessage } from "@earendil-works/pi-ai";
+import { runSync } from "../../src/runs/foreground/execution.ts";
+import { makeAgentConfigs } from "../support/helpers.ts";
+import { runChildSession } from "../../src/runs/background/run-child-session.ts";
+import type { ChildSession, ChildSessionFactory } from "../../src/runs/shared/child-session.ts";
+import type { InProcessChildLaunch } from "../../src/runs/shared/child-launch.ts";
+
+const launch = { session: {
+	cwd: process.cwd(), storage: { kind: "memory" }, extensionPaths: [], ambientExtensions: false,
+	hooks: [], noSkills: true, noContextFiles: true,
+	runtime: { fanoutChild: false, fast: false, depth: 1, waitTool: { enabled: false } },
+} } as InProcessChildLaunch;
+
+// Without the abort backstop this run never settles, so bound the test instead of hanging the suite.
+it("settles a timed-out run whose session creation never returns, and contains late disposal rejection", { timeout: 10_000 }, async () => {
+	let releaseCreate!: (session: ChildSession) => void;
+	const createBlocked = new Promise<ChildSession>((resolve) => { releaseCreate = resolve; });
+	let timeout: (() => void) | undefined;
+	let prompted = false;
+	let disposeAttempted = false;
+	const session: ChildSession = {
+		subscribe() { return () => {}; },
+		async prompt() { prompted = true; },
+		async steer() {}, async followUp() {}, async abort() {},
+		async dispose() {
+			disposeAttempted = true;
+			throw new Error("late disposal failed");
+		},
+		messages: [], sessionId: "late-session", modelId: "mock/model",
+	};
+	const factory: ChildSessionFactory = { create: () => createBlocked, async dispose() {} };
+	const run = runChildSession({
+		factory,
+		launch,
+		prompt: "never starts",
+		timeoutMessage: "Subagent timed out after 1ms.",
+		appendChildEvent() {}, writeOutputLine() {},
+		registerTimeout(handler) { timeout = handler; },
+	});
+	assert.ok(timeout, "runChildSession must register its timeout handler before the session exists");
+	timeout();
+	const result = await run;
+	assert.equal(result.timedOut, true);
+	assert.equal(result.exitCode, 1);
+	assert.equal(result.error, "Subagent timed out after 1ms.");
+
+	releaseCreate(session);
+	await new Promise((resolve) => setImmediate(resolve));
+	assert.equal(disposeAttempted, true);
+	assert.equal(prompted, false);
+});
+
+it("reports the created child's context window before prompting", { timeout: 10_000 }, async () => {
+	const reported: number[] = [];
+	let timeout: (() => void) | undefined;
+	let promptedAfterReport = false;
+	const session: ChildSession = {
+		subscribe() { return () => {}; },
+		async prompt() { promptedAfterReport = reported.length === 1; timeout?.(); },
+		async steer() {}, async followUp() {}, async abort() {}, async dispose() {},
+		messages: [], sessionId: "window-session", modelId: "openai-codex/gpt-6-sol", contextWindow: 1_050_000,
+	};
+	const factory: ChildSessionFactory = { create: async () => session, async dispose() {} };
+	await runChildSession({
+		factory,
+		launch,
+		prompt: "report window",
+		timeoutMessage: "done",
+		appendChildEvent() {}, writeOutputLine() {},
+		registerTimeout(handler) { timeout = handler; },
+		onContextWindow: (contextWindow) => { reported.push(contextWindow); },
+	});
+	assert.deepEqual(reported, [1_050_000]);
+	assert.equal(promptedAfterReport, true);
+});
+
+
+for (const mode of ["foreground", "background"] as const) {
+	it(`rejects unfinished commands at authoritative ${mode} settlement and still disposes the child`, async () => {
+		let listener: Parameters<ChildSession["subscribe"]>[0] = () => {};
+		let prompted = false;
+		let finalized = 0;
+		let disposed = false;
+		const messages = [];
+		const session: ChildSession = {
+			subscribe(handler) { listener = handler; return () => {}; },
+			async prompt() {
+				const message = fauxAssistantMessage("Done");
+				messages.push(message);
+				listener({ type: "message_end", message });
+				listener({ type: "agent_end", messages });
+				listener({ type: "agent_settled" });
+				prompted = true;
+			},
+			async finishCommands() {
+				assert.equal(prompted, true);
+				finalized++;
+				throw new Error("Child finished with unfinished commands: service. Commands were cancelled.");
+			},
+			async steer() {}, async followUp() {}, async abort() {}, async dispose() { disposed = true; },
+			messages, sessionId: "command-settlement-session", modelId: "mock/model",
+		};
+		const factory: ChildSessionFactory = { create: async () => session, async dispose() {} };
+		const result = mode === "foreground"
+			? await runSync(process.cwd(), makeAgentConfigs(["worker"]), "worker", "Finish", { childSessionFactory: factory })
+			: await runChildSession({ factory, launch, prompt: "Finish", timeoutMessage: "timed out", appendChildEvent() {}, writeOutputLine() {} });
+		assert.equal(result.exitCode, 1);
+		assert.match(result.error ?? "", /unfinished commands: service/);
+		assert.equal(finalized, 1);
+		assert.equal(disposed, true);
+	});
+}
+
+it("verifies a virtual-model child against its selection and keeps the dispatched model", { timeout: 10_000 }, async () => {
+	let listener: Parameters<ChildSession["subscribe"]>[0] | undefined;
+	const session: ChildSession = {
+		subscribe(next) { listener = next; return () => {}; },
+		async prompt() {
+			listener?.({ type: "message_end", message: { ...fauxAssistantMessage("done"), model: "gpt-6.1-sol" } });
+		},
+		async steer() {}, async followUp() {}, async abort() {}, async dispose() {},
+		messages: [], sessionId: "virtual-session", modelId: "router/auto", virtualModelId: "router/auto",
+	};
+	const result = await runChildSession({
+		factory: { create: async () => session, async dispose() {} },
+		launch,
+		prompt: "route",
+		appendChildEvent() {}, writeOutputLine() {},
+		expectedModelForVerification: "router/auto:medium",
+		modelVerificationRegistry: [{ provider: "router", id: "auto", fullId: "router/auto" }],
+	});
+	assert.equal(result.error, undefined);
+	assert.equal(result.exitCode, 0);
+	assert.equal(result.model, "gpt-6.1-sol");
+});
+
+// Unfinished streamed text recovered on timeout or a thrown session error.
+type PartialScenario = "timeout" | "child error" | "completed reply" | "provider error" | "recovered tool call";
+
+async function runPartialScenario(mode: "foreground" | "background", scenario: PartialScenario) {
+	let listener: Parameters<ChildSession["subscribe"]>[0] = () => {};
+	let timeout: (() => void) | undefined;
+	let releasePrompt!: () => void;
+	const hung = new Promise<void>((resolve) => { releasePrompt = resolve; });
+	const messages: ChildSession["messages"] = [];
+	const streaming = (text: string) => ({ role: "assistant", content: [{ type: "text", text }] });
+	const session: ChildSession = {
+		subscribe(handler) { listener = handler; return () => {}; },
+		async prompt() {
+			listener({ type: "message_update", message: streaming("half a th"), assistantMessageEvent: { type: "text_delta", delta: "half a th" } });
+			listener({ type: "message_update", message: streaming("half a thought"), assistantMessageEvent: { type: "text_delta", delta: "ought" } });
+			if (scenario === "completed reply") {
+				const message = fauxAssistantMessage("half a thought, finished");
+				messages.push(message);
+				listener({ type: "message_end", message });
+			}
+			if (scenario === "provider error") {
+				const message = { ...fauxAssistantMessage("text before the provider error"), stopReason: "error", errorMessage: "overloaded" };
+				messages.push(message);
+				listener({ type: "message_end", message });
+				throw new Error("overloaded");
+			}
+			if (scenario === "recovered tool call") {
+				// A retried provider error whose recovered reply only calls a tool, which then outlives the timeout.
+				const failed = { ...fauxAssistantMessage("stale failed attempt"), stopReason: "error", errorMessage: "overloaded" };
+				const toolOnly = { role: "assistant", content: [{ type: "toolCall", id: "call-1", name: "bash", arguments: { command: "sleep 100" } }], stopReason: "toolUse" };
+				messages.push(failed, toolOnly);
+				listener({ type: "message_end", message: failed });
+				listener({ type: "message_end", message: toolOnly });
+				listener({ type: "tool_execution_start", toolCallId: "call-1", toolName: "bash", args: { command: "sleep 100" } });
+			}
+			if (scenario === "child error") throw new Error("session blew up");
+			if (mode === "background") timeout?.();
+			await hung;
+		},
+		async steer() {}, async followUp() {}, async abort() { releasePrompt(); }, async dispose() {},
+		messages, sessionId: "partial-session", modelId: "mock/model",
+	};
+	const factory: ChildSessionFactory = { create: async () => session, async dispose() {} };
+	return mode === "foreground"
+		? runSync(process.cwd(), makeAgentConfigs(["worker"]), "worker", "Finish", { childSessionFactory: factory, timeoutMs: 100 })
+		: runChildSession({
+			factory, launch, prompt: "Finish", timeoutMessage: "Subagent timed out.",
+			appendChildEvent() {}, writeOutputLine() {},
+			registerTimeout(handler) { timeout = handler; },
+		});
+}
+
+for (const mode of ["foreground", "background"] as const) {
+	it(`${mode}: returns unfinished streamed text as flagged partial output on timeout`, { timeout: 10_000 }, async () => {
+		const result = await runPartialScenario(mode, "timeout");
+		assert.equal(result.timedOut, true);
+		assert.equal(result.exitCode, 1);
+		assert.equal(result.outputState, "present");
+		assert.equal(result.outputPartial, true);
+		assert.match(result.finalOutput ?? "", /Partial output before timeout:\nhalf a thought$/);
+	});
+
+	it(`${mode}: returns unfinished streamed text as flagged partial output on a thrown session error`, { timeout: 10_000 }, async () => {
+		const result = await runPartialScenario(mode, "child error");
+		assert.equal(result.exitCode, 1);
+		assert.equal(result.outputPartial, true);
+		assert.equal(result.finalOutput, "Partial output before child error:\nhalf a thought");
+		assert.match(result.error ?? "", /session blew up/);
+	});
+
+	it(`${mode}: keeps the text of a failed provider message as partial output`, { timeout: 10_000 }, async () => {
+		const result = await runPartialScenario(mode, "provider error");
+		assert.equal(result.exitCode, 1);
+		assert.equal(result.outputPartial, true);
+		assert.equal(result.finalOutput, "Partial output before child error:\ntext before the provider error");
+	});
+
+	it(`${mode}: does not return a failed attempt's text after a completed tool-only reply`, { timeout: 10_000 }, async () => {
+		const result = await runPartialScenario(mode, "recovered tool call");
+		assert.equal(result.timedOut, true);
+		assert.equal(result.outputPartial, undefined);
+		assert.doesNotMatch(result.finalOutput ?? "", /stale failed attempt/);
+	});
+
+	it(`${mode}: never marks a completed reply as partial`, { timeout: 10_000 }, async () => {
+		const result = await runPartialScenario(mode, "completed reply");
+		assert.equal(result.timedOut, true);
+		assert.equal(result.outputPartial, undefined);
+		assert.doesNotMatch(result.finalOutput ?? "", /Partial output before child error/);
+		assert.match(result.finalOutput ?? "", /half a thought, finished/);
+	});
+}

package/dist/extensions/pi-subagents/test/unit/run-id-resolver.test.ts

@@ -9,6 +9,8 @@ import { releaseActiveRunIndex, updateActiveRunIndex } from "../../src/runs/back
 import { resultFilePath, writeAsyncResultFile, writePendingAsyncResultFile } from "../../src/runs/background/result-files.ts";
 import { resolveSubagentRunId } from "../../src/runs/background/run-id-resolver.ts";
 import { createNestedRoute, writeNestedEvent } from "../../src/runs/shared/nested-events.ts";
+import { removeForegroundControlIfIdle } from "../../src/runs/foreground/subagent-executor.ts";
+import { inspectSubagentStatus } from "../../src/runs/background/run-status.ts";
 
 const routeRoots: string[] = [];
 
@@ -65,6 +67,7 @@ describe("subagent run id resolver", () => {
 			const asyncRoot = path.join(root, "runs");
 			const resultsDir = path.join(root, "results");
 			fs.mkdirSync(path.join(asyncRoot, "shared-id"), { recursive: true });
+			fs.writeFileSync(path.join(asyncRoot, "shared-id", "status.json"), "{}");
 			nested("root-shared", "shared-id");
 			nested("root-prefix", "shared-id-child");
 
@@ -79,12 +82,56 @@ describe("subagent run id resolver", () => {
 		}
 	});
 
+	it("does not let a mission-only directory shadow owned nested status by exact id or prefix", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-id-mission-shadow-"));
+		try {
+			const route = nested("mission-root", "mission-child");
+			const state = stateWithNestedRoute(route);
+			const asyncRoot = path.join(root, "runs");
+			fs.mkdirSync(path.join(asyncRoot, "mission-child"), { recursive: true });
+			fs.writeFileSync(path.join(asyncRoot, "mission-child", "mission.json"), "{}");
+			for (const id of ["mission-child", "mission-chi"]) {
+				const deps = { state, asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") };
+				assert.equal(resolveSubagentRunId(id, deps)?.kind, "nested");
+				assert.notEqual(inspectSubagentStatus({ id }, deps).isError, true);
+			}
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("retains session-owned nested lookup after coordinator removal and descendant completion", () => {
+		const route = nested("retired-root", "finished-coordinator");
+		writeNestedEvent(route, { type: "subagent.nested.started", ts: 110, parentRunId: "finished-coordinator",
+			child: { id: "retired-child", parentRunId: "finished-coordinator", depth: 2, path: [{ runId: route.rootRunId }, { runId: "finished-coordinator" }], state: "running", agent: "worker" },
+		});
+		writeNestedEvent(route, { type: "subagent.nested.completed", ts: 120, parentRunId: route.rootRunId,
+			child: { id: "finished-coordinator", parentRunId: route.rootRunId, depth: 1, path: [{ runId: route.rootRunId }], state: "complete", agent: "coordinator" },
+		});
+		const state = stateWithNestedRoute(route);
+		state.currentSessionId = "owner";
+		state.foregroundControls.get(route.rootRunId)!.sessionId = "owner";
+		assert.equal(resolveSubagentRunId("retired-child", { state })?.kind, "nested");
+		assert.equal(removeForegroundControlIfIdle(state, route.rootRunId), true);
+		assert.equal(resolveSubagentRunId("retired-child", { state })?.kind, "nested");
+		writeNestedEvent(route, { type: "subagent.nested.completed", ts: 200, parentRunId: "finished-coordinator",
+			child: { id: "retired-child", parentRunId: "finished-coordinator", depth: 2, path: [{ runId: route.rootRunId }, { runId: "finished-coordinator" }], state: "complete", agent: "worker" },
+		});
+		const status = inspectSubagentStatus({ id: "retired-child" }, { state });
+		assert.notEqual(status.isError, true);
+		assert.match(status.content[0].text, /State: complete/);
+		assert.equal(resolveSubagentRunId("retired-child", { state, nested: { routes: [] } }), undefined, "child subtree restriction still wins");
+		state.currentSessionId = "foreign";
+		assert.equal(resolveSubagentRunId("retired-child", { state }), undefined);
+	});
+
 	it("reports one combined ambiguity for prefixes across namespaces", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-id-ambiguous-"));
 		try {
 			const asyncRoot = path.join(root, "runs");
 			const resultsDir = path.join(root, "results");
 			fs.mkdirSync(path.join(asyncRoot, "fanout-x-async"), { recursive: true });
+			fs.writeFileSync(path.join(asyncRoot, "fanout-x-async", "status.json"), "{}");
 			nested("root-fanout", "fanout-x-nested");
 			assert.throws(
 				() => resolveSubagentRunId("fanout-x", { asyncDirRoot: asyncRoot, resultsDir }),
@@ -132,6 +179,8 @@ describe("subagent run id resolver", () => {
 			const resultsDir = path.join(root, "results");
 			fs.mkdirSync(path.join(asyncRoot, "dupe-aaa-one"), { recursive: true });
 			fs.mkdirSync(path.join(asyncRoot, "dupe-aaa-two"), { recursive: true });
+			fs.writeFileSync(path.join(asyncRoot, "dupe-aaa-one", "status.json"), "{}");
+			fs.writeFileSync(path.join(asyncRoot, "dupe-aaa-two", "status.json"), "{}");
 
 			assert.throws(
 				() => resolveSubagentRunId("dupe-aaa", { asyncDirRoot: asyncRoot, resultsDir }),
@@ -244,4 +293,4 @@ describe("subagent run id resolver", () => {
 		assert.throws(() => resolveSubagentRunId("a/b"), /safe id token/);
 		assert.throws(() => resolveSubagentRunId(""), /safe id token/);
 	});
-});
+});