@selesai/code 0.8.3 → 0.8.4

package/dist/extensions/pi-subagents/test/unit/wait-subscriptions.test.ts

@@ -6,6 +6,7 @@ import { describe, it } from "node:test";
 import { waitForSubagents } from "../../src/runs/background/subagent-wait.ts";
 import { registerWaitTool } from "../../src/runs/background/wait-tool.ts";
 import { createWaitSubscriptionManager } from "../../src/runs/background/wait-subscriptions.ts";
+import { recordWaitCompletion } from "../../src/runs/background/wait-completions.ts";
 import { inspectSubagentStatus } from "../../src/runs/background/run-status.ts";
 import { SUBAGENT_ASYNC_COMPLETE_EVENT, type IntercomEventBus, type SubagentState } from "../../src/shared/types.ts";
 
@@ -19,7 +20,7 @@ function writeStatus(asyncRoot: string, runId: string, state: string, extra: obj
 		state,
 		startedAt: now,
 		lastUpdate: now,
-		steps: [{ agent: "builder", status: state }],
+		steps: [{ agent: "worker", status: state }],
 		...extra,
 	}), "utf-8");
 }
@@ -97,7 +98,7 @@ describe("non-blocking wait subscriptions", () => {
 				cwd: root,
 				sessionId: "session-a",
 				updatedAt: Date.now(),
-				children: [{ agent: "builder", index: 0, status: "detached" }],
+				children: [{ agent: "worker", index: 0, status: "detached" }],
 			}]]);
 			let tool: { execute: (...args: unknown[]) => Promise<{ content: Array<{ text?: string }>; isError?: boolean }> } | undefined;
 			registerWaitTool({
@@ -120,10 +121,10 @@ describe("non-blocking wait subscriptions", () => {
 		const resultsDir = path.join(root, "results");
 		const subscriptionsDir = path.join(root, "subscriptions");
 		const bus = new TestBus();
-		const sent: Array<{ message: { content?: unknown }; options?: { triggerTurn?: boolean } }> = [];
+		const sent: Array<{ message: { content?: unknown; details?: { completions?: Array<{ runId?: string; archivePath?: string }> } }; options?: { triggerTurn?: boolean } }> = [];
 		const pi = {
 			events: bus,
-			sendMessage(message: { content?: unknown }, options?: { triggerTurn?: boolean }) { sent.push({ message, options }); },
+			sendMessage(message: { content?: unknown; details?: { completions?: Array<{ runId?: string; archivePath?: string }> } }, options?: { triggerTurn?: boolean }) { sent.push({ message, options }); },
 		};
 		try {
 			writeStatus(asyncRoot, "run-exact", "running", { sessionId: "session-a", pid: 999_999 });
@@ -145,9 +146,19 @@ describe("non-blocking wait subscriptions", () => {
 			assert.equal(sent.length, 0, "an unrelated exact run must not satisfy the subscription");
 
 			writeStatus(asyncRoot, "run-exact", "complete", { sessionId: "session-a" });
+			recordWaitCompletion(restoredState, "run-exact", {
+				agent: "worker",
+				state: "complete",
+				success: true,
+				results: [{ agent: "worker", success: true, output: "done" }],
+			}, Date.now(), 60_000, { resultsDir, sessionId: "session-a" });
+			restoredState.completedResults?.clear();
 			bus.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, { runId: "run-exact" });
 			assert.equal(sent.length, 1);
 			assert.match(String(sent[0]?.message.content), /run run-exact: completed/);
+			assert.match(String(sent[0]?.message.content), /Completion archive:/);
+			assert.equal(sent[0]?.message.details?.completions?.[0]?.runId, "run-exact");
+			assert.ok(sent[0]?.message.details?.completions?.[0]?.archivePath);
 			assert.equal(sent[0]?.options?.triggerTurn, true);
 			assert.equal(restoredState.waitSubscriptions?.has(registration.token), false);
 			assert.equal(fs.existsSync(path.join(subscriptionsDir, `${registration.token}.json`)), false);
@@ -186,6 +197,44 @@ describe("non-blocking wait subscriptions", () => {
 		}
 	});
 
+	it("tells the parent to revive the failed child before replacing resumable async runs", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-subscribe-revive-first-"));
+		const asyncRoot = path.join(root, "runs");
+		const subscriptionsDir = path.join(root, "subscriptions");
+		const completedSessionFile = path.join(root, "completed-session.jsonl");
+		const failedSessionFile = path.join(root, "failed-session.jsonl");
+		const sent: string[] = [];
+		const state = makeState();
+		const manager = createWaitSubscriptionManager({
+			events: new TestBus(),
+			sendMessage(message: { content?: unknown }) { sent.push(String(message.content)); },
+		} as never, state, { asyncDirRoot: asyncRoot, subscriptionsDir, pollIntervalMs: 60_000, kill: () => true });
+		try {
+			fs.writeFileSync(completedSessionFile, "{}\n", "utf-8");
+			fs.writeFileSync(failedSessionFile, "{}\n", "utf-8");
+			writeStatus(asyncRoot, "run-revive", "running", { sessionId: "session-a", pid: 999_999 });
+			manager.arm({ targetKind: "async", runId: "run-revive", requestedId: "run-revive", timeoutMs: 30_000 });
+
+			writeStatus(asyncRoot, "run-revive", "failed", {
+				sessionId: "session-a",
+				steps: [
+					{ agent: "first", status: "complete", sessionFile: completedSessionFile },
+					{ agent: "second", status: "failed", sessionFile: failedSessionFile },
+				],
+			});
+			manager.reconcile();
+
+			const message = sent[0] ?? "";
+			assert.match(message, /Resume-first/);
+			assert.match(message, /subagent\(\{ action: "resume", id: "run-revive", index: 1, message:/);
+			assert.match(message, /before reporting failure or launching a replacement/);
+			assert.match(message, /only if revive fails or the user explicitly asks/);
+		} finally {
+			manager.dispose();
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("waits for foreground run restoration before reconciling a restored subscription", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-subscribe-foreground-restore-"));
 		const subscriptionsDir = path.join(root, "subscriptions");
@@ -198,7 +247,7 @@ describe("non-blocking wait subscriptions", () => {
 			cwd: root,
 			sessionId: "session-a",
 			updatedAt: Date.now(),
-			children: [{ agent: "builder", index: 0, status: "detached" }],
+			children: [{ agent: "worker", index: 0, status: "detached" }],
 		}]]);
 		const pi = {
 			events: bus,
@@ -331,7 +380,7 @@ describe("non-blocking wait subscriptions", () => {
 				sessionId: "session-a",
 				pid: 999_999,
 				activityState: "needs_attention",
-				steps: [{ agent: "builder", status: "running", activityState: "needs_attention" }],
+				steps: [{ agent: "worker", status: "running", activityState: "needs_attention" }],
 			});
 			manager.reconcile();
 			assert.match(sent.shift() ?? "", /needs attention/);

package/dist/extensions/pi-subagents/test/unit/watchdog-child-status.test.ts

@@ -22,19 +22,19 @@ describe("child watchdog status helpers", () => {
 					model: "openai/gpt-test-child",
 					thinking: "low",
 					overrides: {
-						builder: {
-							model: "anthropic/claude-test-builder",
+						worker: {
+							model: "anthropic/claude-test-worker",
 							thinking: false,
 						},
 					},
 				},
 			},
-			agent: "builder",
+			agent: "worker",
 			runId: "run-1",
 			childIndex: 0,
 		});
 
-		assert.equal(config?.model, "anthropic/claude-test-builder");
+		assert.equal(config?.model, "anthropic/claude-test-worker");
 		assert.equal(config?.thinking, false);
 		assert.deepEqual(config?.lsp, DEFAULT_WATCHDOG_CONFIG.lsp);
 	});
@@ -43,7 +43,7 @@ describe("child watchdog status helpers", () => {
 		const payload = {
 			enabled: true,
 			runId: "run-1",
-			agent: "builder",
+			agent: "worker",
 			childIndex: 1,
 			watchdogTailTimeoutMs: 100,
 			agentEndTimeoutMs: 200,
@@ -79,7 +79,7 @@ describe("child watchdog status helpers", () => {
 		const firstEvent = {
 			type: CHILD_WATCHDOG_STATUS_EVENT,
 			runId: "run-1",
-			agent: "builder",
+			agent: "worker",
 			childIndex: 0,
 			seq: 1,
 			phase: "reviewing",
@@ -88,20 +88,20 @@ describe("child watchdog status helpers", () => {
 		} as const;
 
 		assert.equal(isChildWatchdogStatusEvent(firstEvent), true);
-		const first = acceptChildWatchdogEvent({ event: firstEvent, runId: "run-1", agent: "builder", childIndex: 0, current: undefined });
+		const first = acceptChildWatchdogEvent({ event: firstEvent, runId: "run-1", agent: "worker", childIndex: 0, current: undefined });
 		assert.deepEqual(first, { phase: "reviewing", seq: 1, lastUpdate: 10, followUpPending: false });
 		assert.equal(childWatchdogIsActive(first), true);
-		assert.equal(acceptChildWatchdogEvent({ event: firstEvent, current: first, runId: "run-1", agent: "builder", childIndex: 0 }), undefined);
-		assert.equal(acceptChildWatchdogEvent({ event: { ...firstEvent, seq: 2, runId: undefined }, current: first, runId: "run-1", agent: "builder", childIndex: 0 }), undefined);
-		assert.equal(acceptChildWatchdogEvent({ event: { ...firstEvent, seq: 2, agent: undefined }, current: first, runId: "run-1", agent: "builder", childIndex: 0 }), undefined);
-		assert.equal(acceptChildWatchdogEvent({ event: { ...firstEvent, seq: 2, childIndex: undefined }, current: first, runId: "run-1", agent: "builder", childIndex: 0 }), undefined);
-		assert.equal(acceptChildWatchdogEvent({ event: { ...firstEvent, seq: 2, agent: "other" }, current: first, runId: "run-1", agent: "builder", childIndex: 0 }), undefined);
+		assert.equal(acceptChildWatchdogEvent({ event: firstEvent, current: first, runId: "run-1", agent: "worker", childIndex: 0 }), undefined);
+		assert.equal(acceptChildWatchdogEvent({ event: { ...firstEvent, seq: 2, runId: undefined }, current: first, runId: "run-1", agent: "worker", childIndex: 0 }), undefined);
+		assert.equal(acceptChildWatchdogEvent({ event: { ...firstEvent, seq: 2, agent: undefined }, current: first, runId: "run-1", agent: "worker", childIndex: 0 }), undefined);
+		assert.equal(acceptChildWatchdogEvent({ event: { ...firstEvent, seq: 2, childIndex: undefined }, current: first, runId: "run-1", agent: "worker", childIndex: 0 }), undefined);
+		assert.equal(acceptChildWatchdogEvent({ event: { ...firstEvent, seq: 2, agent: "other" }, current: first, runId: "run-1", agent: "worker", childIndex: 0 }), undefined);
 
 		const settled = acceptChildWatchdogEvent({
 			event: { ...firstEvent, seq: 2, phase: "idle", ts: 20 },
 			current: first,
 			runId: "run-1",
-			agent: "builder",
+			agent: "worker",
 			childIndex: 0,
 		});
 		assert.equal(settled?.phase, "idle");

package/dist/extensions/pi-subagents/test/unit/watchdog-lsp-diagnostics.test.ts

@@ -110,7 +110,7 @@ describe("watchdog LSP diagnostics", () => {
 				cwd: temp,
 				root: temp,
 				changedPaths: ["src/file.ts"],
-				config: { enabled: true, timeoutMs: 5000, maxFiles: 10, maxDiagnostics: 10 },
+				config: { enabled: true, timeoutMs: 500, maxFiles: 10, maxDiagnostics: 10 },
 			});
 
 			assert.equal(diagnostics.status, "failed");

package/dist/extensions/pi-subagents/test/unit/watchdog-runtime.test.ts

@@ -337,7 +337,7 @@ describe("main watchdog runtime", () => {
 		assert.equal(runtime.getSnapshot().lastWarning, undefined);
 	});
 
-	it("bounds review input before calling the commentator", async () => {
+	it("bounds review input before calling the reviewer", async () => {
 		let reviewedDelta = "";
 		const runtime = new MainWatchdogRuntime({
 			resolveConfig: () => configResult(enabledConfig()),

package/dist/extensions/pi-subagents/test/unit/watchdog-settings.test.ts

@@ -87,7 +87,7 @@ describe("watchdog settings", () => {
 					children: {
 						autoFollow: { maxAttempts: 4 },
 						overrides: {
-							builder: { enabled: true, model: "anthropic/claude-test" },
+							worker: { enabled: true, model: "anthropic/claude-test" },
 						},
 					},
 					guidance: { systemPromptPath: "/tmp/user-watchdog.md" },
@@ -105,8 +105,8 @@ describe("watchdog settings", () => {
 					children: {
 						autoFollow: { blockers: false },
 						overrides: {
-							builder: { thinking: "medium" },
-							commentator: { enabled: false },
+							worker: { thinking: "medium" },
+							reviewer: { enabled: false },
 						},
 					},
 				},
@@ -118,7 +118,7 @@ describe("watchdog settings", () => {
 				autoFollow: { maxAttempts: null },
 				children: {
 					overrides: {
-						builder: { enabled: false },
+						worker: { enabled: false },
 					},
 				},
 			},
@@ -133,12 +133,12 @@ describe("watchdog settings", () => {
 		assert.deepEqual(result.config.cadence, { everyNTools: 10 });
 		assert.deepEqual(result.config.lsp, { enabled: false, timeoutMs: 1500, maxFiles: 4, maxDiagnostics: 7 });
 		assert.deepEqual(result.config.children.autoFollow, { blockers: false, maxAttempts: 4, stalemateRepeats: 3 });
-		assert.deepEqual(result.config.children.overrides.builder, {
+		assert.deepEqual(result.config.children.overrides.worker, {
 			enabled: false,
 			model: "anthropic/claude-test",
 			thinking: "medium",
 		});
-		assert.deepEqual(result.config.children.overrides.commentator, { enabled: false });
+		assert.deepEqual(result.config.children.overrides.reviewer, { enabled: false });
 	});
 
 	it("returns exact validation errors at the watchdog boundary", () => {
@@ -166,7 +166,7 @@ describe("watchdog settings", () => {
 		writeJson(userSettingsPath(), {
 			subagents: {
 				watchdog: {
-					children: { overrides: { builder: { mode: "fast" } } },
+					children: { overrides: { worker: { mode: "fast" } } },
 				},
 			},
 		});
@@ -174,7 +174,7 @@ describe("watchdog settings", () => {
 		assert.throws(
 			() => resolveWatchdogConfigStrict(tempProject),
 			(error: unknown) => error instanceof Error
-				&& error.message === `Watchdog settings in '${userSettingsPath()}' have unknown field 'subagents.watchdog.children.overrides.builder.mode'.`,
+				&& error.message === `Watchdog settings in '${userSettingsPath()}' have unknown field 'subagents.watchdog.children.overrides.worker.mode'.`,
 		);
 	});
 

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

@@ -39,13 +39,13 @@ function job(child: NestedRunSummary): AsyncJobState {
 
 describe("nested widget rendering", () => {
 	it("renders a bounded collapsed tree and full child rows when expanded", () => {
-		const child = nested("nested-commentator", "root-run", "running", { currentTool: "read", model: "gpt-5.6-luna:medium", thinking: "medium" });
+		const child = nested("nested-reviewer", "root-run", "running", { currentTool: "read", model: "gpt-5.6-luna:medium", thinking: "medium" });
 		const collapsed = buildWidgetLines([job(child)], theme as any, 120, false).join("\n");
-		assert.match(collapsed, /↳ └─ \[\d{2}:\d{2}:\d{2}\] . nested-commentator · running · gpt-5.6-luna · thinking medium · read/);
+		assert.match(collapsed, /↳ └─ \[\d{2}:\d{2}:\d{2}\] . nested-reviewer · running · gpt-5.6-luna · thinking medium · read/);
 		assert.equal((collapsed.match(/thinking medium/g) ?? []).length, 1);
 
 		const expanded = buildWidgetLines([job(child)], theme as any, 120, true).join("\n");
-		assert.match(expanded, /↳ \[\d{2}:\d{2}:\d{2}\] . nested-commentator · running · gpt-5.6-luna · thinking medium · read/);
+		assert.match(expanded, /↳ \[\d{2}:\d{2}:\d{2}\] . nested-reviewer · running · gpt-5.6-luna · thinking medium · read/);
 
 		const epoch = buildWidgetLines([job(nested("epoch", "root-run", "running", { lastUpdate: 0, startedAt: 0 }))], theme as any, 120, false).join("\n");
 		assert.match(epoch, /↳ └─ \[\d{2}:\d{2}:\d{2}\] . epoch · running/);
@@ -137,7 +137,7 @@ describe("nested widget rendering", () => {
 	});
 
 	it("keeps event-time timestamps stable instead of advancing with wall time", async () => {
-		const state = job(nested("nested-commentator", "root-run", "running", { currentTool: "read", currentToolStartedAt: 0 }));
+		const state = job(nested("nested-reviewer", "root-run", "running", { currentTool: "read", currentToolStartedAt: 0 }));
 		const first = buildWidgetLines([state], theme as any, 120, true);
 		await new Promise((resolve) => setTimeout(resolve, 20));
 		const second = buildWidgetLines([state], theme as any, 120, true);
@@ -145,8 +145,8 @@ describe("nested widget rendering", () => {
 	});
 
 	it("rerenders when only nested state changes", () => {
-		const first = job(nested("nested-commentator", "root-run", "running"));
-		const second = job(nested("nested-commentator", "root-run", "complete"));
+		const first = job(nested("nested-reviewer", "root-run", "running"));
+		const second = job(nested("nested-reviewer", "root-run", "complete"));
 		assert.notEqual(widgetRenderKey(first), widgetRenderKey(second));
 	});
 });

package/dist/extensions/pi-subagents/test/unit/workflow-chat-progress.test.ts

@@ -6,8 +6,10 @@ import * as path from "node:path";
 import { describe, it } from "node:test";
 import { isSameGitRepository, resolveWorkflowChatProgress } from "../../src/workflows/chat-progress.ts";
 import { renderSubagentResult } from "../../src/tui/render.ts";
-import { createSubagentExecutor, foregroundResultIntercomStatus, shouldSuppressRoutineResultIntercom } from "../../src/runs/foreground/subagent-executor.ts";
-import type { Details, SingleResult, SubagentState } from "../../src/shared/types.ts";
+import { bindMissionWorkflowChildAsyncLaunch, createSubagentExecutor, foregroundResultIntercomStatus, missionWorkflowChildStatus, runMissionWorkflowChild, shouldSuppressRoutineResultIntercom } from "../../src/runs/foreground/subagent-executor.ts";
+import { readMissionBinding } from "../../src/missions/lifecycle.ts";
+import { createMission, readMission } from "../../src/missions/store.ts";
+import { DIRS, type Details, type SingleResult, type SubagentState } from "../../src/shared/types.ts";
 
 const theme = {
 	fg(_name: string, text: string): string { return text; },
@@ -96,6 +98,7 @@ describe("workflow chat progress policy", () => {
 			assert.equal(resolveWorkflowChatProgress({ requested: "auto", parentCwd: repo, workflowCwd: worktree, background: true }).projection?.mode, "milestones");
 			assert.equal(resolveWorkflowChatProgress({ requested: "auto", parentCwd: repo, workflowCwd: other, background: false }).projection?.mode, "terminal");
 			assert.match(resolveWorkflowChatProgress({ requested: "live-card", parentCwd: repo, workflowCwd: other, background: false }).error ?? "", /same Git repository/i);
+			assert.match(resolveWorkflowChatProgress({ requested: "terminal", parentCwd: repo, workflowCwd: repo, background: false }).projection?.mode ?? "", /terminal/);
 		} finally {
 			try { git(repo, ["worktree", "remove", "--force", worktree]); } catch {}
 			fs.rmSync(repo, { recursive: true, force: true });
@@ -112,7 +115,7 @@ describe("workflow chat progress rendering", () => {
 			const updates: Array<{ details?: Details }> = [];
 			const result = await createExecutor().execute(
 				"wf-live",
-				{ workflowScript: `return await runs.run("explorer", { agent: "missing-agent", task: "scan", phase: "Validation", label: "Find renderer seam" });`, async: false },
+				{ workflowScript: `return await runs.run("scout", { agent: "missing-agent", task: "scan", phase: "Validation", label: "Find renderer seam" });`, async: false },
 				new AbortController().signal,
 				(update) => updates.push(update),
 				ctx(repo),
@@ -120,14 +123,85 @@ describe("workflow chat progress rendering", () => {
 			assert.equal(result.isError, true);
 			const liveUpdate = updates.find((update) => update.details?.chatProgress?.mode === "live-card");
 			assert.ok(liveUpdate, "expected a live-card update");
-			assert.equal(liveUpdate.details?.workflow?.trace[0]?.key, "explorer");
+			assert.equal(liveUpdate.details?.workflow?.trace[0]?.key, "scout");
 			assert.equal(liveUpdate.details?.workflow?.trace[0]?.phase, "Validation");
 			assert.equal(liveUpdate.details?.workflow?.trace[0]?.label, "Find renderer seam");
+			const ledgerChild = result.details.mission?.workflowChildren[0];
+			assert.equal(ledgerChild?.key, "scout");
+			assert.equal(ledgerChild?.workflowRunId, "wf-live");
+			assert.equal(ledgerChild?.agent, "missing-agent");
+			assert.equal(ledgerChild?.phase, "Validation");
+			assert.equal(ledgerChild?.status, "failed");
+			assert.equal(ledgerChild?.heartbeat?.status, "failed");
 		} finally {
 			fs.rmSync(repo, { recursive: true, force: true });
 		}
 	});
 
+	it("keeps async workflow launch receipts running in the mission ledger", () => {
+		assert.equal(missionWorkflowChildStatus({
+			content: [{ type: "text", text: "Async: worker [run-1]" }],
+			details: { mode: "single", runId: "run-1", asyncId: "run-1", asyncDir: "/tmp/run-1", results: [] },
+		} as any), "running");
+	});
+
+	it("writes mission binding before async workflow child launch", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-workflow-child-binding-"));
+		const asyncId = `workflow-child-${process.pid}-${Date.now()}`;
+		const asyncDir = path.join(DIRS.async, asyncId);
+		try {
+			const location = {
+				projectRoot: root,
+				missionDir: path.join(root, ".pi-subagents", "missions"),
+				globalIndexDir: path.join(root, ".pi-subagents", "mission-index"),
+				writeGlobalIndex: false,
+			};
+			const mission = createMission(location, { title: "Workflow", objective: "Track child" });
+			const params = bindMissionWorkflowChildAsyncLaunch(
+				{ agent: "worker", task: "run", async: true },
+				{ missionId: mission.id, location, autoCreated: false },
+				false,
+				asyncId,
+			);
+
+			assert.equal(params.workflowChildAsyncId, asyncId);
+			assert.equal(readMissionBinding(asyncDir)?.missionId, mission.id);
+		} finally {
+			fs.rmSync(asyncDir, { recursive: true, force: true });
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("marks workflow launch preparation failures as failed mission children", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-workflow-prep-failure-"));
+		try {
+			const location = {
+				projectRoot: root,
+				missionDir: path.join(root, ".pi-subagents", "missions"),
+				globalIndexDir: path.join(root, ".pi-subagents", "mission-index"),
+				writeGlobalIndex: false,
+			};
+			const mission = createMission(location, { title: "Workflow", objective: "Track child" });
+
+			await assert.rejects(
+				() => runMissionWorkflowChild({ missionId: mission.id, location, autoCreated: false }, "wf-prep-failure", "resume", "Prep", async () => {
+					throw new Error("gate is not supported with retained resume");
+				}),
+				/gate is not supported with retained resume/,
+			);
+			const ledgerChild = readMission(location, mission.id).workflowChildren[0];
+
+			assert.equal(ledgerChild?.key, "resume");
+			assert.equal(ledgerChild?.status, "failed");
+			assert.equal(ledgerChild?.heartbeat?.status, "failed");
+			assert.equal(ledgerChild?.heartbeat?.phase, "Prep");
+			assert.match(ledgerChild?.heartbeat?.message ?? "", /gate is not supported with retained resume/);
+			assert.ok(ledgerChild?.completedAt);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("renders stable rows keyed by workflow trace entries", () => {
 		const text = componentText(renderSubagentResult({
 			content: [{ type: "text", text: "Workflow running." }],
@@ -138,7 +212,7 @@ describe("workflow chat progress rendering", () => {
 				chatProgress: { mode: "live-card", repoRelation: "same", repoLabel: "pi-subagents" },
 				workflow: {
 					trace: [
-						{ operation: "run", key: "explorer", state: "completed", runId: "run-explorer", phase: "Validation", label: "Found renderer seam", durationMs: 12 },
+						{ operation: "run", key: "scout", state: "completed", runId: "run-scout", phase: "Validation", label: "Found renderer seam", durationMs: 12 },
 						{ operation: "run", key: "tests", state: "started", phase: "Validation", label: "focused integration suite" },
 						{ operation: "run", key: "review", state: "failed", phase: "Validation", label: "fresh-context UX review", error: "needs fixes" },
 					],
@@ -151,15 +225,68 @@ describe("workflow chat progress rendering", () => {
 		assert.match(text, /workflow wf_8f3a12345 .* same repo .* failed/);
 		assert.match(text, /Repo   pi-subagents/);
 		assert.match(text, /Phase  Validation/);
-		assert.match(text, /complete\s+explorer Found renderer seam/);
+		assert.match(text, /complete\s+scout Found renderer seam/);
 		assert.match(text, /running\s+tests focused integration suite/);
 		assert.match(text, /failed\s+review fresh-context UX review .* needs fixes/);
 	});
 
+	it("bounds workflow live-card rows and keeps old failed children visible", () => {
+		const trace = Array.from({ length: 10 }, (_, index) => ({
+			operation: "run" as const,
+			key: `step-${index}`,
+			state: index === 0 ? "failed" as const : "started" as const,
+			label: `review ${index}`,
+			...(index === 0 ? { error: "Failed\n\nOutput:\nI will read the required plan first.\nI will inspect the exact head.\nI will read agent default application path." } : {}),
+		}));
+		const text = componentText(renderSubagentResult({
+			content: [{ type: "text", text: "Workflow running." }],
+			details: {
+				mode: "workflow",
+				runId: "wf_noisy",
+				results: [],
+				chatProgress: { mode: "live-card", repoRelation: "same", repoLabel: "pi-subagents" },
+				workflow: { trace, emits: [], console: [] },
+			},
+		}, { expanded: false }, theme as any));
+
+		assert.match(text, /2 older workflow rows hidden/);
+		assert.match(text, /failed\s+step-0 review 0 .* Failed · latest: read agent default application path/);
+		assert.match(text, /running\s+step-9 review 9/);
+		assert.doesNotMatch(text, /step-1/);
+		assert.doesNotMatch(text, /Output:/);
+	});
+
+	it("keeps mixed workflow child error output visible", () => {
+		const text = componentText(renderSubagentResult({
+			content: [{ type: "text", text: "Workflow running." }],
+			details: {
+				mode: "workflow",
+				runId: "wf_mixed_error",
+				results: [],
+				chatProgress: { mode: "live-card", repoRelation: "same", repoLabel: "pi-subagents" },
+				workflow: {
+					trace: [{
+						operation: "run",
+						key: "gate-monitor",
+						state: "failed",
+						label: "bot gate",
+						error: "Failed\n\nOutput:\nerror: failed to fetch review threads\nI will inspect the retry path.",
+					}],
+					emits: [],
+					console: [],
+				},
+			},
+		}, { expanded: false }, theme as any));
+
+		assert.match(text, /Failed · error: failed to fetch review threads I will inspect the retry path/);
+		assert.doesNotMatch(text, /latest: inspect the retry path/);
+		assert.doesNotMatch(text, /Output:/);
+	});
+
 	it("suppresses only successful routine child result intercom for live-card workflows", () => {
-		const completed = { agent: "explorer", exitCode: 0, outputState: "present" } as SingleResult;
-		const failed = { agent: "explorer", exitCode: 1, outputState: "present" } as SingleResult;
-		const rejected = { agent: "explorer", exitCode: 0, acceptance: { status: "rejected" }, outputState: "present" } as SingleResult;
+		const completed = { agent: "delegate", exitCode: 0, outputState: "present" } as SingleResult;
+		const failed = { agent: "delegate", exitCode: 1, outputState: "present" } as SingleResult;
+		const rejected = { agent: "delegate", exitCode: 0, acceptance: { status: "rejected" }, outputState: "present" } as SingleResult;
 
 		assert.equal(shouldSuppressRoutineResultIntercom({ suppressRoutineResultIntercom: true, results: [completed] }), true);
 		assert.equal(shouldSuppressRoutineResultIntercom({ suppressRoutineResultIntercom: true, results: [failed] }), false);
@@ -168,7 +295,7 @@ describe("workflow chat progress rendering", () => {
 	});
 
 	it("marks acceptance-rejected foreground intercom results as failed", () => {
-		const rejected = { agent: "explorer", exitCode: 0, acceptance: { status: "rejected" }, outputState: "present" } as SingleResult;
+		const rejected = { agent: "delegate", exitCode: 0, acceptance: { status: "rejected" }, outputState: "present" } as SingleResult;
 
 		assert.equal(foregroundResultIntercomStatus(rejected), "failed");
 	});
@@ -183,7 +310,7 @@ describe("workflow chat progress rendering", () => {
 				chatProgress: { mode: "live-card", repoRelation: "same", repoLabel: "pi-subagents" },
 				workflow: {
 					value: "final answer",
-					trace: [{ operation: "run", key: "explorer", state: "completed", runId: "run-explorer" }],
+					trace: [{ operation: "run", key: "scout", state: "completed", runId: "run-scout" }],
 					emits: [],
 					console: [],
 				},

package/dist/extensions/pi-subagents/test/unit/workflow-graph.test.ts

@@ -7,7 +7,7 @@ describe("workflow graph snapshots", () => {
 		const graph = buildWorkflowGraphSnapshot({
 			runId: "run-1",
 			steps: [
-				{ agent: "explorer", task: "Scan", phase: "Research", label: "Find context", as: "context" },
+				{ agent: "scout", task: "Scan", phase: "Research", label: "Find context", as: "context" },
 				{ agent: "writer", task: "Use {outputs.context}", phase: "Synthesis", outputSchema: { type: "object" } },
 			],
 			results: [{ exitCode: 0 }, { exitCode: 1, error: "bad output" }],
@@ -25,9 +25,9 @@ describe("workflow graph snapshots", () => {
 		]);
 	});
 
-	it("maps a long alternating builder and commentator chain without losing indexes", () => {
+	it("maps a long alternating worker and reviewer chain without losing indexes", () => {
 		const steps = Array.from({ length: 40 }, (_, index) => ({
-			agent: index % 2 === 0 ? "builder" : "commentator",
+			agent: index % 2 === 0 ? "worker" : "reviewer",
 			task: index === 0 ? "Start" : "{previous}",
 		}));
 		const results = steps.map(() => ({ exitCode: 0 }));
@@ -43,10 +43,10 @@ describe("workflow graph snapshots", () => {
 		assert.equal(graph.nodes[0]?.id, "step-0");
 		assert.equal(graph.nodes[0]?.flatIndex, 0);
 		assert.equal(graph.nodes[37]?.id, "step-37");
-		assert.equal(graph.nodes[37]?.agent, "commentator");
+		assert.equal(graph.nodes[37]?.agent, "reviewer");
 		assert.equal(graph.nodes[37]?.flatIndex, 37);
 		assert.equal(graph.nodes[39]?.id, "step-39");
-		assert.equal(graph.nodes[39]?.agent, "commentator");
+		assert.equal(graph.nodes[39]?.agent, "reviewer");
 		assert.equal(graph.nodes[39]?.flatIndex, 39);
 		assert.equal(graph.currentNodeId, "step-37");
 	});
@@ -58,7 +58,7 @@ describe("workflow graph snapshots", () => {
 				{ agent: "setup", task: "Setup" },
 				{
 					parallel: [
-						{ agent: "commentator", label: "Correctness", phase: "Review", as: "correctness" },
+						{ agent: "reviewer", label: "Correctness", phase: "Review", as: "correctness" },
 						{ agent: "security", label: "Security", phase: "Review", as: "security" },
 					],
 				},
@@ -107,7 +107,7 @@ describe("workflow graph snapshots", () => {
 	it("uses dynamic group status overrides for empty or aggregate-failure fanout states", () => {
 		const steps = [{
 			expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-			parallel: { agent: "commentator", task: "Review {item}" },
+			parallel: { agent: "reviewer", task: "Review {item}" },
 			collect: { as: "reviews" },
 		}];
 
@@ -123,7 +123,7 @@ describe("workflow graph snapshots", () => {
 		const collectFailure = buildWorkflowGraphSnapshot({
 			runId: "run-dynamic-collect-fail",
 			steps,
-			dynamicChildren: { 0: [{ agent: "commentator", flatIndex: 0, itemKey: "a" }] },
+			dynamicChildren: { 0: [{ agent: "reviewer", flatIndex: 0, itemKey: "a" }] },
 			results: [{ exitCode: 0 }],
 			dynamicGroupStatuses: { 0: { status: "failed", error: "Collected output validation failed" } },
 		});