@selesai/code 0.5.28 → 0.6.1

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,
@@ -216,10 +227,13 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		assert.match(result.content[0]?.text ?? "", /Delivered single subagent result via intercom\./);
 		assert.doesNotMatch(result.content[0]?.text ?? "", /Full child output from worker/);
 		assert.equal(result.details?.results?.[0]?.finalOutput, undefined);
-		assert.match(String(payload.message ?? ""), /Full child output from worker/);
+		// Reference-first intercom delivery: the child summary is the saved-output
+		// reference (error/status first for failed children), never raw child prose.
+		assert.match(String(payload.message ?? ""), /Output saved to: /);
+		assert.doesNotMatch(String(payload.message ?? ""), /Full child output from worker/);
 	});
 
-	it("falls back to legacy foreground output when the bridge is inactive", async () => {
+	it("returns the native saved-output receipt when the bridge is inactive", async () => {
 		mockPi.onCall({ output: "Legacy foreground output" });
 		const { executor, events } = makeExecutor({ bridgeMode: "off" });
 
@@ -232,10 +246,31 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		);
 
 		assert.equal(events.emitted.some((entry) => entry.channel === "subagent:result-intercom"), false);
-		assert.match(result.content[0]?.text ?? "", /Legacy foreground output/);
+		assert.match(result.content[0]?.text ?? "", /Output saved to: /);
+		assert.doesNotMatch(result.content[0]?.text ?? "", /Legacy foreground output/);
+		const runId = result.details?.runId;
+		assert.ok(runId);
+		assert.equal(fs.readFileSync(path.join(tempDir, ".pi-subagents", "artifacts", "outputs", runId, "result.md"), "utf-8"), "Legacy foreground output");
 	});
 
-	it("falls back to legacy foreground output when grouped delivery is not acknowledged", async () => {
+	it("keeps the native saved-output receipt 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 ?? "", /Output saved to: /);
+		assert.doesNotMatch(result.content[0]?.text ?? "", /Native foreground output/);
+	});
+
+	it("falls back to the compact native saved-output receipt when grouped delivery is not acknowledged", async () => {
 		mockPi.onCall({ output: "Unacknowledged foreground output" });
 		const { executor, events } = makeExecutor({ acknowledgeResults: false });
 
@@ -248,7 +283,8 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		);
 
 		assert.equal(events.emitted.some((entry) => entry.channel === "subagent:result-intercom"), true);
-		assert.match(result.content[0]?.text ?? "", /Unacknowledged foreground output/);
+		assert.match(result.content[0]?.text ?? "", /Output saved to: /);
+		assert.doesNotMatch(result.content[0]?.text ?? "", /Unacknowledged foreground output/);
 	});
 
 	it("top-level parallel runs emit one grouped event containing all children", async () => {
@@ -271,12 +307,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 +469,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 +800,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 +820,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 +955,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 +967,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 +989,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 +1045,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`));
@@ -1072,7 +1259,10 @@ describe("intercom result delivery cutover", { skip: !available ? "executor not
 		const payload = completion.payload as { success?: boolean; summary?: string };
 		assert.equal(payload.success, false);
 		assert.match(payload.summary ?? "", /Acceptance rejected/);
-		assert.match(payload.summary ?? "", /final answer with rejected acceptance evidence/);
+		// Reference-first foreground completion: the recovery summary carries the
+		// saved-output reference (with error/status), never raw child prose.
+		assert.match(payload.summary ?? "", /Output saved to: /);
+		assert.doesNotMatch(payload.summary ?? "", /final answer with rejected acceptance evidence/);
 
 		const status = await executor.execute(
 			"foreground-detached-failed-status",
@@ -1273,9 +1463,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 +1725,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"]);
@@ -253,7 +287,9 @@ describe("parallel agent execution", { skip: !piAvailable ? "pi packages not ava
 			groups: Array<{ children: Array<{ agent: string; summary: string; patch: { path: string } }>; cleanup: { state: string; tasks: Array<{ path: string; worktreeRemoved: boolean; branchRemoved: boolean }> } }>;
 		};
 		assert.equal(handoff.groups[0]!.children[0]!.agent, "echo");
-		assert.equal(handoff.groups[0]!.children[0]!.summary, "Worktree task complete");
+		// Reference-first handoff: the summary carries the saved-output reference.
+		assert.match(handoff.groups[0]!.children[0]!.summary, /Output saved to: /);
+		assert.doesNotMatch(handoff.groups[0]!.children[0]!.summary, /Worktree task complete/);
 		assert.equal(fs.existsSync(handoff.groups[0]!.children[0]!.patch.path), true);
 		assert.ok(result.details?.runId);
 		assert.ok(handoff.groups[0]!.children[0]!.patch.path.includes(`${path.sep}worktree-diffs${path.sep}${result.details.runId}${path.sep}`));
@@ -317,7 +353,8 @@ describe("parallel agent execution", { skip: !piAvailable ? "pi packages not ava
 
 			assert.equal(result.isError, undefined);
 			assert.equal(result.details?.mode, "parallel");
-			assert.match(result.content[0]?.text ?? "", new RegExp(`${action} alias finished`));
+			assert.match(result.content[0]?.text ?? "", /Output saved to: /);
+			assert.doesNotMatch(result.content[0]?.text ?? "", new RegExp(`${action} alias finished`));
 		}
 	});
 
@@ -431,7 +468,9 @@ describe("parallel agent execution", { skip: !piAvailable ? "pi packages not ava
 		assert.equal(result.details?.results?.[0]?.timedOut, true);
 		assert.equal(result.details?.results?.[0]?.error, "Subagent timed out after 300ms.");
 		assert.equal(result.details?.results?.[1]?.exitCode, 0);
-		assert.equal(result.details?.results?.[1]?.finalOutput, "fast done");
+		assert.equal(result.details?.results?.[1]?.finalOutput, undefined);
+		assert.ok(result.details?.results?.[1]?.savedOutputPath);
+		assert.equal(fs.readFileSync(result.details?.results?.[1]?.savedOutputPath as string, "utf-8"), "fast done");
 		assert.match(result.content[0]?.text ?? "", /1\/2 succeeded/);
 		assert.match(result.content[0]?.text ?? "", /TIMED OUT: Subagent timed out after 300ms\./);
 	});
@@ -456,8 +495,9 @@ describe("parallel agent execution", { skip: !piAvailable ? "pi packages not ava
 		assert.match(text, /Output saved to:/);
 		assert.match(text, /2 lines/);
 		assert.doesNotMatch(text, /Parallel full report/);
-		assert.match(result.details?.results?.[0]?.finalOutput ?? "", /Output saved to:/);
-		assert.doesNotMatch(result.details?.results?.[0]?.finalOutput ?? "", /Parallel full report/);
+		assert.equal(result.details?.results?.[0]?.finalOutput, undefined);
+		assert.match(result.details?.results?.[0]?.outputReference?.message ?? "", /Output saved to:/);
+		assert.doesNotMatch(result.details?.results?.[0]?.outputReference?.message ?? "", /Parallel full report/);
 		assert.equal(fs.readFileSync(outputPath, "utf-8"), "Parallel full report\nwith details");
 	});
 
@@ -466,7 +506,7 @@ describe("parallel agent execution", { skip: !piAvailable ? "pi packages not ava
 
 		const result = await executor.execute(
 			"parallel-file-only-missing-output",
-			{ tasks: [{ agent: "echo", task: "Write report", outputMode: "file-only" }] },
+			{ tasks: [{ agent: "echo", task: "Write report", output: false, outputMode: "file-only" }] },
 			new AbortController().signal,
 			undefined,
 			makeMinimalCtx(tempDir),
@@ -570,7 +610,8 @@ describe("parallel agent execution", { skip: !piAvailable ? "pi packages not ava
 
 Inspect
 
-## Acceptance Contract`));
+---\n**Output:**`));
+		assert.match(taskArg, /## Acceptance Contract/);
 	});
 
 	it("top-level parallel defaultProgress uses isolated run storage", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {

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...)" }],