@selesai/code 0.13.15 → 0.13.18

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

@@ -0,0 +1,151 @@
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import { makeAgent } from "../support/helpers.ts";
+import type { MockPiResponse } from "../support/mock-pi.ts";
+import { runSync } from "../../src/runs/foreground/execution.ts";
+import { createStructuredOutputRuntime } from "../../src/runs/shared/structured-output.ts";
+import type { JsonSchemaObject } from "../../src/shared/types.ts";
+import {
+	available,
+	executeAsyncSingle,
+	installAsyncExecutionHooks,
+	isAsyncAvailable,
+	mockPi,
+	readAsyncPayload,
+	tempDir,
+} from "../support/async-execution-fixture.ts";
+
+const providerError = "provider transport failed";
+const structuredValue = { verdict: "ready" };
+const structuredSchema: JsonSchemaObject = {
+	type: "object",
+	properties: { verdict: { const: "ready" } },
+	required: ["verdict"],
+	additionalProperties: false,
+};
+const usage = { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, cost: { total: 0 } };
+
+type Host = "background" | "foreground";
+
+function assistantMessage(stopReason: string, content: unknown[] = [], errorMessage?: string) {
+	const message = {
+		role: "assistant",
+		content,
+		model: "mock/test-model",
+		stopReason,
+		usage,
+	};
+	if (!errorMessage) return { type: "message_end", message };
+	return { type: "message_end", message: { ...message, errorMessage } };
+}
+
+function toolCall(name = "read") {
+	return { type: "toolCall", id: `${name}-call`, name, arguments: name === "structured_output" ? { value: structuredValue } : {} };
+}
+
+function failedAssistantRequest() {
+	return assistantMessage("error", [], providerError);
+}
+
+interface FixtureResult {
+	success: boolean;
+	error?: string;
+	structuredOutput?: unknown;
+}
+
+async function runFixture(host: Host, response: MockPiResponse, withStructuredOutput = false): Promise<FixtureResult> {
+	mockPi.onCall(response);
+	const agent = makeAgent("recovery-fixture", { completionGuard: false });
+	const runId = `recovered-assistant-error-${host}-${randomUUID()}`;
+
+	if (host === "foreground") {
+		const structuredOutput = withStructuredOutput ? createStructuredOutputRuntime(structuredSchema, tempDir) : undefined;
+		const options = { runId, acceptance: false as const, waitToolEnabled: false };
+		const result = structuredOutput
+			? await runSync(tempDir, [agent], agent.name, "Exercise the scripted child lifecycle", { ...options, structuredOutput })
+			: await runSync(tempDir, [agent], agent.name, "Exercise the scripted child lifecycle", options);
+		assert.equal(mockPi.callCount(), 1, "the fixture must not launch a fallback child");
+		return { success: result.exitCode === 0, error: result.error, structuredOutput: result.structuredOutput };
+	}
+
+	const params = {
+		agent: agent.name,
+		task: "Exercise the scripted child lifecycle",
+		agentConfig: agent,
+		ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: "recovered-assistant-error-session" },
+		artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
+		shareEnabled: false,
+		sessionRoot: path.join(tempDir, "sessions"),
+		maxSubagentDepth: 2,
+		waitToolEnabled: false,
+		acceptance: false as const,
+	};
+	const launch = withStructuredOutput
+		? executeAsyncSingle(runId, { ...params, structuredOutputSchema: structuredSchema })
+		: executeAsyncSingle(runId, params);
+	assert.equal(launch.isError, undefined, launch.content[0]?.text ?? "background launch failed");
+	const payload = await readAsyncPayload(runId);
+	assert.equal(mockPi.callCount(), 1, "the fixture must not launch a fallback child");
+	return {
+		success: payload.success,
+		error: payload.results[0]?.error,
+		structuredOutput: payload.results[0]?.structuredOutput,
+	};
+}
+
+// These cases use only the installed scripted ChildSessionFactory. They do not
+// load a provider, credential, ambient extension, or real child agent.
+describe("recovered assistant errors", { skip: !available ? "pi packages not available" : undefined }, () => {
+	installAsyncExecutionHooks();
+
+	for (const host of ["background", "foreground"] as const) {
+		it(`${host}: recovered request can terminate with structured_output`, { skip: host === "background" && !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+			const result = await runFixture(host, {
+				jsonl: [
+					failedAssistantRequest(),
+					{ type: "auto_retry_start", attempt: 1, maxAttempts: 3, delayMs: 0, errorMessage: providerError },
+					assistantMessage("toolUse", [toolCall("structured_output")]),
+					{ type: "auto_retry_end", success: true, attempt: 1 },
+				],
+				structuredOutput: structuredValue,
+			}, true);
+
+			assert.equal(result.success, true, result.error);
+			assert.equal(result.error, undefined);
+			assert.deepEqual(result.structuredOutput, structuredValue);
+		});
+
+		it(`${host}: retry success and toolUse without a call do not clear the error`, { skip: host === "background" && !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+			const result = await runFixture(host, {
+				jsonl: [
+					failedAssistantRequest(),
+					{ type: "auto_retry_end", success: true, attempt: 1 },
+					assistantMessage("toolUse"),
+				],
+			});
+
+			assert.equal(result.success, false);
+			assert.match(result.error ?? "", new RegExp(providerError));
+		});
+
+		it(`${host}: a tool call with a non-toolUse stop does not clear the error`, { skip: host === "background" && !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+			const result = await runFixture(host, {
+				jsonl: [failedAssistantRequest(), assistantMessage("length", [toolCall()])],
+			});
+
+			assert.equal(result.success, false);
+			assert.match(result.error ?? "", new RegExp(providerError));
+		});
+
+		it(`${host}: an error-bearing toolUse response replaces rather than clears the error`, { skip: host === "background" && !isAsyncAvailable() ? "jiti not available" : undefined }, async () => {
+			const result = await runFixture(host, {
+				jsonl: [failedAssistantRequest(), assistantMessage("toolUse", [toolCall()], "later provider failure")],
+			});
+
+			assert.equal(result.success, false);
+			assert.match(result.error ?? "", /later provider failure/);
+		});
+	}
+});

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

