@selesai/code 0.5.28 → 0.5.29

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

@@ -64,7 +64,7 @@ interface TestParallelTask {
 	gateOn?: "execution" | "acceptance";
 }
 
-type TestChainStep = TestSequentialStep | {
+type TestChainStep = { checkpoint: string; message?: string; label?: string; phase?: string } | TestSequentialStep | {
 	parallel: TestParallelTask[];
 	concurrency?: number;
 	failFast?: boolean;
@@ -91,6 +91,7 @@ type TestChainStep = TestSequentialStep | {
 };
 
 interface ChainResultItem {
+	index: number;
 	agent: string;
 	exitCode: number;
 	finalOutput?: string;
@@ -118,6 +119,7 @@ interface ChainExecutionResult {
 		currentStepIndex?: number;
 		outputs?: Record<string, { text: string; structured?: unknown }>;
 		parallelHandoff?: { version: number; path: string; groupCount: number; childCount: number; cleanupState: string };
+		checkpoint?: { name?: string; status?: string; message?: string };
 	};
 }
 
@@ -215,6 +217,27 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		);
 	}
 
+	it("pauses foreground chains at approval checkpoints without launching the next child", async () => {
+		mockPi.onCall({ output: "analysis done" });
+		mockPi.onCall({ output: "should not run" });
+		const agents = [makeAgent("analyst"), makeAgent("worker")];
+
+		const result = await executeChain!(makeChainParams([
+			{ agent: "analyst", task: "Analyze" },
+			{ checkpoint: "review", message: "Approve implementation?" },
+			{ agent: "worker", task: "Implement" },
+		], agents));
+
+		assert.equal(result.isError, undefined);
+		assert.match(result.content[0]!.text, /Chain paused at checkpoint 'review'/);
+		assert.equal(result.details.results.length, 1);
+		assert.equal(result.details.checkpoint?.name, "review");
+		assert.equal(result.details.checkpoint?.status, "pending");
+		assert.equal(result.details.workflowGraph?.nodes[1]?.kind, "checkpoint");
+		assert.equal(result.details.workflowGraph?.nodes[1]?.status, "paused");
+		assert.equal(mockPi.callCount(), 1);
+	});
+
 	it("runs a 2-step chain", async () => {
 		mockPi.onCall({ output: "Analysis complete: found 3 issues" });
 		const agents = [makeAgent("analyst"), makeAgent("reporter")];
@@ -1361,6 +1384,7 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 
 		assert.ok(!result.isError, `should succeed: ${JSON.stringify(result.content)}`);
 		assert.equal(result.details.results.length, 2);
+		assert.deepEqual(result.details.results.map((row) => row.index), [0, 1]);
 	});
 
 	it("aggregates worktree handoffs across foreground chain groups", { skip: process.platform === "win32" ? "worktree paths differ on Windows" : undefined }, async () => {
@@ -1700,6 +1724,7 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 
 		assert.ok(!result.isError);
 		assert.equal(result.details.results.length, 4);
+		assert.deepEqual(result.details.results.map((row) => row.index), [0, 1, 2, 3]);
 		assert.equal(result.details.totalSteps, 3);
 	});
 });

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

@@ -53,6 +53,18 @@ function assistantToolCall(toolName: string): Record<string, unknown> {
 	};
 }
 
