@selesai/code 0.5.28 → 0.6.1

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

@@ -114,6 +114,27 @@ function createUiContext() {
 }
 
 describe("async job tracker", { skip: !available ? "pi packages not available" : undefined }, () => {
+	it("drops stale captured extension contexts instead of crashing background timers", () => {
+		const asyncRoot = createTempDir("pi-async-job-tracker-stale-context-");
+		try {
+			const state = createState();
+			const recorder = createEventRecorder();
+			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot);
+			(state as { lastUiContext: unknown }).lastUiContext = {
+				get hasUI() {
+					throw new Error("This extension ctx is stale after session replacement or reload.");
+				},
+			};
+
+			tracker.handleStarted({ id: "run-stale-context", asyncDir: path.join(asyncRoot, "run-stale-context"), agent: "worker" });
+
+			assert.equal(state.lastUiContext, null);
+			if (state.poller) clearInterval(state.poller);
+		} finally {
+			removeTempDir(asyncRoot);
+		}
+	});
+
 	it("removes completed jobs after retention and requests a rerender", async () => {
 		const asyncRoot = createTempDir("pi-async-job-tracker-");
 		try {
@@ -856,6 +877,69 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		}
 	});
 
+	it("resynchronizes when a saved cursor resumes inside an oversized JSONL record", async () => {
+		const asyncRoot = createTempDir("pi-async-job-tracker-");
+		const originalError = console.error;
+		const errors: unknown[][] = [];
+		console.error = (...args: unknown[]) => {
+			errors.push(args);
+		};
+		try {
+			const runDir = path.join(asyncRoot, "run-midline-oversized-control");
+			fs.mkdirSync(runDir, { recursive: true });
+			fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
+				runId: "run-midline-oversized-control",
+				mode: "single",
+				state: "running",
+				startedAt: Date.now() - 1000,
+				lastUpdate: Date.now(),
+				steps: [{ agent: "worker", status: "running" }],
+			}), "utf-8");
+			const largeDiagnostic = JSON.stringify({
+				type: "message_update",
+				message: { role: "assistant", content: [{ type: "text", text: "x".repeat(2_500_000) }] },
+			});
+			const controlEvent = JSON.stringify({
+				type: "subagent.control",
+				channels: ["event"],
+				event: {
+					type: "needs_attention",
+					to: "needs_attention",
+					ts: 123,
+					runId: "run-midline-oversized-control",
+					agent: "worker",
+					message: "worker needs attention",
+				},
+			});
+			fs.writeFileSync(path.join(runDir, "events.jsonl"), `${largeDiagnostic}\n${controlEvent}\n`, "utf-8");
+
+			const state = createState();
+			state.asyncJobs.set("run-midline-oversized-control", {
+				asyncId: "run-midline-oversized-control",
+				asyncDir: runDir,
+				status: "running",
+				agents: ["worker"],
+				startedAt: Date.now() - 1000,
+				updatedAt: Date.now(),
+				controlEventCursor: 0,
+			});
+			const recorder = createEventRecorder();
+			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+				pollIntervalMs: 10,
+			});
+			tracker.ensurePoller();
+
+			await waitForCondition(
+				() => recorder.events.some((event) => event.channel === "subagent:control-event"),
+				"control event after oversized diagnostic",
+			);
+			assert.equal(errors.some((args) => String(args[0]).includes("Ignoring malformed async control event")), false);
+		} finally {
+			console.error = originalError;
+			removeTempDir(asyncRoot);
+		}
+	});
+
 	it("does not tail-skip control events for newly tracked large logs", async () => {
 		const asyncRoot = createTempDir("pi-async-job-tracker-");
 		try {

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

@@ -27,8 +27,8 @@ describe("async status helpers", () => {
 				currentStep: 1,
 				outputFile,
 				steps: [
-					{ agent: "scout", status: "complete", durationMs: 10 },
-					{ agent: "worker", status: "running", durationMs: 20 },
+					{ agent: "scout", status: "complete", durationMs: 10, description: "Inspect auth only" },
+					{ agent: "worker", status: "running", durationMs: 20, description: "Patch billing only" },
 				],
 			});
 			createAsyncDir(root, "run-b", {
@@ -47,6 +47,8 @@ describe("async status helpers", () => {
 			assert.equal(runs[0]?.steps.length, 2);
 			assert.equal(runs[0]?.steps[1]?.agent, "worker");
 			assert.equal(runs[0]?.steps[1]?.status, "running");
+			assert.equal(runs[0]?.steps[0]?.description, "Inspect auth only");
+			assert.equal(runs[0]?.steps[1]?.description, "Patch billing only");
 			assert.match(formatAsyncRunList(runs), /output: .*output-1\.log/);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });

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

@@ -349,9 +349,9 @@ describe("chain clarify model display", { skip: !available ? "pi packages not av
 			assert.match(initial, /\[Enter\] Run • \[Esc\] Cancel/);
 			if (mode === "single") {
 				assert.match(initial, /\[w\]Output/);
-				assert.doesNotMatch(initial, /\[↑↓\] Navigate/);
+				assert.doesNotMatch(initial, /\[↑↓\/jk\] Navigate/);
 			} else {
-				assert.match(initial, /\[↑↓\] Navigate/);
+				assert.match(initial, /\[↑↓\/jk\] Navigate/);
 			}
 			if (mode === "chain") {
 				assert.match(initial, /\[w\]Output/);
@@ -368,4 +368,53 @@ describe("chain clarify model display", { skip: !available ? "pi packages not av
 			assert.match(component.render(84).map(stripAnsi).join("\n"), /\[b\]Background:ON/);
 		}
 	});
+
+	it("navigates non-editing chain steps with j and k", () => {
+		const agents = ["scout", "worker"].map((name) => ({
+			name,
+			description: "",
+			systemPrompt: "",
+			systemPromptMode: "replace",
+			inheritProjectContext: false,
+			inheritSkills: false,
+			source: "user",
+			filePath: `${name}.md`,
+		}));
+		const component = new ChainClarifyComponent(
+			{ requestRender() {} },
+			{ fg(_key: string, text: string) { return text; } },
+			agents,
+			["Scout", "Implement"],
+			"Task",
+			undefined,
+			agents.map(() => ({ output: false, outputMode: "inline", reads: false, progress: false, skills: [], model: undefined })),
+			[],
+			undefined,
+			[{ name: "jk-skill", source: "user" }],
+			() => {},
+			"chain",
+		);
+
+		component.handleInput("j");
+		assert.equal(component.selectedStep, 1);
+		component.handleInput("k");
+		assert.equal(component.selectedStep, 0);
+
+		component.handleInput("e");
+		component.handleInput("j");
+		component.handleInput("k");
+		assert.match(component.render(84).map(stripAnsi).join("\n"), /jkScout/);
+		component.handleInput("\x1b");
+
+		component.handleInput("m");
+		component.handleInput("j");
+		component.handleInput("k");
+		assert.match(component.render(84).map(stripAnsi).join("\n"), /Search: jk/);
+		component.handleInput("\x1b");
+
+		component.handleInput("s");
+		component.handleInput("j");
+		component.handleInput("k");
+		assert.match(component.render(84).map(stripAnsi).join("\n"), /Search: jk/);
+	});
 });

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")];
@@ -344,8 +367,9 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		assert.doesNotMatch(firstTaskArg, /\[Write to:|Write your findings to exactly this path/);
 		assert.ok(result.details.results[0]?.savedOutputPath);
 		assert.equal(fs.readFileSync(result.details.results[0].savedOutputPath, "utf-8"), "full chain output\nwith details");
-		assert.match(result.details.results[0]?.finalOutput ?? "", /Output saved to:/);
-		assert.doesNotMatch(result.details.results[0]?.finalOutput ?? "", /full chain output/);
+		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 ?? "", /full chain output/);
 		const secondTaskArg = readCallArgs(1).at(-1) ?? "";
 		assert.match(secondTaskArg, /Output saved to:/);
 		assert.match(secondTaskArg, /2 lines/);
@@ -381,7 +405,8 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		);
 
 		assert.ok(!result.isError, `chain should succeed: ${JSON.stringify(result.content)}`);
-		assert.match(result.details.results[0]?.finalOutput ?? "", /Output saved to:/);
+		assert.equal(result.details.results[0]?.finalOutput, undefined);
+		assert.match(result.details.results[0]?.outputReference?.message ?? "", /Output saved to:/);
 		assert.equal(result.details.results[0]?.acceptance?.status, "checked");
 		assert.ok(result.details.results[0]?.acceptance?.childReport);
 
@@ -607,10 +632,13 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 
 		assert.ok(!result.isError);
 		const step2Task = result.details.results[1].task;
+		// Reference-first handoff: {previous} carries the saved-output reference and
+		// the step reads the named path instead of re-inlined prose.
 		assert.ok(
-			step2Task.includes("MARKER_ABC_123"),
-			`step 2 task should contain step 1 output via {previous}: ${step2Task.slice(0, 200)}`,
+			step2Task.includes("Output saved to:"),
+			`step 2 task should contain the saved-output reference via {previous}: ${step2Task.slice(0, 200)}`,
 		);
+		assert.doesNotMatch(step2Task, /MARKER_ABC_123/);
 	});
 
 	it("passes named sequential outputs through {outputs.name}", async () => {
@@ -629,7 +657,8 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		);
 
 		assert.ok(!result.isError);
-		assert.match(readCallArgs(1).at(-1) ?? "", /CTX_123/);
+		assert.match(readCallArgs(1).at(-1) ?? "", /Output saved to: /);
+		assert.doesNotMatch(readCallArgs(1).at(-1) ?? "", /CTX_123/);
 		assert.equal(result.details.workflowGraph?.nodes[0]?.outputName, "contextOutput");
 	});
 
@@ -669,9 +698,10 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		assert.match(readCallArgs(1).at(-1) ?? "", /Review src\/a\.ts/);
 		assert.match(readCallArgs(2).at(-1) ?? "", /Review src\/b\.ts/);
 		assert.match(readCallArgs(3).at(-1) ?? "", /"key":"src\/a\.ts"/);
-		const collected = result.details.outputs?.reviews?.structured as Array<{ key: string; structured: unknown }>;
-		assert.deepEqual(collected.map((item) => item.key), ["src/a.ts", "src/b.ts"]);
-		assert.deepEqual(collected.map((item) => item.structured), [{ ok: "a" }, { ok: "b" }]);
+		// Terminal details strip chain outputs text/structured; bindings remain
+		// reference-first via {outputs.name} and the workflow graph keeps item keys.
+		assert.equal(result.details.outputs?.reviews?.text, "");
+		assert.equal(result.details.outputs?.reviews?.structured, undefined);
 		const dynamicNode = result.details.workflowGraph?.nodes[1];
 		assert.equal(dynamicNode?.kind, "dynamic-parallel-group");
 		assert.deepEqual(dynamicNode?.children?.map((child) => child.itemKey), ["src/a.ts", "src/b.ts"]);
@@ -845,7 +875,7 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 					{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
 					{
 						expand: { from: { output: "targets", path: "/items" }, key: "/path", maxItems: 4 },
-						parallel: { agent: "reviewer", task: "Review {item.path}", outputMode: "file-only" },
+						parallel: { agent: "reviewer", task: "Review {item.path}", output: false, outputMode: "file-only" },
 						collect: { as: "reviews" },
 					},
 				],
@@ -883,7 +913,8 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 
 		assert.ok(!result.isError, `chain should succeed: ${JSON.stringify(result.content)}`);
 		assert.equal(mockPi.callCount(), 2);
-		assert.deepEqual(result.details.outputs?.reviews?.structured, []);
+		assert.equal(result.details.outputs?.reviews?.text, "");
+		assert.equal(result.details.outputs?.reviews?.structured, undefined);
 		assert.equal(result.details.workflowGraph?.nodes[1]?.status, "completed");
 		assert.deepEqual(result.details.workflowGraph?.nodes[1]?.children, []);
 	});