@@ -696,6 +696,47 @@ describe("renderSubagentResult fork indicator", () => {
 		assert.match(expanded, /✓ five · completed/);
 	});
 
+	it("keeps mixed workflow host diagnostics visible once while deduplicating child errors", () => {
+		const hostError = "CI command failed: executable not found";
+		const childError = "Child review failed";
+		for (const childFailed of [false, true]) {
+			const result = {
+				content: [{ type: "text" as const, text: "workflow failed" }],
+				isError: true,
+				details: {
+					mode: "workflow" as const,
+					results: [{
+						agent: "reviewer",
+						task: "Review changes",
+						exitCode: childFailed ? 1 : 0,
+						error: childFailed ? childError : undefined,
+						finalOutput: childFailed ? "" : "Review complete",
+						messages: [],
+						usage: emptyUsage,
+					}],
+					workflow: {
+						value: "workflow finished",
+						trace: [],
+						emits: [],
+						console: [],
+						receipt: {
+							hostSteps: [{
+								version: 1, kind: "host-step", monitorKind: "command",
+								id: "ci", label: "CI", state: "error", detail: hostError,
+								exitCode: 127, updatedAt: 1,
+							}],
+						},
+					},
+				},
+			};
+			for (const expanded of childFailed ? [true] : [false, true]) {
+				const text = withTerminalWidth(220, () => renderSubagentResult!(result, { expanded }, theme).render(220).join("\n"));
+				assert.equal(text.split(hostError).length - 1, 1, text);
+				if (expanded) assert.equal(text.split(childError).length - 1, childFailed ? 1 : 0, text);
+			}
+		}
+	});
+
 	it("renders a stale-running interrupted aggregate as paused", () => {
 		const result = {
 			content: [{ type: "text" as const, text: "paused" }],
@@ -1405,4 +1446,4 @@ describe("renderSubagentResult fork indicator", () => {
 		}
 	});
 
-});
+});

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