+function emptyTerminalAssistant(): Record<string, unknown> {
+	return {
+		role: "assistant",
+		content: [],
+		api: "test",
+		provider: "test",
+		model: "test",
+		stopReason: "stop",
+		usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: { total: 0 } },
+	};
+}
+
 describe("detectSubagentError", { skip: !available ? "utils not importable" : undefined }, () => {
 	// ---- Basic detection (must still work) ----
 
@@ -197,6 +209,42 @@ describe("detectSubagentError", { skip: !available ? "utils not importable" : un
 			"tool-call assistant message without text is not a recovery");
 	});
 
+	it("accepts a successful tool recovery followed by a clean empty terminal stop", () => {
+		const messages = [
+			toolResult("bash", "error: process exited with code 1", true),
+			assistantToolCall("edit"),
+			toolResult("edit", "Updated src/file.ts"),
+			emptyTerminalAssistant(),
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, false,
+			"later successful work plus a clean terminal stop recovers the earlier tool error");
+	});
+
+	it("keeps the final failed tool result despite a clean empty terminal stop", () => {
+		const messages = [
+			toolResult("edit", "Updated src/file.ts"),
+			assistantToolCall("bash"),
+			toolResult("bash", "error: process exited with code 2", true),
+			emptyTerminalAssistant(),
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, true,
+			"a clean terminal stop alone cannot recover the final failed tool result");
+		assert.equal(result.exitCode, 2);
+	});
+
+	it("does not recover an earlier tool error after an unsuccessful terminal stop", () => {
+		const messages = [
+			toolResult("bash", "error: process exited with code 1", true),
+			toolResult("edit", "Updated src/file.ts"),
+			{ ...emptyTerminalAssistant(), errorMessage: "provider transport failed" },
+		];
+		const result = detectSubagentError(messages);
+		assert.equal(result.hasError, true,
+			"the terminal assistant stop must itself be clean");
+	});
+
 	it("does not treat empty/whitespace assistant message as recovery", () => {
 		const messages = [
 			toolResult("read", "EISDIR: illegal operation on a directory", true),

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

@@ -1863,14 +1863,14 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 		process.env.USERPROFILE = tempHome;
 		const worktreeDir = path.join(tempDir, "worktree");
 		fs.mkdirSync(worktreeDir, { recursive: true });
-		writeProjectOverride(tempDir, "reviewer", "openai/gpt-5-main");
-		writeProjectOverride(worktreeDir, "reviewer", "openai/gpt-5-worktree");
+		writeProjectOverride(tempDir, "commentator", "openai/gpt-5-main");
+		writeProjectOverride(worktreeDir, "commentator", "openai/gpt-5-worktree");
 		const executor = makeExecutor();
 
 		try {
 			const result = await executor.execute(
 				"id",
-				{ action: "get", agent: "reviewer", cwd: "worktree" },
+				{ action: "get", agent: "commentator", cwd: "worktree" },
 				new AbortController().signal,
 				undefined,
 				makeCtx(makeSessionManagerRecorder().manager),

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

@@ -144,6 +144,14 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		}
 	}
 
+	async function waitForCallCount(minimum: number, timeoutMs = 10_000): Promise<void> {
+		const deadline = Date.now() + timeoutMs;
+		while (mockPi.callCount() < minimum) {
+			if (Date.now() > deadline) assert.fail(`Timed out waiting for ${minimum} mock pi calls; saw ${mockPi.callCount()}`);
+			await new Promise((resolve) => setTimeout(resolve, 50));
+		}
+	}
+
 	async function waitForMissingPath(filePath: string, timeoutMs = 10_000): Promise<void> {
 		const deadline = Date.now() + timeoutMs;
 		while (fs.existsSync(filePath)) {
@@ -152,7 +160,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		}
 	}
 
-	function makeExecutor(options: { bridgeMode?: "always" | "off"; agents?: ReturnType<typeof makeAgent>[]; acknowledgeResults?: boolean; kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean } = {}) {
+	function makeExecutor(options: { bridgeMode?: "always" | "off"; resultDelivery?: boolean; agents?: ReturnType<typeof makeAgent>[]; acknowledgeResults?: boolean; kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean } = {}) {
 		const events = createRecordingEventBus({ acknowledgeResults: options.acknowledgeResults ?? true });
 		const state = {
 			baseCwd: tempDir,
@@ -180,7 +188,10 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 			},
 			state,
 			config: {
-				intercomBridge: { mode: options.bridgeMode ?? "always" },
+				intercomBridge: {
+					mode: options.bridgeMode ?? "always",
+					...(options.resultDelivery === undefined ? {} : { resultDelivery: options.resultDelivery }),
+				},
 			},
 			asyncByDefault: false,
 			tempArtifactsDir: tempDir,
@@ -235,6 +246,22 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		assert.match(result.content[0]?.text ?? "", /Legacy foreground output/);
 	});
 
+	it("keeps native foreground output without attempting external grouped delivery when disabled", async () => {
+		mockPi.onCall({ output: "Native foreground output" });
+		const { executor, events } = makeExecutor({ resultDelivery: false });
+
+		const result = await executor.execute(
+			"single-native-delivery",
+			{ agent: "worker", task: "Summarize feature" },
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+
+		assert.equal(events.emitted.some((entry) => entry.channel === "subagent:result-intercom"), false);
+		assert.match(result.content[0]?.text ?? "", /Native foreground output/);
+	});
+
 	it("falls back to legacy foreground output when grouped delivery is not acknowledged", async () => {
 		mockPi.onCall({ output: "Unacknowledged foreground output" });
 		const { executor, events } = makeExecutor({ acknowledgeResults: false });
@@ -271,12 +298,145 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		assert.equal((payload.children ?? []).every((child) => /^subagent-[ab]-[a-f0-9]+-[12]$/.test(child.intercomTarget ?? "")), true);
 		assert.match(String(payload.message ?? ""), /Intercom targets below identify child sessions used while they were running/);
 		assert.match(String(payload.message ?? ""), /Run intercom target: subagent-a-[a-f0-9]+-1/);
-		assert.match(String(payload.message ?? ""), /1\. a — completed/);
-		assert.match(String(payload.message ?? ""), /2\. b — completed/);
+		assert.match(String(payload.message ?? ""), /1\. a — process completed · output present/);
+		assert.match(String(payload.message ?? ""), /2\. b — process completed · output present/);
 		assert.match(result.content[0]?.text ?? "", /Delivered parallel subagent results via intercom\./);
 		assert.equal(result.details?.results?.every((entry) => entry.finalOutput === undefined), true);
 	});
 
+	it("keeps a queued top-level parallel child controlled after an early outer rejection", async () => {
+		mockPi.onCall({ matchArgIncludes: "task-a", output: "early child", delay: 100 });
+		mockPi.onCall({ matchArgIncludes: "task-b", output: "middle child", delay: 400 });
+		mockPi.onCall({ matchArgIncludes: "task-c", output: "too late", delay: 10_000 });
+		const { executor, state } = makeExecutor({ bridgeMode: "off", agents: [makeAgent("a"), makeAgent("b"), makeAgent("c")] });
+		let rejected = false;
+		const result = await executor.execute(
+			"parallel-rejection-cleanup",
+			{ concurrency: 2, tasks: [{ agent: "a", task: "task-a" }, { agent: "b", task: "task-b" }, { agent: "c", task: "task-c" }] },
+			new AbortController().signal,
+			(update: { details?: { progress?: Array<{ agent?: string; status?: string }> } }) => {
+				if (!rejected && update.details?.progress?.some((entry) => entry.agent === "a" && entry.status === "completed")) {
+					rejected = true;
+					throw new Error("reject early parallel completion");
+				}
+			},
+			makeMinimalCtx(tempDir),
+		);
+		assert.equal(rejected, true);
+		assert.equal(result.isError, true);
+		assert.equal(state.foregroundControls.size, 1, "remaining worker still owns queued scheduling");
+		await waitForCallCount(3);
+		const liveControl = [...state.foregroundControls.values()][0];
+		assert.equal(liveControl?.currentAgent, "c", "later queued child must remain discoverable after launch");
+		assert.ok(liveControl?.interrupt, "later queued child must remain interruptible");
+		assert.equal(liveControl.interrupt(), true);
+		for (let attempt = 0; attempt < 100 && state.foregroundControls.size > 0; attempt++) await new Promise((resolve) => setTimeout(resolve, 20));
+		assert.equal(state.foregroundControls.size, 0, "control must disappear after workers and children settle");
+	});
+
+	it("keeps a queued chain-parallel child controlled after an early outer rejection", async () => {
+		mockPi.onCall({ matchArgIncludes: "chain-task-a", output: "early chain child", delay: 100 });
+		mockPi.onCall({ matchArgIncludes: "chain-task-b", output: "middle chain child", delay: 400 });
+		mockPi.onCall({ matchArgIncludes: "chain-task-c", output: "too late", delay: 10_000 });
+		const { executor, state } = makeExecutor({ bridgeMode: "off", agents: [makeAgent("a"), makeAgent("b"), makeAgent("c")] });
+		let rejected = false;
+		const result = await executor.execute(
+			"chain-parallel-rejection-cleanup",
+			{ chain: [{ concurrency: 2, parallel: [{ agent: "a", task: "chain-task-a" }, { agent: "b", task: "chain-task-b" }, { agent: "c", task: "chain-task-c" }] }] },
+			new AbortController().signal,
+			(update: { details?: { progress?: Array<{ agent?: string; status?: string }> } }) => {
+				if (!rejected && update.details?.progress?.some((entry) => entry.agent === "a" && entry.status === "completed")) {
+					rejected = true;
+					throw new Error("reject early chain completion");
+				}
+			},
+			makeMinimalCtx(tempDir),
+		);
+		assert.equal(rejected, true);
+		assert.equal(result.isError, true);
+		assert.equal(state.foregroundControls.size, 1, "remaining chain worker still owns queued scheduling");
+		await waitForCallCount(3);
+		const liveControl = [...state.foregroundControls.values()][0];
+		assert.equal(liveControl?.currentAgent, "c", "later queued chain child must remain discoverable after launch");
+		assert.ok(liveControl?.interrupt, "later queued chain child must remain interruptible");
+		assert.equal(liveControl.interrupt(), true);
+		for (let attempt = 0; attempt < 100 && state.foregroundControls.size > 0; attempt++) await new Promise((resolve) => setTimeout(resolve, 20));
+		assert.equal(state.foregroundControls.size, 0, "chain control must disappear after workers and children settle");
+	});
+
+	it("cleans a rejected sequential chain child and releases foreground ownership", async () => {
+		mockPi.onCall({ output: "sequential child output" });
+		const { executor, state } = makeExecutor({ bridgeMode: "off", agents: [makeAgent("worker")] });
+		let rejected = false;
+		let ownedControl: { schedulingOwners?: number; activeChildren?: Map<number, unknown> } | undefined;
+		const result = await executor.execute(
+			"chain-sequential-rejection-cleanup",
+			{ chain: [{ agent: "worker", task: "sequential task" }] },
+			new AbortController().signal,
+			(update: { details?: { progress?: Array<{ status?: string }> } }) => {
+				if (rejected || !update.details?.progress?.some((entry) => entry.status === "completed")) return;
+				rejected = true;
+				ownedControl = [...state.foregroundControls.values()][0];
+				throw new Error("reject sequential chain completion");
+			},
+			makeMinimalCtx(tempDir),
+		);
+		assert.equal(rejected, true);
+		assert.equal(result.isError, true);
+		assert.ok(ownedControl);
+		assert.equal(ownedControl.schedulingOwners, 0);
+		assert.equal(ownedControl.activeChildren?.size, 0);
+		assert.equal(state.foregroundControls.size, 0);
+	});
+
+	it("cleans a sequential chain child after an early tool-budget validation return", async () => {
+		const { executor, state } = makeExecutor({ bridgeMode: "off", agents: [makeAgent("worker")] });
+		const execution = executor.execute(
+			"chain-sequential-budget-cleanup",
+			{ chain: [{ agent: "worker", task: "invalid budget task", toolBudget: { hard: 0 } }] },
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+		const ownedControl = [...state.foregroundControls.values()][0];
+		assert.ok(ownedControl, "outer scheduling owner should remain visible until execution settles");
+		const result = await execution;
+		assert.equal(result.isError, true);
+		assert.match(result.content[0]?.text ?? "", /toolBudget\.hard must be an integer >= 1/);
+		assert.equal(mockPi.callCount(), 0);
+		assert.equal(ownedControl.schedulingOwners, 0);
+		assert.equal(ownedControl.activeChildren?.size, 0);
+		assert.equal(state.foregroundControls.size, 0);
+	});
+
+	it("cleans an attached single rejection and its temporary structured runtime", async () => {
+		mockPi.onCall({
+			stdoutRaw: [
+				{ type: "tool_execution_start", toolName: "structured_output", args: { value: { ok: true } } },
+				{ type: "tool_result_end", message: { role: "toolResult", toolName: "structured_output", content: [{ type: "text", text: "Structured output captured." }] } },
+				{ type: "tool_execution_end", toolName: "structured_output" },
+			].map((entry) => JSON.stringify(entry)).join("\n") + "\n",
+			structuredOutputCapture: { ok: true },
+		});
+		const { executor, state } = makeExecutor({ bridgeMode: "off", agents: [makeAgent("worker")] });
+		let structuredDir: string | undefined;
+		const result = await executor.execute(
+			"single-rejection-cleanup",
+			{ agent: "worker", task: "structured task", artifacts: false, outputSchema: { type: "object", properties: { ok: { type: "boolean" } }, required: ["ok"] } },
+			new AbortController().signal,
+			(update: { details?: { results?: Array<{ structuredOutputPath?: string }>; progress?: Array<{ status?: string }> } }) => {
+				const outputPath = update.details?.results?.[0]?.structuredOutputPath;
+				if (outputPath) structuredDir = path.dirname(outputPath);
+				if (update.details?.progress?.[0]?.status === "completed") throw new Error("reject attached single completion");
+			},
+			makeMinimalCtx(tempDir),
+		);
+		assert.equal(result.isError, true);
+		assert.equal(state.foregroundControls.size, 0);
+		assert.ok(structuredDir);
+		assert.equal(fs.existsSync(structuredDir), false, "temporary structured runtime must be removed on rejection");
+	});
+
 	it("chain runs emit one grouped event containing all executed children", async () => {
 		mockPi.onCall({ output: "Chain child output" });
 		const { executor, events } = makeExecutor({ agents: [makeAgent("a"), makeAgent("b"), makeAgent("c")] });
@@ -300,9 +460,9 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		assert.equal(payload.mode, "chain");
 		assert.deepEqual((payload.children ?? []).map((child) => child.agent).sort(), ["a", "b", "c"]);
 		assert.equal((payload.children ?? []).every((child) => /^subagent-[abc]-[a-f0-9]+-[123]$/.test(child.intercomTarget ?? "")), true);
-		assert.match(String(payload.message ?? ""), /1\. a — completed/);
-		assert.match(String(payload.message ?? ""), /2\. b — completed/);
-		assert.match(String(payload.message ?? ""), /3\. c — completed/);
+		assert.match(String(payload.message ?? ""), /1\. a — process completed · output present/);
+		assert.match(String(payload.message ?? ""), /2\. b — process completed · output present/);
+		assert.match(String(payload.message ?? ""), /3\. c — process completed · output present/);
 		assert.match(result.content[0]?.text ?? "", /Delivered chain subagent results via intercom\./);
 		assert.equal(result.details?.results?.every((entry) => entry.finalOutput === undefined), true);
 	});
@@ -631,7 +791,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 				lastUpdate: 200,
 				cwd: tempDir,
 				sessionFile,
-				steps: [{ agent: "worker", status: "complete" }],
+				steps: [{ agent: "worker", status: "complete", launchContractDigest: "source-launch-contract-digest" }],
 			}, null, 2), "utf-8");
 			const { executor, events } = makeExecutor();
 
@@ -651,6 +811,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 			assert.doesNotMatch(result.content[0]?.text ?? "", /Follow:/);
 			const revivedId = result.details?.asyncId;
 			assert.ok(revivedId, "expected revived async id");
+			assert.equal(result.details?.sourceLaunchContractDigest, "source-launch-contract-digest");
 			const startedEvent = events.emitted.find((entry) => entry.channel === SUBAGENT_ASYNC_STARTED_EVENT && (entry.payload as { id?: string }).id === revivedId)?.payload as { goal?: string } | undefined;
 			assert.equal(startedEvent?.goal, "What changed?");
 			const resultPath = path.join(RESULTS_DIR, `${revivedId}.json`);
@@ -785,7 +946,7 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		mockPi.onCall({ output: "first child done" });
 		mockPi.onCall({ output: "second child done" });
 		mockPi.onCall({ output: "revived foreground answer" });
-		const { executor } = makeExecutor({ bridgeMode: "off", agents: [makeAgent("a"), makeAgent("b")] });
+		const { executor } = makeExecutor({ bridgeMode: "off", agents: [makeAgent("a"), makeAgent("b", { model: "anthropic/claude-sonnet-4", thinking: "high" })] });
 
 		const original = await executor.execute(
 			"foreground-resume-original",
@@ -797,6 +958,17 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		const runId = original.details?.runId;
 		assert.ok(runId, "expected foreground run id");
 
+		const overridden = await executor.execute(
+			"foreground-resume-model-override",
+			{ action: "resume", id: runId, index: 1, message: "Follow up with b", model: "openai/gpt-5" },
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+		assert.equal(overridden.isError, true);
+		assert.match(overridden.content[0]?.text ?? "", /reuses the persisted child model/);
+		assert.equal(mockPi.callCount(), 2, "rejected model override must not spawn a revival");
+
 		const revived = await executor.execute(
 			"foreground-resume",
 			{ action: "resume", id: runId, index: 1, message: "Follow up with b" },
@@ -808,10 +980,13 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		assert.equal(revived.isError, undefined);
 		assert.match(revived.content[0]?.text ?? "", /Revived foreground subagent from/);
 		assert.match(revived.content[0]?.text ?? "", /Agent: b/);
+		assert.equal(revived.details?.sourceLaunchContractDigest, original.details?.results?.[1]?.launchContractDigest);
+		assert.ok(revived.details?.sourceLaunchContractDigest, "expected foreground source launch contract digest");
 		const reviveArgs = await readMockCallArgs(2);
 		const selectedSession = original.details?.results?.[1]?.sessionFile;
 		assert.ok(selectedSession, "expected selected child session file");
 		assert.equal(reviveArgs[reviveArgs.indexOf("--session") + 1], selectedSession);
+		assert.equal(reviveArgs[reviveArgs.indexOf("--model") + 1], original.details?.results?.[1]?.model);
 		const revivedId = revived.details?.asyncId;
 		assert.ok(revivedId, "expected revived async id");
 		const resultPath = path.join(RESULTS_DIR, `${revivedId}.json`);
@@ -861,7 +1036,10 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 			);
 			assert.equal(blocked.isError, true);
 			assert.match(blocked.content[0]?.text ?? "", new RegExp(`already owned by run '${firstRevivedId}'`));
-			assert.equal(fs.readdirSync(mockPi.dir).filter((name) => name.startsWith("call-")).length, 2, "contending foreground revival must not spawn Pi");
+			// The original and the first revival each spawn Pi asynchronously, so wait for both markers
+			// before asserting the contending revival added no third spawn.
+			await waitForCallCount(2);
+			assert.equal(mockPi.callCount(), 2, "contending foreground revival must not spawn Pi");
 
 			fs.writeFileSync(releasePath, "release", "utf-8");
 			await waitForFile(path.join(RESULTS_DIR, `${firstRevivedId}.json`));
@@ -1273,9 +1451,10 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 			makeMinimalCtx(tempDir),
 		);
 		const fleetText = fleet.content[0]?.text ?? "";
-		assert.match(fleetText, /Detached foreground runs:/);
+		assert.match(fleetText, /Foreground runs:/);
 		assert.ok(fleetText.includes(runId));
-		assert.match(fleetText, /recovery: reply to the supervisor request first/);
+		assert.match(fleetText, /running/);
+		assert.match(fleetText, /contact_supervisor/);
 
 		const resumed = await executor.execute(
 			"foreground-detached-resume",
@@ -1534,7 +1713,28 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		const payload = intercomEvents[0]!.payload as { status?: string; summary?: string; message?: string };
 		assert.equal(payload.status, "failed");
 		assert.match(String(payload.summary ?? ""), /1 completed, 1 failed/);
-		assert.match(String(payload.message ?? ""), /Status: failed/);
+		assert.match(String(payload.message ?? ""), /Process status: failed/);
+		assert.match(String(payload.message ?? ""), /Outputs: 2 present \(semantic adequacy unassessed\)/);
+		assert.match(String(payload.message ?? ""), /Inspect that output before retrying/);
 		assert.match(result.content[0]?.text ?? "", /Children: 1 completed, 1 failed/);
 	});
+
+	it("does not treat a synthetic foreground startup error as child output", async () => {
+		mockPi.onCall({ output: "", stderr: "mock startup failure", exitCode: 1 });
+		const { executor, events } = makeExecutor({ agents: [makeAgent("worker")] });
+
+		await executor.execute(
+			"foreground-synthetic-error",
+			{ agent: "worker", task: "synthetic-error-task" },
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+
+		const intercomEvents = events.emitted.filter((entry) => entry.channel === "subagent:result-intercom");
+		assert.equal(intercomEvents.length, 1);
+		const message = String((intercomEvents[0]!.payload as { message?: string }).message ?? "");
+		assert.match(message, /process failed · output absent/);
+		assert.doesNotMatch(message, /Inspect that output before retrying/);
+	});
 });

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

@@ -227,6 +227,40 @@ describe("parallel agent execution", { skip: !piAvailable ? "pi packages not ava
 		assert.equal(state.foregroundControls.size, 0);
 	});
 
+	it("exposes stable child indexes for counted top-level parallel results", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
+		mockPi.onCall({
+			steps: [
+				{ jsonl: [{ type: "tool_execution_start", toolName: "read", args: { path: "a.md" } }], delay: 10 },
+				{ jsonl: [{ type: "message_end", message: { role: "assistant", content: [{ type: "text", text: "Counted A done" }], model: "mock/test-model", stopReason: "stop", usage: { input: 100, output: 50, cacheRead: 0, cacheWrite: 0, cost: { total: 0.001 } } } }] },
+			],
+		});
+		mockPi.onCall({
+			steps: [
+				{ jsonl: [{ type: "tool_execution_start", toolName: "read", args: { path: "b.md" } }], delay: 10 },
+				{ jsonl: [{ type: "message_end", message: { role: "assistant", content: [{ type: "text", text: "Counted B done" }], model: "mock/test-model", stopReason: "stop", usage: { input: 100, output: 50, cacheRead: 0, cacheWrite: 0, cost: { total: 0.001 } } } }] },
+			],
+		});
+		const executor = makeExecutor();
+		const updateIndexes: number[] = [];
+
+		const result = await executor.execute(
+			"counted-parallel-indexes",
+			{ tasks: [{ agent: "echo", task: "Counted inspection", count: 2 }] },
+			new AbortController().signal,
+			(update) => {
+				for (const row of update.details?.results ?? []) updateIndexes.push(row.index);
+			},
+			makeMinimalCtx(tempDir),
+		);
+
+		assert.equal(result.isError, undefined);
+		assert.deepEqual(result.details?.results.map((row: { index: number }) => row.index), [0, 1]);
+		assert.deepEqual([...new Set(result.details?.results.map((row: { index: number }) => row.index))], [0, 1]);
+		assert.ok(updateIndexes.includes(0));
+		assert.ok(updateIndexes.includes(1));
+		assert.ok(updateIndexes.every((index) => Number.isInteger(index)));
+	});
+
 	it("publishes a durable handoff before cleaning foreground parallel worktrees", { skip: !createSubagentExecutor || process.platform === "win32" ? "executor unavailable or worktree paths differ on Windows" : undefined }, async () => {
 		git(["init"]);
 		git(["config", "user.email", "test@example.com"]);

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

@@ -454,6 +454,50 @@ describe("renderSubagentResult fork indicator", () => {
 		assert.match(text, /output: \/tmp\/reviewer_output\.md/);
 	});
 
+	it("shows model and thinking on running compact single and multi rows", () => {
+		const single = renderSubagentResult!({
+			content: [{ type: "text", text: "(running...)" }],
+			details: {
+				mode: "single",
+				results: [{
+					agent: "reviewer",
+					task: "review",
+					exitCode: 0,
+					messages: [],
+					usage: emptyUsage,
+					progress: {
+						index: 0,
+						agent: "reviewer",
+						status: "running",
+						task: "review",
+						model: "openai-codex/gpt-5.5",
+						thinking: "high",
+						recentTools: [],
+						recentOutput: [],
+						toolCount: 1,
+						tokens: 42,
+						durationMs: 3_000,
+					},
+				}],
+			},
+		}, { expanded: false }, theme).render(160).join("\n");
+		assert.match(single, /reviewer \(gpt-5\.5 · thinking high\)/);
+
+		const multi = renderSubagentResult!({
+			content: [{ type: "text", text: "(running...)" }],
+			details: {
+				mode: "parallel",
+				totalSteps: 2,
+				results: [
+					{ agent: "scout", task: "scan", exitCode: 0, messages: [], usage: emptyUsage, model: "anthropic/claude-haiku-4-5", thinking: "low", progress: { index: 0, agent: "scout", status: "running", task: "scan", recentTools: [], recentOutput: [], toolCount: 0, tokens: 0, durationMs: 0 } },
+					{ agent: "worker", task: "fix", exitCode: 0, messages: [], usage: emptyUsage, progress: { index: 1, agent: "worker", status: "running", task: "fix", model: "openai/gpt-5-mini", recentTools: [], recentOutput: [], toolCount: 0, tokens: 0, durationMs: 0 } },
+				],
+			},
+		}, { expanded: false }, theme).render(160).join("\n");
+		assert.match(multi, /Agent 1\/2: scout \(claude-haiku-4-5 · thinking low\)/);
+		assert.match(multi, /Agent 2\/2: worker \(gpt-5-mini\)/);
+	});
+
 	it("keeps running compact result output stable when progress is unchanged", async () => {
 		const result = {
 			content: [{ type: "text" as const, text: "(running...)" }],