@selesai/code 0.13.40 → 0.14.3

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

@@ -4,7 +4,7 @@ import { visibleWidth } from "@earendil-works/pi-tui";
 import { extractToolArgsPreview } from "../../src/shared/utils.ts";
 
 const { buildWidgetLines, clearLegacyResultAnimationTimer, compactTaskText, projectAsyncLane, renderWidget, widgetRenderKey } = await import("../../src/tui/render.ts") as {
-	buildWidgetLines: (jobs: Array<Record<string, unknown>>, theme: { fg(name: string, text: string): string; bold(text: string): string }, width?: number, expanded?: boolean, frame?: number) => string[];
+	buildWidgetLines: (jobs: Array<Record<string, unknown>>, theme: { fg(name: string, text: string): string; bold(text: string): string; getThinkingBorderColor(level: string): (text: string) => string }, width?: number, expanded?: boolean, frame?: number) => string[];
 	clearLegacyResultAnimationTimer: (context: { state: { subagentResultAnimationTimer?: ReturnType<typeof setInterval> } }) => void;
 	compactTaskText: (task: string | undefined, label?: string) => string | undefined;
 	projectAsyncLane: (job: Record<string, unknown>) => { label?: string; role: string; phase?: string; state: string; gate?: string; next?: string; output?: string; workspace?: string; ref: string; chips: string[] } | undefined;
@@ -15,6 +15,7 @@ const { buildWidgetLines, clearLegacyResultAnimationTimer, compactTaskText, proj
 const theme = {
 	fg: (_name: string, text: string) => text,
 	bold: (text: string) => text,
+	getThinkingBorderColor: (_level: string) => (text: string) => text,
 };
 
 const runningGlyphPattern = "[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏●]";
@@ -91,6 +92,95 @@ function resetWidgetLayout(): void {
 }
 
 describe("subagent async widget rendering", () => {
+	it("advances quiet workflow clocks without advancing a terminal sibling", () => {
+		const originalNow = Date.now;
+		const job = {
+			asyncId: "quiet-workflow", asyncDir: "/tmp/quiet", mode: "workflow", status: "running", startedAt: 1_000, updatedAt: 1_083,
+			steps: [
+				{ index: 0, workflowKey: "live", agent: "worker", status: "running", startedAt: 1_000, durationMs: 0 },
+				{ index: 1, workflowKey: "done", agent: "reviewer", status: "complete", startedAt: 1_000, endedAt: 3_000, durationMs: 2_000 },
+			],
+		};
+		try {
+			Date.now = () => 415_000;
+			assert.match(buildWidgetLines([job], theme, 180).join("\n"), /6m54s/);
+			const first = buildWidgetLines([job], theme, 180, true).join("\n");
+			assert.match(first, /worker.*6m54s/);
+			assert.match(first, /reviewer.*2\.0s/);
+			Date.now = () => 425_000;
+			const second = buildWidgetLines([job], theme, 180, true).join("\n");
+			assert.match(second, /worker.*7m4s/);
+			assert.match(second, /reviewer.*2\.0s/);
+			assert.match(buildWidgetLines([{ ...job, status: "complete", updatedAt: 3_000 }], theme, 180).join("\n"), /2\.0s/);
+			assert.equal(job.steps[0]!.durationMs, 0, "rendering must not persist clocks");
+		} finally { Date.now = originalNow; }
+	});
+
+	it("nests two same-agent workflow children once and collapses the group adaptively", () => {
+		const children = ["t7", "t9"].map((key) => ({
+			asyncId: `child-${key}`, asyncDir: `/tmp/${key}`, parentWorkflowRunId: "parent", workflowKey: key,
+			mode: "single", agents: ["chorus-worker"], status: "running", startedAt: 1_000, updatedAt: 1_083,
+		}));
+		const parent = { asyncId: "parent", asyncDir: "/tmp/parent", mode: "workflow", status: "running", startedAt: 1_000, updatedAt: 1_083,
+			steps: children.map((child, index) => ({ index, workflowKey: child.workflowKey, runId: child.asyncId, agent: "chorus-worker", status: "running" })) };
+		for (const expanded of [false, true]) {
+			const lines = buildWidgetLines([children[0]!, parent, children[1]!], theme, 180, expanded);
+			const text = lines.join("\n");
+			for (const key of ["t7", "t9"]) {
+				assert.equal(text.match(new RegExp(`[├└]─ ${key} `, "g"))?.length, 1, text);
+				assert.match(text, new RegExp(`  [├└]─ ${key} .*chorus-worker`));
+				assert.doesNotMatch(text, new RegExp(`${runningGlyphPattern} ${key} · chorus-worker`), "no mirrored lane row");
+			}
+			assert.doesNotMatch(text, new RegExp(`[├└]─ ${runningGlyphPattern} chorus-worker`), "children must not also be sibling cards");
+			assert.ok(lines.every((line) => visibleWidth(line) <= 180));
+		}
+		assert.equal(buildWidgetLines(children, theme, 180).join("\n").match(new RegExp(`[├└]─ ${runningGlyphPattern} chorus-worker`, "g"))?.length, 2, "orphans stay visible");
+		for (const rows of [12, 30, 80]) withStdoutSize(rows, 100, () => {
+			resetWidgetLayout();
+			const { ctx, widgets } = createUiContext();
+			renderWidget(ctx, [parent, ...children]);
+			const lines = renderWidgetLines(widgets[0], 100);
+			const text = lines.join("\n");
+			for (const key of ["t7", "t9"]) {
+				const count = text.match(new RegExp(`[├└]─ ${key} `, "g"))?.length ?? 0;
+				assert.ok(count <= 1, text);
+				if (rows === 80) assert.equal(count, 1, "roomy adaptive layout keeps both child rows");
+			}
+			assert.ok(lines.every((line) => visibleWidth(line) <= 100));
+			assert.ok(lines.length <= 14);
+			resetWidgetLayout();
+		});
+	});
+	it("keeps live children visible when their workflow parent is not running", () => {
+		for (const status of ["complete", "queued"]) {
+			const parent = { asyncId: "parent", asyncDir: "/tmp/parent", mode: "workflow", status, startedAt: 1_000, updatedAt: 2_000 };
+			const child = { asyncId: "live-child", asyncDir: "/tmp/live-child", mode: "single", status: "running", agents: ["live-worker"], parentWorkflowRunId: "parent", workflowKey: "live" };
+			const jobs = status === "queued"
+				? [parent, child, { asyncId: "other", asyncDir: "/tmp/other", status: "running", agents: ["other-worker"] }]
+				: [parent, child];
+			const full = buildWidgetLines(jobs, theme, 180).join("\n");
+			assert.equal(full.match(new RegExp(`[├└]─ (?:live )?${runningGlyphPattern} live-worker`, "g"))?.length, 1, full);
+			assert.match(full, status === "queued" ? /1 queued/ : /id: parent · 1\.0s/);
+			for (const rows of [12, 23]) withStdoutSize(rows, 100, () => {
+				resetWidgetLayout();
+				const { ctx, widgets } = createUiContext();
+				try {
+					renderWidget(ctx, jobs);
+					const lines = renderWidgetLines(widgets[0], 100);
+					const text = lines.join("\n");
+					if (rows === 12) {
+						assert.match(text, status === "queued" ? /2\/3 running, 1 queued/ : /1\/2 running/);
+						assert.equal(lines.length, 1);
+					} else {
+						assert.equal(text.match(new RegExp(`${runningGlyphPattern} live-worker`, "g"))?.length, 1, text);
+						assert.ok(lines.length <= 4);
+					}
+					assert.ok(lines.every((line) => visibleWidth(line) <= 100));
+				} finally { resetWidgetLayout(); }
+			});
+		}
+	});
+
 	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>();
@@ -172,7 +262,7 @@ describe("subagent async widget rendering", () => {
 		};
 		const compact = buildWidgetLines([job], theme, 180).join("\n");
 		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, /id: a6b9aa6b · 1\/2 done · 1 active · 5 tool uses/);
 		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/);
@@ -877,7 +967,7 @@ describe("subagent async widget rendering", () => {
 		assert.match(text, /Agent 1\/3: reviewer · running · active now · 5 turns · 18 tool uses · 44k token/);
 		assert.match(text, /Agent 2\/3: reviewer · running · active 2s ago · 4 turns · 13 tool uses · 22k token/);
 		assert.match(text, /Agent 3\/3: reviewer · running · grep \| 1\.0s · 3 turns · 11 tool uses · 19k token/);
-		assert.match(text, /Press configured-expand-key for live detail/);
+		assert.match(text, /Configure the expand key for live detail/);
 		assert.doesNotMatch(text, /widget truncated/);
 		assert.ok(lines.length <= 10, "collapsed component should stay under Pi's string-widget cap even though it bypasses it");
 	});
@@ -964,8 +1054,9 @@ describe("subagent async widget rendering", () => {
 
 			renderWidget(ui.ctx as never, crowdedJobs);
 			const crowdedLines = renderWidgetLines(ui.widgets.at(-1));
-			assert.equal(crowdedLines.length, 10, "30 terminal rows should keep the compact widget cap while locking height");
-			assert.match(crowdedLines.join("\n"), /Async agents · 3 agents running/);
+			assert.equal(crowdedLines.length, 4, "the crowded progressive card locks to its content rows");
+			assert.equal(crowdedLines.filter((line) => line.trim() === "").length, 0);
+			assert.match(crowdedLines.join("\n"), /Async agents · 6 agents running/);
 
 			renderWidget(ui.ctx as never, [{
 				...crowdedJobs[0]!,
@@ -978,17 +1069,38 @@ describe("subagent async widget rendering", () => {
 				],
 			}]);
 			const settledLines = renderWidgetLines(ui.widgets.at(-1));
-			assert.equal(settledLines.length, 10, "collapsed widget keeps its locked row count until cleared or resized");
+			assert.equal(settledLines.length, 2, "the card shrinks to header plus the remaining job when jobs leave");
+			assert.equal(settledLines.filter((line) => line.trim() === "").length, 0);
 			assert.match(settledLines.join("\n"), /parallel · done/);
 
 			renderWidget(ui.ctx as never, []);
 			renderWidget(ui.ctx as never, [{ asyncId: "small", asyncDir: "/tmp/small", status: "running", agents: ["worker"], currentTool: "read" }]);
 			const resetLines = renderWidgetLines(ui.widgets.at(-1));
-			assert.ok(resetLines.length < 10, "clearing the widget starts a fresh layout session");
+			assert.ok(resetLines.length < 4, `clearing the widget starts a fresh layout session, got ${resetLines.length}`);
 		});
 		resetWidgetLayout();
 	});
 
+	it("counts unloaded workflow children and step-less parallel runs like FleetView in the progressive header", () => {
+		resetWidgetLayout();
+		// FleetView counts only loaded workflow children, and synthesizes steps from `agents` for step-less runs.
+		const solo = { asyncId: "solo", asyncDir: "/tmp/solo", mode: "single", agents: ["worker"], status: "running", currentTool: "bash" };
+		const cases = [
+			{ expected: "1 agent running", job: { asyncId: "wf", asyncDir: "/tmp/wf", mode: "workflow", status: "running",
+				steps: [0, 1, 2, 3].map((index) => ({ index, workflowKey: `lane-${index}`, runId: `unloaded-${index}`, agent: "scout", status: "running" })) } },
+			{ expected: "3 agents running", job: { asyncId: "par", asyncDir: "/tmp/par", mode: "parallel", status: "running", agents: ["a", "b"] } },
+			{ expected: "3 agents running", job: { asyncId: "par", asyncDir: "/tmp/par", mode: "parallel", status: "running", agents: ["a", "b"], steps: [], runningSteps: 2 } },
+		];
+		for (const { expected, job } of cases) {
+			withStdoutSize(22, 120, () => {
+				const ui = createUiContext();
+				renderWidget(ui.ctx as never, [job, solo]);
+				assert.match(renderWidgetLines(ui.widgets.at(-1), 120)[0] ?? "", new RegExp(`Async agents · ${expected}`), `${job.asyncId} header should say ${expected}`);
+			});
+			resetWidgetLayout();
+		}
+	});
+
 	it("keeps medium terminal progressive fallback within the compact cap", () => {
 		resetWidgetLayout();
 		withStdoutSize(50, 120, () => {
@@ -1008,12 +1120,126 @@ describe("subagent async widget rendering", () => {
 
 			renderWidget(ui.ctx as never, jobs);
 			const lines = renderWidgetLines(ui.widgets.at(-1));
-			assert.equal(lines.length, 14);
+			assert.ok(lines.length <= 14, `progressive card should stay within the compact cap, got ${lines.length}`);
+			assert.equal(lines.filter((line) => line.trim() === "").length, 0, "progressive card should not pad with blank rows");
 			assert.match(lines.join("\n"), /parallel · running/);
 		});
 		resetWidgetLayout();
 	});
 
+	it("shows workflow lanes instead of blank rows in the progressive card (#2578)", () => {
+		resetWidgetLayout();
+		withStdoutSize(36, 120, () => {
+			const lanes = ["lane-1", "lane-2", "lane-3", "lane-4"].map((key) => ({
+				asyncId: `child-${key}`, asyncDir: `/tmp/${key}`, parentWorkflowRunId: "wf", workflowKey: key,
+				mode: "single", agents: ["scout"], status: "running", currentTool: "read",
+			}));
+			const workflow = { asyncId: "wf", asyncDir: "/tmp/wf", mode: "workflow", status: "running",
+				steps: lanes.map((lane, index) => ({ index, workflowKey: lane.workflowKey, runId: lane.asyncId, agent: "scout", status: "running" })) };
+			const single = { asyncId: "solo", asyncDir: "/tmp/solo", mode: "single", agents: ["worker"], status: "running", currentTool: "bash" };
+			const ui = createUiContext();
+			renderWidget(ui.ctx as never, [workflow, ...lanes, single]);
+			const lines = renderWidgetLines(ui.widgets.at(-1), 120);
+			assert.match(lines[0] ?? "", /Async agents · 5 agents running/, "4 workflow lanes plus 1 single run, matching FleetView's active agent count");
+			assert.equal(lines.filter((line) => line.trim() === "").length, 0, lines.join("\n"));
+			assert.equal(lines.length, 7, "header, workflow, four lanes, single run");
+			for (const key of ["lane-1", "lane-2", "lane-3", "lane-4"]) assert.match(lines.join("\n"), new RegExp(`${key} · scout`));
+
+			const extra = { asyncId: "solo-2", asyncDir: "/tmp/solo-2", mode: "single", agents: ["reviewer"], status: "running", currentTool: "grep" };
+			renderWidget(ui.ctx as never, [workflow, ...lanes, single, extra]);
+			const grown = renderWidgetLines(ui.widgets.at(-1), 120);
+			assert.equal(grown.length, lines.length, "a job started before the next relock keeps the locked height");
+			assert.equal(grown.filter((line) => line.trim() === "").length, 0, grown.join("\n"));
+			assert.match(grown.join("\n"), /reviewer · running/);
+		});
+		resetWidgetLayout();
+	});
+
+	it("grows a content-sized progressive card when a job starts before the next relock", () => {
+		resetWidgetLayout();
+		withStdoutSize(30, 120, () => {
+			const wide = {
+				asyncId: "run-wide", asyncDir: "/tmp/run-wide", status: "running", mode: "parallel",
+				agents: Array.from({ length: 40 }, (_, index) => `agent-${index}`), activeParallelGroup: true,
+				runningSteps: 40, completedSteps: 0, stepsTotal: 40,
+				steps: Array.from({ length: 40 }, (_, index) => ({ index, agent: `agent-${index}`, status: "running", currentTool: "read" })),
+			};
+			const ui = createUiContext();
+			renderWidget(ui.ctx as never, [wide]);
+			assert.equal(renderWidgetLines(ui.widgets.at(-1)).length, 2, "one job locks a two-row progressive card");
+
+			const late = { asyncId: "run-late", asyncDir: "/tmp/run-late", status: "running", mode: "single", agents: ["reviewer"], currentTool: "grep" };
+			renderWidget(ui.ctx as never, [wide, late]);
+			const grown = renderWidgetLines(ui.widgets.at(-1));
+			const text = grown.join("\n");
+			assert.equal(grown.length, 3, text);
+			assert.match(text, /parallel · running/);
+			assert.match(text, /reviewer · running/);
+			assert.doesNotMatch(text, /\+\d+ more/);
+			assert.equal(grown.filter((line) => line.trim() === "").length, 0, text);
+
+			renderWidget(ui.ctx as never, [wide, { ...late, status: "complete", currentTool: undefined }]);
+			assert.equal(renderWidgetLines(ui.widgets.at(-1)).length, 3, "a finished job that is still listed keeps the grown height");
+
+			renderWidget(ui.ctx as never, [wide]);
+			assert.equal(renderWidgetLines(ui.widgets.at(-1)).length, 2, "the card shrinks once the finished job leaves the list");
+		});
+		resetWidgetLayout();
+	});
+
+	it("shrinks the progressive card without blank rows when root jobs leave (#2651)", () => {
+		const singles = Array.from({ length: 6 }, (_, index) => ({
+			asyncId: `solo-${index}`, asyncDir: `/tmp/solo-${index}`, mode: "single", agents: ["worker"], status: "running", currentTool: "read",
+		}));
+		const lanes = ["lane-1", "lane-2", "lane-3", "lane-4"].map((key) => ({
+			asyncId: `child-${key}`, asyncDir: `/tmp/${key}`, parentWorkflowRunId: "wf", workflowKey: key,
+			mode: "single", agents: ["scout"], status: "running", currentTool: "read",
+		}));
+		const workflow = { asyncId: "wf", asyncDir: "/tmp/wf", mode: "workflow", status: "running",
+			steps: lanes.map((lane, index) => ({ index, workflowKey: lane.workflowKey, runId: lane.asyncId, agent: "scout", status: "running" })) };
+		const single = singles[0]!;
+		for (const { rows, before, after } of [
+			{ rows: 26, before: singles, after: [single] },
+			{ rows: 36, before: [workflow, ...lanes, single], after: [single] },
+		]) {
+			resetWidgetLayout();
+			withStdoutSize(rows, 120, () => {
+				const ui = createUiContext();
+				renderWidget(ui.ctx as never, before);
+				assert.equal(renderWidgetLines(ui.widgets.at(-1), 120).length, 7, `${rows} rows: progressive card before jobs leave`);
+				for (let pass = 0; pass < 2; pass++) {
+					renderWidget(ui.ctx as never, after);
+					const lines = renderWidgetLines(ui.widgets.at(-1), 120);
+					assert.equal(lines.length, 2, `${rows} rows, pass ${pass}: ${lines.join("\n")}`);
+					assert.equal(lines.filter((line) => line.trim() === "").length, 0, lines.join("\n"));
+				}
+			});
+		}
+		resetWidgetLayout();
+	});
+
+	it("keeps the progressive height when content shrinks but every root job remains", () => {
+		resetWidgetLayout();
+		withStdoutSize(36, 120, () => {
+			const lanes = ["lane-1", "lane-2", "lane-3", "lane-4"].map((key) => ({
+				asyncId: `child-${key}`, asyncDir: `/tmp/${key}`, parentWorkflowRunId: "wf", workflowKey: key,
+				mode: "single", agents: ["scout"], status: "running", currentTool: "read",
+			}));
+			const steps = lanes.map((lane, index) => ({ index, workflowKey: lane.workflowKey, runId: lane.asyncId, agent: "scout", status: "running" }));
+			const workflow = { asyncId: "wf", asyncDir: "/tmp/wf", mode: "workflow", status: "running", steps };
+			const single = { asyncId: "solo", asyncDir: "/tmp/solo", mode: "single", agents: ["worker"], status: "running", currentTool: "bash" };
+			const ui = createUiContext();
+			renderWidget(ui.ctx as never, [workflow, ...lanes, single]);
+			assert.equal(renderWidgetLines(ui.widgets.at(-1), 120).length, 7);
+
+			renderWidget(ui.ctx as never, [{ ...workflow, steps: steps.slice(0, 2) }, lanes[0]!, lanes[1]!, single]);
+			const lines = renderWidgetLines(ui.widgets.at(-1), 120);
+			assert.equal(lines.length, 7, "dropping two lanes with the same root jobs keeps the locked height");
+			assert.doesNotMatch(lines.join("\n"), /lane-3/);
+		});
+		resetWidgetLayout();
+	});
+
 	it("selects the current flat-indexed member from a collapsed parallel group", () => {
 		resetWidgetLayout();
 		withStdoutSize(22, 120, () => {
@@ -1106,7 +1332,7 @@ describe("subagent async widget rendering", () => {
 			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, /Configure the expand key for details/);
 			assert.match(text, /label-helpers/);
 			assert.doesNotMatch(text, /Step \d+\/9|task:|workspace:|out(?:put)?:|next:/i);
 		});
@@ -1292,7 +1518,7 @@ describe("subagent async widget rendering", () => {
 		assert.doesNotMatch(text, /Agent 1\/3: reviewer/);
 		assert.match(text, /⎿  active now/);
 		assert.match(text, /Agent 2\/3: reviewer · running\n\s+⎿  read \| 2\.0s/);
-		assert.match(text, /Press configured-expand-key for live detail/);
+		assert.match(text, /Configure the expand key for live detail/);
 		assert.match(text, /Agent 3\/3: reviewer · complete · 1\.5k token/);
 	});
 
@@ -1428,11 +1654,11 @@ describe("subagent async widget rendering", () => {
 		};
 
 		const collapsedText = buildWidgetLines([job], theme, 180).join("\n");
-		assert.match(collapsedText, /Press configured-expand-key for live detail/);
+		assert.match(collapsedText, /Configure the expand key for live detail/);
 		assert.doesNotMatch(collapsedText, /found renderWidget/);
 
 		const expandedText = buildWidgetLines([job], theme, 180, true).join("\n");
-		assert.doesNotMatch(expandedText, /Press configured-expand-key for live detail/);
+		assert.doesNotMatch(expandedText, /Configure the expand key for live detail/);
 		assert.match(expandedText, /⎿  read: src\/tui\/render\.ts \| 2\.0s/);
 		assert.match(expandedText, outputPathPattern("/tmp/1/output-0.log"));
 		assert.match(expandedText, /grep: async widget/);
@@ -1646,14 +1872,14 @@ describe("subagent async widget rendering", () => {
 		assert.match(collapsedText, /reviewer · running · 23 tool uses · 49\.1s/);
 		assert.match(collapsedText, /task: Review the widget/);
 		assert.match(collapsedText, /⎿  read: src\/tui\/render\.ts \| 2\.0s/);
-		assert.match(collapsedText, /Press configured-expand-key for live detail/);
+		assert.match(collapsedText, /Configure the expand key for live detail/);
 		assert.match(collapsedText, outputPathPattern("/tmp/single-run/output-0.log"));
 		assert.doesNotMatch(collapsedText, /error: failed to inspect the widget/);
 
 		const expandedText = buildWidgetLines([job], theme, 180, true).join("\n");
 		const expandedLines = expandedText.split("\n");
 		const expandedSummary = expandedLines.slice(0, 2).join("\n");
-		assert.doesNotMatch(expandedText, /Press configured-expand-key for live detail/);
+		assert.doesNotMatch(expandedText, /Configure the expand key for live detail/);
 		assert.doesNotMatch(expandedSummary, /step 1\/1/i);
 		assert.match(expandedSummary, /async subagent · background/);
 		assert.match(expandedSummary, /reviewer/);
@@ -1782,7 +2008,7 @@ describe("subagent async widget rendering", () => {
 
 		assert.match(text, /⎿  read 1\.0s/);
 		assert.doesNotMatch(text, /Step 1\/1/);
-		assert.doesNotMatch(text, /Press configured-expand-key for live detail/);
+		assert.doesNotMatch(text, /Configure the expand key for live detail/);
 	});
 
 	it("includes logical chain context for active async chain parallel groups", () => {
@@ -1918,7 +2144,7 @@ describe("subagent async widget rendering", () => {
 		assert.match(text, /chain · step 2\/2/);
 		assert.match(text, /Step 1\/2: parallel group · 3\/3 done/);
 		assert.match(text, /Step 2\/2: writer · running · 1 tool use/);
-		assert.match(text, /Press configured-expand-key for live detail/);
+		assert.match(text, /Configure the expand key for live detail/);
 		assert.match(text, outputPathPattern("/tmp/chain/output-3.log"));
 		assert.doesNotMatch(text, /step 4\/4/);
 		assert.doesNotMatch(text, /Step 4\/4/);

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

@@ -92,7 +92,7 @@ describe("native runner result publication", { skip: !available ? "pi packages u
 						collect: { as: "reviews" }, concurrency: 2,
 					},
 				],
-				agents: [makeAgent("producer", { completionGuard: false }), makeAgent("reviewer", { completionGuard: false })],
+				agents: [makeAgent("producer"), makeAgent("reviewer")],
 				ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: sessionId, completionOwnerId: owner },
 				artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
 				shareEnabled: false, maxSubagentDepth: 2, acceptance: false,
@@ -305,7 +305,7 @@ describe("native runner result publication", { skip: !available ? "pi packages u
 				process.env.RESULT_PUBLICATION_TEST_ROOT = root;
 				mockPi.onCall({ output: "Indexed completion after capacity recovery" });
 				const receipt = executeAsyncSingle(id, {
-					agent: "worker", task: "Complete without a provider", agentConfig: makeAgent("worker", { completionGuard: false }),
+					agent: "worker", task: "Complete without a provider", agentConfig: makeAgent("worker"),
 					ctx: { pi: { events: { emit() {} } }, cwd: tempDir, currentSessionId: sessionId, completionOwnerId: owner },
 					artifactConfig: { enabled: false, includeInput: false, includeOutput: false, includeJsonl: false, includeMetadata: false, cleanupDays: 7 },
 					shareEnabled: false, sessionRoot: path.join(tempDir, "sessions"), maxSubagentDepth: 2, acceptance: false,

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

@@ -7,6 +7,8 @@ import { describe, it } from "node:test";
 import type { ExtensionContext } from "@selesai/code";
 import { buildCompletionKey } from "../../src/runs/background/completion-dedupe.ts";
 import { createResultWatcher as createRawResultWatcher } from "../../src/runs/background/result-watcher.ts";
+import { collectWaitCompletions } from "../../src/runs/background/wait-completions.ts";
+import registerSubagentNotify from "../../src/runs/background/notify.ts";
 import { createResultDeliveryOwnership } from "../../src/runs/background/result-delivery-ownership.ts";
 import { writeAsyncResultFile, writePendingAsyncResultFile } from "../../src/runs/background/result-files.ts";
 import { encodeIndexSegment, MAX_INDEX_SEGMENT_BYTES } from "../../src/runs/background/index-segment.ts";
@@ -14,7 +16,8 @@ import { createScheduledRunManager, scheduledRunStorePath } from "../../src/runs
 import { prepareMissionLaunch, writeMissionAsyncBinding } from "../../src/missions/lifecycle.ts";
 import { readMission, updateMission } from "../../src/missions/store.ts";
 import { createNestedRoute, writeNestedEvent } from "../../src/runs/shared/nested-events.ts";
-import type { SubagentState } from "../../src/shared/types.ts";
+import { SUBAGENT_ASYNC_COMPLETE_EVENT, type SubagentState } from "../../src/shared/types.ts";
+import type { AsyncRunSummary } from "../../src/runs/background/async-status.ts";
 
 const COMPLETION_OWNER_ID = "completion-owner-default";
 
@@ -67,6 +70,31 @@ async function waitForPredicate(predicate: () => boolean, timeoutMs = 2_500): Pr
 }
 
 describe("result watcher", () => {
+	it("keeps running workflow launch receipts nonterminal in notifications and completion events", async () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-dispatch-"));
+		const state = createState();
+		state.currentSessionId = "session-1";
+		const delivered: unknown[] = [], completed: unknown[] = [];
+		const watcher = createResultWatcher({ events: { on: () => () => {}, emit(event, value) { if (event === SUBAGENT_ASYNC_COMPLETE_EVENT) completed.push(value); } } }, state, resultsDir, 60_000, {
+			notifier: { async deliver(value) { delivered.push(value); return true; } },
+		});
+		try {
+			watcher.startResultWatcher();
+			writeIndexedResult(path.join(resultsDir, "dispatch.json"), { id: "dispatch", runId: "dispatch", mode: "workflow", state: "complete", success: true, sessionId: "session-1",
+				results: [{ workflowKey: "child", runId: "child-run", state: "running", output: "", outputState: "absent" }],
+			});
+			assert.equal(await waitForPredicate(() => completed.length === 1), true);
+			for (const value of [...delivered, ...completed]) {
+				assert.equal(value.results[0].status, "running");
+				assert.equal(value.results[0].success, undefined);
+				assert.equal(value.results[0].outputState, "absent");
+				assert.equal(value.results[0].artifactPath, undefined);
+			}
+		} finally {
+			watcher.stopResultWatcher();
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
 	it("does not create Darwin native watchers or idle timers", () => {
 		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-darwin-idle-"));
 		try {
@@ -174,6 +202,33 @@ describe("result watcher", () => {
 		}
 	});
 
+	it("records an id-alias result when runId is empty", async () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-id-alias-"));
+		try {
+			const state = createState();
+			state.currentSessionId = "session-current";
+			const resultPath = path.join(resultsDir, "alias-run.json");
+			writeIndexedResult(resultPath, {
+				id: "alias-run",
+				runId: "",
+				sessionId: "session-current",
+				success: true,
+				summary: "done",
+			});
+			const watcher = createResultWatcher({ events: { on: () => () => {}, emit() {} } }, state, resultsDir, 60_000);
+			try {
+				watcher.primeExistingResults();
+				assert.equal(await waitForPredicate(() => !fs.existsSync(resultPath)), true);
+			} finally {
+				watcher.stopResultWatcher();
+			}
+			assert.equal(state.completedResults?.get("alias-run")?.sessionId, "session-current");
+			assert.equal(state.completedResults?.get("alias-run")?.completion.runId, "alias-run");
+		} finally {
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
 	it("hands predecessor results to the replacement session without widening ownership", async () => {
 		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-transition-"));
 		try {
@@ -505,6 +560,55 @@ describe("result watcher", () => {
 		}
 	});
 
+	it("delivers and cleans up completion when artifact verification reports I/O failure", async () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-artifact-verify-"));
+		const artifactPath = path.join(resultsDir, "retained-output.md");
+		const resultPath = path.join(resultsDir, "artifact-verify.json");
+		const originalStatSync = fsDefault.statSync;
+		const sent: string[] = [];
+		let observations = 0;
+		try {
+			fs.writeFileSync(artifactPath, "retained");
+			writeIndexedResult(resultPath, {
+				id: "artifact-verify", runId: "artifact-verify", mode: "workflow", agent: "workflow",
+				sessionId: "session-current", success: true, summary: "done",
+				results: [{ workflowKey: "worker", runId: "child-1", success: true, output: "x".repeat(5_000), artifactPaths: { outputPath: artifactPath } }],
+			});
+			fsDefault.statSync = ((candidate, ...args) => {
+				if (String(candidate) === artifactPath) throw Object.assign(new Error("storage temporarily unavailable"), { code: "EIO" });
+				return originalStatSync(candidate, ...args);
+			}) as typeof fsDefault.statSync;
+			syncBuiltinESMExports();
+
+			const state = createState();
+			state.currentSessionId = "session-current";
+			const pi = {
+				events: { on: () => () => {}, emit(event: string) { if (event === SUBAGENT_ASYNC_COMPLETE_EVENT) observations += 1; } },
+				sendMessage(message: { content?: string }) { sent.push(message.content ?? ""); },
+			};
+			const notifier = registerSubagentNotify(pi as never, state, { batchConfig: { enabled: false } });
+			const watcher = createResultWatcher(pi, state, resultsDir, 60_000, { notifier });
+			try {
+				watcher.primeExistingResults();
+				assert.equal(await waitForPredicate(() => !fs.existsSync(resultPath)), true);
+				watcher.primeExistingResults();
+				await new Promise((resolve) => setTimeout(resolve, 50));
+			} finally {
+				watcher.stopResultWatcher();
+				notifier.dispose();
+			}
+
+			assert.equal(observations, 1);
+			assert.equal(sent.length, 1);
+			assert.match(sent[0]!, /Output artifact verification failed: stat EIO/);
+			assert.match(sent[0]!, /Full output unavailable/);
+		} finally {
+			fsDefault.statSync = originalStatSync;
+			syncBuiltinESMExports();
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
 	it("does not redeliver user notification after reload while observer retry is pending", async () => {
 		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-observer-reload-"));
 		const originalError = console.error;
@@ -557,6 +661,56 @@ describe("result watcher", () => {
 		}
 	});
 
+	it("retains a readable result reference until failed completion replay persistence recovers", async () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-replay-failure-"));
+		const originalError = console.error;
+		try {
+			console.error = () => {};
+			const runId = "replay-failure";
+			const resultPath = path.join(resultsDir, `${runId}.json`);
+			const archiveDir = path.join(resultsDir, "output-archives");
+			fs.writeFileSync(archiveDir, "blocks archive persistence");
+			writeIndexedResult(resultPath, {
+				id: runId, runId, sessionId: "session-current", success: true,
+				summary: "READABLE_FINDING",
+			});
+			let deliveries = 0;
+			const state = createState();
+			state.currentSessionId = "session-current";
+			const watcher = createResultWatcher({ events: { on: () => () => {}, emit() {} } }, state, resultsDir, 60_000, {
+				notifier: { deliver: async () => { deliveries += 1; return true; } },
+			});
+			const terminal = [{ id: runId, sessionId: "session-current" }] as AsyncRunSummary[];
+			try {
+				watcher.primeExistingResults();
+				assert.equal(await waitForPredicate(() => {
+					if (deliveries !== 1 || !fs.existsSync(resultPath)) return false;
+					return typeof (JSON.parse(fs.readFileSync(resultPath, "utf-8")) as { notificationDeliveredAt?: unknown }).notificationDeliveredAt === "number";
+				}), true);
+				const beforeReferences: string[] = [];
+				assert.equal(collectWaitCompletions(terminal, state, resultsDir, (text) => beforeReferences.push(text))?.[0]?.runId, runId);
+				assert.deepEqual(beforeReferences, [`Result [${runId}]: ${resultPath}`]);
+				assert.match(fs.readFileSync(resultPath, "utf-8"), /READABLE_FINDING/);
+
+				fs.rmSync(archiveDir);
+				watcher.primeExistingResults();
+				assert.equal(await waitForPredicate(() => !fs.existsSync(resultPath)), true);
+				const afterReferences: string[] = [];
+				const completion = collectWaitCompletions(terminal, state, resultsDir, (text) => afterReferences.push(text))?.[0];
+				assert.equal(completion?.runId, runId);
+				assert.equal(typeof completion?.archivePath, "string");
+				assert.deepEqual(afterReferences, [`Result [${runId}]: ${completion!.archivePath}`]);
+				assert.match(fs.readFileSync(completion!.archivePath!, "utf-8"), /READABLE_FINDING/);
+				assert.equal(deliveries, 1);
+			} finally {
+				watcher.stopResultWatcher();
+			}
+		} finally {
+			console.error = originalError;
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
 	it("observes retained-project completions without changing active-session delivery", async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-watcher-scheduled-"));
 		const resultsDir = path.join(root, "results");
@@ -1377,7 +1531,7 @@ describe("result watcher", () => {
 				assert.equal(state.watcher, null);
 				assert.notEqual(state.watcherRestartTimer, null);
 
-				writeIndexedResult(path.join(resultsDir, "done.json"), { sessionId: "session-1", summary: "done" });
+				writeIndexedResult(path.join(resultsDir, "done.json"), { id: "done", sessionId: "session-1", summary: "done" });
 				poll?.();
 				await new Promise((resolve) => setTimeout(resolve, 10));
 			} finally {
@@ -2253,7 +2407,7 @@ describe("result watcher", () => {
 			const emitted: string[] = [];
 			const watcher = createResultWatcher({ events: { on: () => () => {}, emit(event) { emitted.push(event); } } }, state, resultsDir, 60_000);
 			const resultFile = "expired.json";
-			const result = { sessionId: "session-1", agent: "worker", success: true, summary: "new result", timestamp: 123 };
+			const result = { id: "expired", sessionId: "session-1", agent: "worker", success: true, summary: "new result", timestamp: 123 };
 			const resultPath = path.join(resultsDir, resultFile);
 			writeIndexedResult(resultPath, result);
 			state.completionSeen.set(buildCompletionKey(result, `result:${resultFile}`), Date.now() - 61_000);
@@ -2502,4 +2656,4 @@ describe("result watcher", () => {
 		});
 	});
 
-});
+});