@@ -91,17 +91,78 @@ function resetWidgetLayout(): void {
 }
 
 describe("subagent async widget rendering", () => {
-	it("renders compact workflow plan status by default and keeps details expanded", () => {
+	it("updates the mounted async widget without changing host insertion order", () => {
+		type Widget = { render(width: number): string[]; dispose?(): void };
+		const widgets = new Map<string, Widget>();
+		let registrations = 0;
+		let renderRequests = 0;
+		const tui = { requestRender: () => { renderRequests += 1; } };
+		const ctx = {
+			hasUI: true,
+			ui: {
+				// Pi 0.85 setExtensionWidget disposes/deletes before inserting.
+				setWidget(key: string, factory: ((tui: typeof tui, theme: typeof theme) => Widget) | undefined) {
+					widgets.get(key)?.dispose?.();
+					widgets.delete(key);
+					if (factory) {
+						registrations += 1;
+						widgets.set(key, factory(tui, theme));
+					}
+				},
+			},
+		};
+		const job = { asyncId: "same-run", asyncDir: "/tmp/run", status: "running", agents: ["before-update"] };
+		const originalNow = Date.now;
+		try {
+			Date.now = () => 1_000;
+			renderWidget(ctx, [job]);
+			const mounted = widgets.get("subagent-async")!;
+			assert.match(mounted.render(180).join("\n"), /before-update/);
+			ctx.ui.setWidget("other-extension", () => ({ render: () => ["other"] }));
+			for (const agent of ["after-update", "latest-update"]) {
+				renderWidget({ ...ctx }, [{ ...job, agents: [agent] }]);
+				assert.deepEqual([...widgets.keys()], ["subagent-async", "other-extension"]);
+				assert.equal(widgets.get("subagent-async"), mounted);
+				assert.match(mounted.render(180).join("\n"), new RegExp(agent), "same-frame cache must be invalidated");
+			}
+			assert.equal(registrations, 2, "progress must not re-register either widget");
+			assert.equal(renderRequests, 2, "each update requests a repaint without a timer");
+
+			ctx.ui.setWidget("subagent-async", undefined);
+			renderWidget(ctx, [job]);
+			assert.notEqual(widgets.get("subagent-async"), mounted, "host disposal allows remounting");
+			renderWidget(ctx, []);
+			assert.deepEqual([...widgets.keys()], ["other-extension"]);
+			renderWidget(ctx, [job]);
+			assert.ok(widgets.has("subagent-async"), "cleared widgets can mount again");
+		} finally {
+			Date.now = originalNow;
+			renderWidget(ctx, []);
+		}
+	});
+
+	it("renders compact workflow lanes by default and keeps details expanded", () => {
 		const job = {
-			asyncId: "workflow-preflight",
+			asyncId: "a6b9aa6b-workflow",
 			asyncDir: "/tmp/workflow-preflight",
 			status: "running",
 			mode: "workflow",
+			description: "Review workflow",
+			toolCount: 5,
+			startedAt: 100,
+			updatedAt: 2_600,
 			preflight: {
 				version: 1,
 				coverage: "partial",
-				lanes: [{ key: "review", mode: "review", claims: ["src/tui"], expectedOutput: "review.md" }],
+				lanes: [
+					{ key: "write", mode: "mutation", decision: "apply the smallest fix", claims: ["src/tui"], expectedOutput: "fix.md" },
+					{ key: "review", mode: "review", decision: "check the compact surface", claims: ["src/tui"], expectedOutput: "review.md" },
+				],
 			},
+			steps: [
+				{ index: 0, workflowKey: "review", agent: "reviewer", label: "Review the compact surface", status: "running", toolCount: 2 },
+				{ index: 1, workflowKey: "write", agent: "worker", label: "Apply the smallest fix", status: "complete", toolCount: 3 },
+			],
 			workflow: {
 				trace: [],
 				emits: [],
@@ -110,20 +171,52 @@ describe("subagent async widget rendering", () => {
 			},
 		};
 		const compact = buildWidgetLines([job], theme, 180).join("\n");
-		assert.match(compact, /Plan: 1 lane · review/);
-		assert.match(compact, /Plan note: 1 preflight mismatch · expand for debug\./);
-		assert.doesNotMatch(compact, /key \| mode \| decision \| claims \| expected output \| independence/);
-		assert.doesNotMatch(compact, /review \| review \|/);
-		assert.doesNotMatch(compact, /Preflight advisory/);
+		assert.match(compact, /async workflow: Review workflow ─ background/);
+		assert.match(compact, /id: a6b9aa6b · 1\/2 done · 1 active · 5 tool uses · 2\.5s/);
+		assert.match(compact, /write · worker\/mutation · apply the smallest fix · src\/tui · fix\.md/);
+		assert.match(compact, /review · reviewer\/review · active · check the compact surface · src\/tui · review\.md/);
+		assert.doesNotMatch(compact, /Plan:|Plan note:|preflight mismatch|Preflight advisory/);
+		assert.doesNotMatch(compact, /decision:|claims:|expected:/);
+		assert.doesNotMatch(compact, /output:\s|next:/i);
 
 		const expanded = buildWidgetLines([job], theme, 180, true).join("\n");
-		assert.match(expanded, /Preflight: v1 · partial · 1 lane/);
-		assert.match(expanded, /review \| review \|/);
+		assert.match(expanded, /Preflight: v1 · partial · 2 lanes/);
+		assert.match(expanded, /write \| mutation \| apply the smallest fix \| src\/tui \| fix\.md/);
+		assert.match(expanded, /review \| review \| check the compact surface \| src\/tui \| review\.md/);
 		assert.match(expanded, /expected output \| independence/);
 		assert.match(expanded, /Preflight warnings:/);
 		assert.match(expanded, /review\.extra.*without a declared lane/);
 	});
 
+	it("degrades compact workflow rows without preflight metadata", () => {
+		const job = {
+			asyncId: "workflow-fallback-123",
+			asyncDir: "/tmp/workflow-fallback",
+			status: "running",
+			mode: "workflow",
+			steps: [
+				{ index: 0, workflowKey: "scope", agent: "scout", label: "Scope the request", description: "Inspect the repository", status: "complete", outputName: "scope.md" },
+				{ index: 1, workflowKey: "implement", agent: "worker", label: "Implement the fix", description: "Change only the renderer", status: "running", outputName: "fix.md" },
+			],
+		};
+		const compact = buildWidgetLines([job], theme, 180).join("\n");
+		assert.match(compact, /async workflow: workflow ─ background/);
+		assert.match(compact, /scope · scout · Scope the request/);
+		assert.match(compact, /implement · worker · active · Implement the fix/);
+		assert.doesNotMatch(compact, /Plan:|next:|output:/i);
+
+		const narrow = buildWidgetLines([job], theme, 72);
+		assert.match(narrow[1] ?? "", /id: workflow · 1\/2 done · 1 active/);
+		for (const line of narrow) assert.ok(visibleWidth(line) <= 72, `workflow row exceeds width: ${visibleWidth(line)}`);
+		const tightHeader = buildWidgetLines([{ ...job, description: "backlog-wave" }], theme, 40)[0] ?? "";
+		assert.match(tightHeader, /async workflow backlog-wave · background/);
+		assert.doesNotMatch(tightHeader, /workflow:/);
+		const longJob = { ...job, steps: job.steps.map((step, index) => ({ ...step, label: `${step.label} ${"with a deliberately long lane description ".repeat(4)}`, description: index === 1 ? `${step.description} ${"and more detail ".repeat(8)}` : step.description })) };
+		const truncated = buildWidgetLines([longJob], theme, 72);
+		assert.match(truncated[1] ?? "", /id: workflow · 1\/2 done · 1 active/);
+		assert.ok(truncated.some((line) => line.includes("...")), "narrow lane rows should be truncated");
+	});
+
 	it("projects known workflow metadata into a compact lane row", () => {
 		const job = {
 			asyncId: "lane-run-123456",
@@ -307,15 +400,48 @@ describe("subagent async widget rendering", () => {
 		};
 
 		const text = buildWidgetLines([job], theme, 180).join("\n");
-		assert.match(text, /CI checks 1 active/);
-		assert.match(text, /Review gate 1 blocked/);
-		assert.doesNotMatch(text, /async subagent .*CI checks/);
+		assert.match(text, /async workflow: host-run ─ background/);
+		assert.match(text, /id: host-run · 0\/2 done · 1 active · 1 blocked/);
+		assert.match(text, /ci-1 · active · CI checks/);
+		assert.match(text, /gate-1 · blocked · Review gate/);
+		assert.match(text, /bottleneck · gate-1 · blocked/);
+		assert.doesNotMatch(text, /Plan:|next:|output:/i);
 
 		const expanded = buildWidgetLines([job], theme, 180, true).join("\n");
 		assert.match(expanded, /ci: CI checks · running · provider:local-tests · PR #1614/);
 		assert.match(expanded, /gate: Review gate · inconclusive · provider:opaque-provider · reason:stale-head · stale · out:gate.json/);
 	});
 
+	it("chooses the most severe compact workflow bottleneck", () => {
+		const text = buildWidgetLines([{
+			asyncId: "workflow-bottleneck-severity",
+			asyncDir: "/tmp/workflow-bottleneck-severity",
+			status: "running",
+			mode: "workflow",
+			steps: [
+				{ index: 0, workflowKey: "paused-first", agent: "worker", status: "paused" },
+				{ index: 1, workflowKey: "failed-later", agent: "reviewer", status: "failed", error: "review failed" },
+			],
+		}], theme, 180).join("\n");
+		assert.match(text, /paused-first · worker · paused/);
+		assert.match(text, /failed-later · reviewer · failed/);
+		assert.match(text, /bottleneck · failed-later · failed/);
+		assert.doesNotMatch(text, /bottleneck · paused-first/);
+	});
+
+	it("renders a workflow failure detail once in expanded checklist output", () => {
+		const detail = "review failed with one canonical diagnostic";
+		const text = buildWidgetLines([{
+			asyncId: "workflow-error-dedup",
+			asyncDir: "/tmp/workflow-error-dedup",
+			status: "failed",
+			mode: "workflow",
+			steps: [{ index: 0, workflowKey: "review", agent: "reviewer", status: "failed", error: detail }],
+		}], theme, 180, true).join("\n");
+
+		assert.equal(text.match(new RegExp(detail, "g"))?.length, 1, text);
+	});
+
 	it("keeps simple one-off async rows on the existing fallback projection", () => {
 		const job = {
 			asyncId: "simple-run",
@@ -930,7 +1056,7 @@ describe("subagent async widget rendering", () => {
 		resetWidgetLayout();
 	});
 
-	it("keeps the active runs.lanes stage in focus before collapsed history", () => {
+	it("renders loaded workflow lanes without normal-running bottleneck noise", () => {
 		resetWidgetLayout();
 		withStdoutSize(30, 120, () => {
 			const stageKeys = ["scope-scout", "red-tests", "label-helpers", "summary-title", "detail-row", "tiers-noise", "validation", "minimality-challenge", "fresh-review"];
@@ -973,17 +1099,16 @@ describe("subagent async widget rendering", () => {
 					...(index < 3 ? { lastActivityAt: 100 } : { currentTool: "read", currentToolStartedAt: 190, lastActivityAt: 195 }),
 				})),
 			};
-			const ui = createUiContext();
-			renderWidget(ui.ctx as never, [job]);
-			const lines = renderWidgetLines(ui.widgets.at(-1));
+			const lines = buildWidgetLines([job], theme, 220);
 			const text = lines.join("\n");
-			assert.match(text, /7\/9 done · 1 active · 1 queued/);
-			assert.match(text, /minimality-challenge 1 active/);
-			assert.match(text, /fresh-review 1 queued/);
-			assert.match(text, /bottleneck · minimality-challenge/);
-			assert.match(text, /Press configured-expand-key for live detail/);
-			assert.doesNotMatch(text, /label-helpers/);
-			assert.doesNotMatch(text, /Step \d+\/9|task:|workspace:|out(?:put)?:/i);
+			assert.match(text, /async workflow: workflow ─ background/);
+			assert.match(text, /id: workflow · 7\/9 done · 1 active · 1 queued/);
+			assert.match(text, /issue-1695\.minimality-challenge · worker · active/);
+			assert.match(text, /issue-1695\.fresh-review · worker · queued/);
+			assert.doesNotMatch(text, /bottleneck ·/);
+			assert.match(text, /Press configured-expand-key for details/);
+			assert.match(text, /label-helpers/);
+			assert.doesNotMatch(text, /Step \d+\/9|task:|workspace:|out(?:put)?:|next:/i);
 		});
 		resetWidgetLayout();
 	});
@@ -2091,4 +2216,4 @@ describe("subagent async widget rendering", () => {
 		assert.equal(ui.widgets.length, afterClearCount, "cleared widget should stay quiet");
 		assert.equal(ui.widgets.at(-1), undefined);
 	});
-});
+});