@@ -1100,7 +1131,9 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		assert.equal(result.details.results.length, 2);
 		assert.equal(result.details.results[0]?.acceptance?.status, "rejected");
 		assert.equal(result.details.results[0]?.exitCode, 0);
-		assert.match(result.details.results[1]?.finalOutput ?? "", /Step 2 ran/);
+		assert.equal(result.details.results[1]?.finalOutput, undefined);
+		assert.ok(result.details.results[1]?.savedOutputPath);
+		assert.equal(fs.readFileSync(result.details.results[1]!.savedOutputPath!, "utf-8"), "Step 2 ran");
 	});
 
 	it("agent contract v1 chain can gate progression on acceptance", async () => {
@@ -1172,7 +1205,8 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 		);
 
 		const finalTaskArg = readCallArgs(chainLength - 1).at(-1) ?? "";
-		assert.match(finalTaskArg, /step-38-output/);
+		assert.match(finalTaskArg, /Output saved to: /);
+		assert.doesNotMatch(finalTaskArg, /step-38-output/);
 		assert.doesNotMatch(finalTaskArg, /step-37-output/);
 		assert.match(result.content[0]?.text ?? "", /40 steps/);
 	});
@@ -1261,7 +1295,9 @@ describe("chain execution — sequential", { skip: !available ? "pi packages not
 			);
 
 			assert.ok(!result.isError);
-			assert.deepEqual(JSON.parse(result.details.results[0].finalOutput ?? "{}"), {
+			const depthChild = result.details.results[0];
+			assert.ok(depthChild.savedOutputPath);
+			assert.deepEqual(JSON.parse(fs.readFileSync(depthChild.savedOutputPath, "utf-8")), {
 				SELESAI_SUBAGENT_DEPTH: "1",
 				SELESAI_SUBAGENT_MAX_DEPTH: "1",
 			});
@@ -1361,6 +1397,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 () => {
@@ -1450,8 +1487,9 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 
 		assert.ok(!result.isError);
 		const finalTask = readCallArgs(2).at(-1) ?? "";
-		assert.match(finalTask, /Alpha named output/);
-		assert.match(finalTask, /Beta named output/);
+		assert.match(finalTask, /Output saved to: /);
+		assert.doesNotMatch(finalTask, /Alpha named output/);
+		assert.doesNotMatch(finalTask, /Beta named output/);
 	});
 
 	it("funnels an initial parallel step through one agent, then fans the funnel output back out", async () => {
@@ -1488,13 +1526,14 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 		assert.equal(result.details.totalSteps, 3);
 		const funnelTask = readCallArgsMatching("Synthesize:").at(-1) ?? "";
 		assert.match(funnelTask, /=== Parallel Task 1 \(scout-a\) ===/);
-		assert.match(funnelTask, /Scout A findings/);
 		assert.match(funnelTask, /=== Parallel Task 2 \(scout-b\) ===/);
-		assert.match(funnelTask, /Scout B findings/);
+		assert.match(funnelTask, /Output saved to: /);
+		assert.doesNotMatch(funnelTask, /Scout A findings/);
+		assert.doesNotMatch(funnelTask, /Scout B findings/);
 		const fanoutTaskA = readCallArgsMatching("Review funnel A:").at(-1) ?? "";
 		const fanoutTaskB = readCallArgsMatching("Review funnel B:").at(-1) ?? "";
-		assert.match(fanoutTaskA, /Review funnel A:\nFunnel synthesis/);
-		assert.match(fanoutTaskB, /Review funnel B:\nFunnel synthesis/);
+		assert.match(fanoutTaskA, /Review funnel A:\nOutput saved to: /);
+		assert.match(fanoutTaskB, /Review funnel B:\nOutput saved to: /);
 		assert.equal(result.details.workflowGraph?.nodes[0]?.kind, "parallel-group");
 		assert.equal(result.details.workflowGraph?.nodes[1]?.kind, "step");
 		assert.equal(result.details.workflowGraph?.nodes[2]?.kind, "parallel-group");
@@ -1536,7 +1575,7 @@ describe("chain execution — parallel steps", { skip: !available ? "pi packages
 			makeChainParams(
 				[{
 					parallel: [
-						{ agent: "reviewer-a", task: "Review A", outputMode: "file-only" },
+						{ agent: "reviewer-a", task: "Review A", output: false, outputMode: "file-only" },
 						{ agent: "reviewer-b", task: "Review B", output: "b.md" },
 					],
 				}],
@@ -1700,6 +1739,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

@@ -310,7 +310,8 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 
 		assert.equal(result.isError, undefined);
 		const args = readCallArgs();
-		assert.ok((args.at(-1) ?? "").startsWith("Task: \n\n## Acceptance Contract"));
+		assert.ok((args.at(-1) ?? "").startsWith("Task: \n\n---\n**Output:**"));
+		assert.match(args.at(-1) ?? "", /## Acceptance Contract/);
 	});
 
 	it("does not treat top-level agent as single mode when tasks are present", async () => {
@@ -327,7 +328,8 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 
 		assert.equal(result.isError, undefined);
 		const args = readCallArgs();
-		assert.ok((args.at(-1) ?? "").startsWith("Task: parallel task\n\n## Acceptance Contract"));
+		assert.ok((args.at(-1) ?? "").startsWith("Task: parallel task\n\n---\n**Output:**"));
+		assert.match(args.at(-1) ?? "", /## Acceptance Contract/);
 	});
 
 	it("uses agent defaultContext fork when launch context is omitted", async () => {
@@ -1827,7 +1829,7 @@ describe("fork context execution wiring", { skip: !available ? "subagent executo
 		);
 
 		assert.equal(result.isError, undefined);
-		const args = readAllCallArgs().find((callArgs) => (callArgs.at(-1) ?? "").startsWith(`Task: ${task}\n\n## Acceptance Contract`));
+		const args = readAllCallArgs().find((callArgs) => (callArgs.at(-1) ?? "").startsWith(`Task: ${task}\n\n---\n**Output:**`));
 		assert.ok(args, "expected a recorded mock pi call for this test task");
 		const modelIndex = args.indexOf("--model");
 		assert.notEqual(modelIndex, -1);
@@ -1863,14 +1865,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),