@selesai/code 0.6.2 → 0.7.0

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: {
-						worker: {
-							model: "anthropic/claude-test-worker",
+						builder: {
+							model: "anthropic/claude-test-builder",
 							thinking: false,
 						},
 					},
 				},
 			},
-			agent: "worker",
+			agent: "builder",
 			runId: "run-1",
 			childIndex: 0,
 		});
 
-		assert.equal(config?.model, "anthropic/claude-test-worker");
+		assert.equal(config?.model, "anthropic/claude-test-builder");
 		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: "worker",
+			agent: "builder",
 			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: "worker",
+			agent: "builder",
 			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: "worker", childIndex: 0, current: undefined });
+		const first = acceptChildWatchdogEvent({ event: firstEvent, runId: "run-1", agent: "builder", 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: "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);
+		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);
 
 		const settled = acceptChildWatchdogEvent({
 			event: { ...firstEvent, seq: 2, phase: "idle", ts: 20 },
 			current: first,
 			runId: "run-1",
-			agent: "worker",
+			agent: "builder",
 			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: 500, maxFiles: 10, maxDiagnostics: 10 },
+				config: { enabled: true, timeoutMs: 5000, maxFiles: 10, maxDiagnostics: 10 },
 			});
 
 			assert.equal(diagnostics.status, "failed");

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

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import type { StreamFn } from "@earendil-works/pi-agent-core";
+import { createAssistantMessageEventStream, fauxAssistantMessage, fauxToolCall, type AssistantMessage, type Model } from "@earendil-works/pi-ai";
+import { createWatchdogPermissionArbiter } from "../../src/watchdog/permission-arbiter.ts";
+
+function model(): Model<any> {
+	return { id: "watchdog", name: "watchdog", api: "faux", provider: "test", baseUrl: "https://example.invalid", reasoning: true, input: ["text"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 100_000, maxTokens: 4_096 };
+}
+
+function ctx(current = model()) {
+	return {
+		cwd: "/tmp/watchdog-permission",
+		model: current,
+		signal: undefined,
+		modelRegistry: {
+			getAvailable: () => [current],
+			find: (provider: string, id: string) => provider === current.provider && id === current.id ? current : undefined,
+			hasConfiguredAuth: () => true,
+			getApiKeyAndHeaders: async () => ({ ok: true as const, apiKey: "test-key" }),
+			getRegisteredProviderConfig: () => undefined,
+		},
+	} as never;
+}
+
+function responseStream(message: AssistantMessage) {
+	const stream = createAssistantMessageEventStream();
+	queueMicrotask(() => stream.push({ type: "done", reason: message.stopReason, message }));
+	return stream;
+}
+
+function stream(decision: "approve" | "deny", reason: string): StreamFn {
+	const responses = [
+		fauxAssistantMessage(fauxToolCall("watchdog_permission_decision", { decision, reason }), { stopReason: "toolUse" }),
+		fauxAssistantMessage("done", { stopReason: "stop" }),
+	];
+	return () => responseStream(responses.shift()!);
+}
+
+const childConfig = JSON.stringify({
+	enabled: true,
+	watchdogTailTimeoutMs: 1_000,
+	agentEndTimeoutMs: 1_000,
+	maxWarnings: null,
+	lsp: { enabled: false, timeoutMs: 100, maxFiles: 1, maxDiagnostics: 1 },
+	autoFollowBlockers: false,
+	autoFollowMaxAttempts: null,
+	stalemateRepeats: 2,
+});
+
+describe("watchdog permission arbiter", () => {
+	it("approves and denies exact calls through the watchdog model decision tool", async () => {
+		const approved = await createWatchdogPermissionArbiter({ streamFn: stream("approve", "safe output path") })({ ctx: ctx(), toolName: "write", args: { path: "out.txt" }, rawWatchdogConfig: childConfig });
+		assert.deepEqual(approved, { approved: true, reason: "safe output path", source: "watchdog" });
+
+		const denied = await createWatchdogPermissionArbiter({ streamFn: stream("deny", "path is outside scope") })({ ctx: ctx(), toolName: "write", args: { path: "/etc/hosts" }, rawWatchdogConfig: childConfig });
+		assert.deepEqual(denied, { approved: false, reason: "path is outside scope", source: "watchdog" });
+	});
+
+	it("fails closed when the child watchdog is unavailable and audits redacted decisions", async () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "watchdog-permission-"));
+		try {
+			const auditPath = path.join(dir, "audit.jsonl");
+			const result = await createWatchdogPermissionArbiter()({ ctx: ctx(), toolName: "write", args: { token: "secret-value", path: "out.txt" }, auditPath });
+			assert.equal(result.approved, false);
+			assert.match(result.reason, /disabled/);
+			const records = fs.readFileSync(auditPath, "utf-8").trim().split("\n").map((line) => JSON.parse(line) as Record<string, unknown>);
+			assert.equal(records.length, 2);
+			assert.equal(records[0]?.decisionSource, "watchdog");
+			assert.equal(records[1]?.decision, "unavailable");
+			assert.doesNotMatch(String(records[0]?.preview), /secret-value/);
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+});

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 reviewer", async () => {
+	it("bounds review input before calling the commentator", 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: {
-							worker: { enabled: true, model: "anthropic/claude-test" },
+							builder: { enabled: true, model: "anthropic/claude-test" },
 						},
 					},
 					guidance: { systemPromptPath: "/tmp/user-watchdog.md" },
@@ -105,8 +105,8 @@ describe("watchdog settings", () => {
 					children: {
 						autoFollow: { blockers: false },
 						overrides: {
-							worker: { thinking: "medium" },
-							reviewer: { enabled: false },
+							builder: { thinking: "medium" },
+							commentator: { enabled: false },
 						},
 					},
 				},
@@ -118,7 +118,7 @@ describe("watchdog settings", () => {
 				autoFollow: { maxAttempts: null },
 				children: {
 					overrides: {
-						worker: { enabled: false },
+						builder: { 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.worker, {
+		assert.deepEqual(result.config.children.overrides.builder, {
 			enabled: false,
 			model: "anthropic/claude-test",
 			thinking: "medium",
 		});
-		assert.deepEqual(result.config.children.overrides.reviewer, { enabled: false });
+		assert.deepEqual(result.config.children.overrides.commentator, { enabled: false });
 	});
 
 	it("returns exact validation errors at the watchdog boundary", () => {
@@ -166,7 +166,7 @@ describe("watchdog settings", () => {
 		writeJson(userSettingsPath(), {
 			subagents: {
 				watchdog: {
-					children: { overrides: { worker: { mode: "fast" } } },
+					children: { overrides: { builder: { 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.worker.mode'.`,
+				&& error.message === `Watchdog settings in '${userSettingsPath()}' have unknown field 'subagents.watchdog.children.overrides.builder.mode'.`,
 		);
 	});
 

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

@@ -38,17 +38,53 @@ function job(child: NestedRunSummary): AsyncJobState {
 }
 
 describe("nested widget rendering", () => {
-	it("uses aggregate lines when collapsed and full child rows when expanded", () => {
-		const child = nested("nested-reviewer", "root-run", "running", { currentTool: "read" });
+	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 collapsed = buildWidgetLines([job(child)], theme as any, 120, false).join("\n");
-		assert.match(collapsed, /↳ \[\d{2}:\d{2}:\d{2}\] \+1 nested run \(1 running\)/);
-		assert.doesNotMatch(collapsed, /nested-reviewer · running/);
+		assert.match(collapsed, /↳ └─ \[\d{2}:\d{2}:\d{2}\] . nested-commentator · 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-reviewer · running · read/);
+		assert.match(expanded, /↳ \[\d{2}:\d{2}:\d{2}\] . nested-commentator · 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}\] \+1 nested run/);
+		assert.match(epoch, /↳ └─ \[\d{2}:\d{2}:\d{2}\] . epoch · running/);
+	});
+
+	it("shows four direct leaves and one overflow row while retaining completed siblings", () => {
+		const root = nested("parallel-owner", "root-run", "running", {
+			mode: "parallel",
+			steps: ["one", "two", "three", "four", "five"].map((agent, index) => ({
+				agent,
+				status: index === 0 ? "complete" as const : "running" as const,
+				model: index === 0 ? "gpt-5.6-luna:medium" : "gpt-5.6-luna",
+				thinking: "medium",
+			})),
+		});
+		const collapsed = buildWidgetLines([job(root)], theme as any, 160, false).join("\n");
+		assert.match(collapsed, /parallel-owner · running/);
+		for (const [agent, state] of [["one", "complete"], ["two", "running"], ["three", "running"], ["four", "running"]] as const) {
+			const line = collapsed.split("\n").find((candidate) => candidate.includes(` ${agent} ·`));
+			assert.ok(line);
+			assert.match(line!, /\[\d{2}:\d{2}:\d{2}\] /);
+			assert.match(line!, /gpt-5.6-luna/);
+			assert.match(line!, /thinking medium/);
+			assert.match(line!, new RegExp(state));
+		}
+		assert.doesNotMatch(collapsed, /five · running/);
+
+		const chain = nested("chain-owner", "root-run", "running", {
+			mode: "chain",
+			steps: ["first", "second"].map((agent) => ({ agent, status: "running" as const })),
+		});
+		const chainCollapsed = buildWidgetLines([job(chain)], theme as any, 160, false).join("\n");
+		for (const agent of ["first", "second"]) {
+			const line = chainCollapsed.split("\n").find((candidate) => candidate.includes(` ${agent} ·`));
+			assert.ok(line);
+			assert.match(line!, /\[\d{2}:\d{2}:\d{2}\] /);
+		}
+		assert.match(collapsed, /\+1 more nested leaves/);
+		assert.equal((collapsed.match(/thinking medium/g) ?? []).length, 4);
 	});
 
 	it("collapses descendants beyond the nested depth budget", () => {
@@ -101,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-reviewer", "root-run", "running", { currentTool: "read", currentToolStartedAt: 0 }));
+		const state = job(nested("nested-commentator", "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);
@@ -109,8 +145,8 @@ describe("nested widget rendering", () => {
 	});
 
 	it("rerenders when only nested state changes", () => {
-		const first = job(nested("nested-reviewer", "root-run", "running"));
-		const second = job(nested("nested-reviewer", "root-run", "complete"));
+		const first = job(nested("nested-commentator", "root-run", "running"));
+		const second = job(nested("nested-commentator", "root-run", "complete"));
 		assert.notEqual(widgetRenderKey(first), widgetRenderKey(second));
 	});
 });

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

@@ -0,0 +1,197 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+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";
+
+const theme = {
+	fg(_name: string, text: string): string { return text; },
+	bold(text: string): string { return text; },
+};
+
+function git(cwd: string, args: string[]): string {
+	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8" });
+	if (result.status !== 0) throw new Error(result.stderr.trim() || result.stdout.trim() || `git ${args.join(" ")} failed`);
+	return result.stdout.trim();
+}
+
+function createRepo(prefix: string): string {
+	const repo = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+	git(repo, ["init"]);
+	git(repo, ["config", "user.email", "tests@example.com"]);
+	git(repo, ["config", "user.name", "Workflow Progress Tests"]);
+	fs.writeFileSync(path.join(repo, "tracked.txt"), "initial\n", "utf-8");
+	git(repo, ["add", "-A"]);
+	git(repo, ["commit", "-m", "initial"]);
+	return repo;
+}
+
+function componentText(component: unknown): string {
+	if (typeof component !== "object" || component === null) return "";
+	if ("text" in component && typeof component.text === "string") return component.text;
+	if ("children" in component && Array.isArray(component.children)) return component.children.map(componentText).filter(Boolean).join("\n");
+	return "";
+}
+
+function createState(): SubagentState {
+	return {
+		baseCwd: "",
+		currentSessionId: null,
+		asyncJobs: new Map(),
+		foregroundRuns: new Map(),
+		foregroundControls: new Map(),
+		lastForegroundControlId: null,
+		pendingForegroundControlNotices: new Map(),
+		cleanupTimers: new Map(),
+		lastUiContext: null,
+		poller: null,
+		completionSeen: new Map(),
+		watcher: null,
+		watcherRestartTimer: null,
+		resultFileCoalescer: { schedule: () => false, clear: () => {} },
+	};
+}
+
+function createExecutor() {
+	return createSubagentExecutor({
+		pi: { events: { emit() {}, on() { return () => {}; } }, getSessionName() { return "parent"; } } as any,
+		state: createState(),
+		config: { maxSubagentDepth: 2, control: {}, intercomBridge: {} } as any,
+		asyncByDefault: false,
+		tempArtifactsDir: os.tmpdir(),
+		getSubagentSessionRoot: () => os.tmpdir(),
+		expandTilde: (value) => value,
+		discoverAgents: () => ({ agents: [] as any[] }),
+	});
+}
+
+function ctx(root: string) {
+	return {
+		cwd: root,
+		hasUI: false,
+		sessionManager: { getSessionId() { return "session"; }, getSessionFile() { return null; } },
+		modelRegistry: { getAvailable() { return []; } },
+		model: { provider: "test", id: "test-model" },
+	} as any;
+}
+
+describe("workflow chat progress policy", () => {
+	it("treats managed worktrees as same repo and sibling repos as other repo", () => {
+		const repo = createRepo("pi-workflow-progress-repo-");
+		const other = createRepo("pi-workflow-progress-other-");
+		const worktree = path.join(os.tmpdir(), `pi-workflow-progress-wt-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+		try {
+			fs.mkdirSync(path.join(repo, "packages"));
+			git(repo, ["worktree", "add", "-b", "chat-progress-test", worktree, "HEAD"]);
+			assert.equal(isSameGitRepository(repo, path.join(repo, "packages")), true);
+			assert.equal(isSameGitRepository(repo, worktree), true);
+			assert.equal(isSameGitRepository(repo, other), false);
+
+			assert.equal(resolveWorkflowChatProgress({ requested: "auto", parentCwd: repo, workflowCwd: worktree, background: false }).projection?.mode, "live-card");
+			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);
+		} finally {
+			try { git(repo, ["worktree", "remove", "--force", worktree]); } catch {}
+			fs.rmSync(repo, { recursive: true, force: true });
+			fs.rmSync(other, { recursive: true, force: true });
+			fs.rmSync(worktree, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("workflow chat progress rendering", () => {
+	it("emits live-card updates for same-repo watched workflowScript runs", async () => {
+		const repo = createRepo("pi-workflow-progress-executor-");
+		try {
+			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 },
+				new AbortController().signal,
+				(update) => updates.push(update),
+				ctx(repo),
+			);
+			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]?.phase, "Validation");
+			assert.equal(liveUpdate.details?.workflow?.trace[0]?.label, "Find renderer seam");
+		} finally {
+			fs.rmSync(repo, { recursive: true, force: true });
+		}
+	});
+
+	it("renders stable rows keyed by workflow trace entries", () => {
+		const text = componentText(renderSubagentResult({
+			content: [{ type: "text", text: "Workflow running." }],
+			details: {
+				mode: "workflow",
+				runId: "wf_8f3a123456",
+				results: [],
+				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: "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" },
+					],
+					emits: [],
+					console: [],
+				},
+			},
+		}, { expanded: false }, theme as any));
+
+		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, /running\s+tests focused integration suite/);
+		assert.match(text, /failed\s+review fresh-context UX review .* needs fixes/);
+	});
+
+	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;
+
+		assert.equal(shouldSuppressRoutineResultIntercom({ suppressRoutineResultIntercom: true, results: [completed] }), true);
+		assert.equal(shouldSuppressRoutineResultIntercom({ suppressRoutineResultIntercom: true, results: [failed] }), false);
+		assert.equal(shouldSuppressRoutineResultIntercom({ suppressRoutineResultIntercom: true, results: [rejected] }), false);
+		assert.equal(shouldSuppressRoutineResultIntercom({ suppressRoutineResultIntercom: false, results: [completed] }), false);
+	});
+
+	it("marks acceptance-rejected foreground intercom results as failed", () => {
+		const rejected = { agent: "explorer", exitCode: 0, acceptance: { status: "rejected" }, outputState: "present" } as SingleResult;
+
+		assert.equal(foregroundResultIntercomStatus(rejected), "failed");
+	});
+
+	it("shows final workflow output after live-card progress completes", () => {
+		const text = componentText(renderSubagentResult({
+			content: [{ type: "text", text: "Workflow completed.\n\nReturn:\nfinal answer" }],
+			details: {
+				mode: "workflow",
+				runId: "wf_done",
+				results: [],
+				chatProgress: { mode: "live-card", repoRelation: "same", repoLabel: "pi-subagents" },
+				workflow: {
+					value: "final answer",
+					trace: [{ operation: "run", key: "explorer", state: "completed", runId: "run-explorer" }],
+					emits: [],
+					console: [],
+				},
+			},
+		}, { expanded: true }, theme as any));
+
+		assert.match(text, /Workflow completed/);
+		assert.match(text, /final answer/);
+		assert.doesNotMatch(text, /workflow wf_done/);
+	});
+});

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: "scout", task: "Scan", phase: "Research", label: "Find context", as: "context" },
+				{ agent: "explorer", 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 worker and reviewer chain without losing indexes", () => {
+	it("maps a long alternating builder and commentator chain without losing indexes", () => {
 		const steps = Array.from({ length: 40 }, (_, index) => ({
-			agent: index % 2 === 0 ? "worker" : "reviewer",
+			agent: index % 2 === 0 ? "builder" : "commentator",
 			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, "reviewer");
+		assert.equal(graph.nodes[37]?.agent, "commentator");
 		assert.equal(graph.nodes[37]?.flatIndex, 37);
 		assert.equal(graph.nodes[39]?.id, "step-39");
-		assert.equal(graph.nodes[39]?.agent, "reviewer");
+		assert.equal(graph.nodes[39]?.agent, "commentator");
 		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: "reviewer", label: "Correctness", phase: "Review", as: "correctness" },
+						{ agent: "commentator", 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: "reviewer", task: "Review {item}" },
+			parallel: { agent: "commentator", 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: "reviewer", flatIndex: 0, itemKey: "a" }] },
+			dynamicChildren: { 0: [{ agent: "commentator", flatIndex: 0, itemKey: "a" }] },
 			results: [{ exitCode: 0 }],
 			dynamicGroupStatuses: { 0: { status: "failed", error: "Collected output validation failed" } },
 		});