@selesai/code 0.8.2 → 0.8.4

package/dist/extensions/pi-subagents/test/unit/herdr-inspector-bootstrap.test.ts

@@ -0,0 +1,69 @@
+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 { fileURLToPath } from "node:url";
+import { handleHerdrInspectorAction } from "../../src/inspectors/herdr/actions.ts";
+import type { HerdrClient } from "../../src/inspectors/herdr/client.ts";
+import type { AsyncStatus } from "../../src/shared/types.ts";
+
+function writeCompletedRun(root: string): { asyncDir: string; status: AsyncStatus } {
+	const asyncDir = path.join(root, "run-123");
+	fs.mkdirSync(asyncDir, { recursive: true });
+	const status: AsyncStatus = {
+		runId: "run-123",
+		mode: "single",
+		state: "completed",
+		startedAt: Date.now() - 1_000,
+		cwd: root,
+		steps: [{ agent: "worker", status: "completed", recentOutput: ["done"] }],
+	};
+	fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
+	return { asyncDir, status };
+}
+
+describe("Herdr inspector bootstrap", () => {
+	it("uses ordinary Node for the inspector pane command", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-herdr-bootstrap-command-"));
+		try {
+			writeCompletedRun(root);
+			const calls: string[][] = [];
+			const client: HerdrClient = {
+				run: async <T>(args: string[]) => {
+					calls.push(args);
+					if (args[0] === "--version") return { ok: true, data: "herdr 0.7.5" as T };
+					if (args[0] === "pane" && args[1] === "split") return { ok: true, data: { pane: { pane_id: "w1:p9" } } as T };
+					return { ok: true, data: {} as T };
+				},
+			};
+			const opened = await handleHerdrInspectorAction("inspector.open", { id: "run-123" }, {
+				cwd: root,
+				asyncDirRoot: root,
+				resultsDir: path.join(root, "results"),
+				client,
+			});
+			assert.equal(opened.isError, undefined);
+			const command = calls.find((args) => args[0] === "pane" && args[1] === "run")?.[3] ?? "";
+			assert.equal(command.startsWith("& "), process.platform === "win32");
+			assert.doesNotMatch(command, /--experimental-strip-types/);
+			assert.match(command, /inspector-runner\.mjs/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("starts the packaged bootstrap with ordinary Node", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-herdr-bootstrap-run-"));
+		try {
+			const { asyncDir, status } = writeCompletedRun(root);
+			const bootstrap = fileURLToPath(new URL("../../inspector-runner.mjs", import.meta.url));
+			const launched = spawnSync(process.execPath, [bootstrap, "--async-dir", asyncDir, "--run-id", status.runId], { encoding: "utf-8" });
+			assert.equal(launched.status, 0, launched.stderr);
+			assert.match(launched.stdout, /pi-subagents inspector for run-123/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/herdr-inspector.test.ts

@@ -8,7 +8,7 @@ import { describe, it } from "node:test";
 import { handleHerdrInspectorAction, readHerdrInspectorBinding } from "../../src/inspectors/herdr/actions.ts";
 import { createHerdrClient, detectHerdr, parseHerdrVersion, supportsRawPanes, type HerdrClient } from "../../src/inspectors/herdr/client.ts";
 import { formatInspectorDashboard, submitInspectorControl } from "../../src/inspectors/herdr/inspector-runner.ts";
-import { handleHerdrProjectPaneAction, readHerdrProjectPaneBinding } from "../../src/inspectors/herdr/project-panes.ts";
+import { createProjectPaneManager, handleHerdrProjectPaneAction, readHerdrProjectPaneBinding } from "../../src/inspectors/herdr/project-panes.ts";
 import { consumeSteerRequests, consumeStopRequest } from "../../src/runs/background/control-channel.ts";
 import { SELESAI_SUBAGENT_PI_BINARY_ENV } from "../../src/runs/shared/pi-spawn.ts";
 import type { AsyncStatus } from "../../src/shared/types.ts";
@@ -30,7 +30,7 @@ function writeRun(root: string, id = "run-123"): { asyncDir: string; status: Asy
 		state: "running",
 		startedAt: Date.now() - 1_000,
 		cwd: root,
-		steps: [{ agent: "builder", status: "running", recentOutput: ["working"] }],
+		steps: [{ agent: "worker", status: "running", recentOutput: ["working"] }],
 	};
 	fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
 	return { asyncDir, status };
@@ -191,6 +191,10 @@ describe("Herdr inspector", () => {
 					calls.push(args);
 					if (args[0] === "--version") return { ok: true, data: "herdr 0.7.5" as T };
 					if (args[0] === "pane" && args[1] === "split") return { ok: true, data: { pane: { pane_id: "w1:p10" } } as T };
+					if (args[0] === "pane" && args[1] === "get") return { ok: true, data: { pane: {
+						pane_id: "w1:p10", agent: "pi", agent_status: "idle", cwd: projectRoot,
+						foreground_cwd: projectRoot, focused: false, terminal_title_stripped: "Pi · project",
+					} } as T };
 					return { ok: true, data: {} as T };
 				},
 			};
@@ -209,6 +213,7 @@ describe("Herdr inspector", () => {
 			const splitCall = calls.find((args) => args[0] === "pane" && args[1] === "split");
 			assert.deepEqual(splitCall?.slice(0, 7), ["pane", "split", "--current", "--direction", "right", "--cwd", projectRoot]);
 			const runCall = calls.find((args) => args[0] === "pane" && args[1] === "run" && args[2] === "w1:p10");
+			assert.equal(runCall?.[3]?.startsWith("& "), process.platform === "win32");
 			assert.match(runCall?.[3] ?? "", /pi-bin/);
 			assert.match(runCall?.[3] ?? "", /Own this project mission\./);
 
@@ -228,6 +233,78 @@ describe("Herdr inspector", () => {
 		}
 	});
 
+	it("fails closed when an idle-only project pane close sees active work", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-herdr-project-pane-busy-"));
+		try {
+			const projectRoot = fs.realpathSync(root);
+			const calls: string[][] = [];
+			let opened = false;
+			const client: HerdrClient = {
+				run: async <T>(args: string[]) => {
+					calls.push(args);
+					if (args[0] === "--version") return { ok: true, data: "herdr 0.8.0" as T };
+					if (args[0] === "pane" && args[1] === "split") return { ok: true, data: { pane: { pane_id: "w1:p11" } } as T };
+					if (args[0] === "pane" && args[1] === "run") { opened = true; return { ok: true, data: {} as T }; }
+					if (args[0] === "pane" && args[1] === "get" && opened) return { ok: true, data: { pane: {
+						pane_id: "w1:p11", agent: "pi", agent_status: "working", cwd: projectRoot,
+					} } as T };
+					return { ok: true, data: {} as T };
+				},
+			};
+			const manager = createProjectPaneManager({ client });
+			const open = await manager.open({ cwd: root, focus: false });
+			assert.equal(open.ok, true);
+			const closed = await manager.close({ cwd: root, requireIdle: true });
+			assert.equal(closed.ok, false);
+			if (!closed.ok) assert.equal(closed.error.code, "PANE_NOT_IDLE");
+			assert.equal(calls.some((args) => args.join(" ") === "pane close w1:p11"), false);
+			assert.equal(readHerdrProjectPaneBinding(root)?.paneId, "w1:p11");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("preserves legacy model-facing recovery for transient and opaque pane inspection results", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-herdr-project-pane-legacy-"));
+		try {
+			let splitCount = 0;
+			let getMode: "valid" | "timeout" | "opaque" = "valid";
+			const client: HerdrClient = {
+				run: async <T>(args: string[]) => {
+					if (args[0] === "--version") return { ok: true, data: "herdr 0.8.0" as T };
+					if (args[0] === "pane" && args[1] === "split") {
+						splitCount++;
+						return { ok: true, data: { pane: { pane_id: `w1:p3${splitCount}` } } as T };
+					}
+					if (args[0] === "pane" && args[1] === "get") {
+						if (getMode === "timeout") return { ok: false, error: { code: "TIMEOUT", message: "temporary" } };
+						if (getMode === "opaque") return { ok: true, data: {} as T };
+						return { ok: true, data: { pane: { pane_id: `w1:p3${splitCount}`, agent_status: "idle", cwd: root } } as T };
+					}
+					return { ok: true, data: {} as T };
+				},
+			};
+			const first = await handleHerdrProjectPaneAction("project.open", { cwd: root }, { cwd: root, client });
+			assert.equal(first.isError, undefined, text(first));
+			getMode = "timeout";
+			const recovered = await handleHerdrProjectPaneAction("project.open", { cwd: root }, { cwd: root, client });
+			assert.equal(recovered.isError, undefined, text(recovered));
+			assert.equal(splitCount, 2);
+			assert.equal(readHerdrProjectPaneBinding(root)?.paneId, "w1:p32");
+			getMode = "opaque";
+			const status = await handleHerdrProjectPaneAction("project.status", { cwd: root }, { cwd: root, client });
+			assert.equal(status.isError, undefined, text(status));
+			assert.match(text(status), /w1:p32 is open/);
+			const legacyBinding = readHerdrProjectPaneBinding(root)!;
+			fs.writeFileSync(path.join(root, ".pi-subagents", "project-panes", "herdr.json"), JSON.stringify({ ...legacyBinding, startupMessage: 42 }));
+			const closed = await handleHerdrProjectPaneAction("project.close", { cwd: root }, { cwd: root, client });
+			assert.equal(closed.isError, undefined, text(closed));
+			assert.equal(readHerdrProjectPaneBinding(root), undefined);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("rejects project pane targets that are not directories", async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-herdr-project-pane-missing-"));
 		try {

package/dist/extensions/pi-subagents/test/unit/herdr-status-bridge.test.ts

@@ -5,6 +5,8 @@ import {
 	registerHerdrStatusBridge,
 	type HerdrStatusBridgeEvents,
 } from "../../src/integrations/herdr-status.ts";
+import { projectActiveHerdrRuns } from "../../src/extension/index.ts";
+import type { SubagentState } from "../../src/shared/types.ts";
 import {
 	SUBAGENT_ASYNC_COMPLETE_EVENT,
 	SUBAGENT_ASYNC_STARTED_EVENT,
@@ -52,7 +54,58 @@ class FakeEvents implements HerdrStatusBridgeEvents {
 	}
 }
 
+function stateForTest(): SubagentState {
+	return {
+		baseCwd: process.cwd(),
+		currentSessionId: "session-current",
+		asyncJobs: new Map(),
+		fleetJobs: new Map(),
+		foregroundRuns: new Map(),
+		foregroundControls: new Map(),
+		lastForegroundControlId: null,
+		cleanupTimers: new Map(),
+		lastUiContext: null,
+		poller: null,
+		completionSeen: new Map(),
+		watcher: null,
+		watcherRestartTimer: null,
+		resultFileCoalescer: { schedule: () => false, clear: () => {} },
+	};
+}
+
 describe("Herdr status bridge", () => {
+	it("projects foreground workflow children onto the parent run without a shell duplicate", () => {
+		const state = stateForTest();
+		state.asyncJobs.set("workflow-1", {
+			asyncId: "workflow-1",
+			asyncDir: "/tmp/workflow-1",
+			status: "running",
+			mode: "workflow",
+			agents: ["workflow"],
+		});
+		state.foregroundControls.set("child-1", {
+			runId: "child-1",
+			parentWorkflowRunId: "workflow-1",
+			workflowKey: "review",
+			mode: "single",
+			startedAt: 10,
+			updatedAt: 20,
+			activeChildren: new Map([[0, {
+				index: 0,
+				agent: "reviewer",
+				startedAt: 10,
+				updatedAt: 20,
+				currentActivityState: "needs_attention",
+			}]]),
+		});
+
+		assert.deepEqual(projectActiveHerdrRuns(state), [{
+			id: "workflow-1",
+			agents: ["reviewer"],
+			needsAttention: true,
+		}]);
+	});
+
 	it("reports an async run as visible and semantically busy", async () => {
 		const events = new FakeEvents();
 		const commands: string[][] = [];
@@ -73,13 +126,13 @@ describe("Herdr status bridge", () => {
 		bridge.sessionStarted({ hasUI: true, runs: [] });
 		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
 			id: "run-1",
-			agent: "builder",
+			agent: "worker",
 		});
 		await bridge.flush();
 
 		assert.deepEqual(busyEvents, [{
 			active: true,
-			label: "⏳ 1 subagent (builder)",
+			label: "⏳ 1 subagent (worker)",
 		}]);
 		assert.equal(commands.length, 1);
 		assert.deepEqual(commands[0]?.slice(0, 8), [
@@ -94,10 +147,10 @@ describe("Herdr status bridge", () => {
 		]);
 		assert.ok(commands[0]?.includes("herdr:pi"));
 		assert.ok(commands[0]?.includes("--state-label"));
-		assert.ok(commands[0]?.includes("working=⏳ 1 subagent (builder)"));
-		assert.ok(commands[0]?.includes("idle=⏳ 1 subagent (builder)"));
-		assert.ok(commands[0]?.includes("done=⏳ 1 subagent (builder)"));
-		assert.ok(commands[0]?.includes("summary=⏳ 1 subagent (builder)"));
+		assert.ok(commands[0]?.includes("working=⏳ 1 subagent (worker)"));
+		assert.ok(commands[0]?.includes("idle=⏳ 1 subagent (worker)"));
+		assert.ok(commands[0]?.includes("done=⏳ 1 subagent (worker)"));
+		assert.ok(commands[0]?.includes("summary=⏳ 1 subagent (worker)"));
 		assert.ok(commands[0]?.includes("--ttl-ms"));
 		assert.ok(commands[0]?.includes("--seq"));
 
@@ -117,9 +170,9 @@ describe("Herdr status bridge", () => {
 		});
 		bridge.sessionStarted({ hasUI: true, runs: [] });
 
-		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "builder" });
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "worker" });
 		await bridge.flush();
-		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-2", agent: "commentator" });
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-2", agent: "reviewer" });
 		await bridge.flush();
 		events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, { runId: "run-1" });
 		await bridge.flush();
@@ -127,16 +180,16 @@ describe("Herdr status bridge", () => {
 		await bridge.flush();
 
 		assert.deepEqual(busyEvents, [
-			{ active: true, label: "⏳ 1 subagent (builder)" },
+			{ active: true, label: "⏳ 1 subagent (worker)" },
 			{ active: false },
-			{ active: true, label: "⏳ 2 subagents (builder, commentator)" },
+			{ active: true, label: "⏳ 2 subagents (worker, reviewer)" },
 			{ active: false },
-			{ active: true, label: "⏳ 1 subagent (commentator)" },
+			{ active: true, label: "⏳ 1 subagent (reviewer)" },
 			{ active: false },
 		]);
 		assert.equal(commands.length, 4);
-		assert.ok(commands[1]?.includes("summary=⏳ 2 subagents (builder, commentator)"));
-		assert.ok(commands[2]?.includes("summary=⏳ 1 subagent (commentator)"));
+		assert.ok(commands[1]?.includes("summary=⏳ 2 subagents (worker, reviewer)"));
+		assert.ok(commands[2]?.includes("summary=⏳ 1 subagent (reviewer)"));
 		assert.ok(commands[3]?.includes("--clear-state-labels"));
 		assert.ok(commands[3]?.includes("--clear-token"));
 
@@ -155,10 +208,10 @@ describe("Herdr status bridge", () => {
 		});
 		bridge.sessionStarted({ hasUI: true, runs: [] });
 
-		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "builder" });
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "worker" });
 		events.emit(SUBAGENT_CONTROL_EVENT, {
 			source: "async",
-			noticeText: "builder needs attention",
+			noticeText: "worker needs attention",
 			event: {
 				type: "needs_attention",
 				runId: "run-1",
@@ -175,7 +228,7 @@ describe("Herdr status bridge", () => {
 		bridge.agentStarted();
 
 		assert.deepEqual(blockedEvents, [
-			{ active: true, label: "builder needs attention" },
+			{ active: true, label: "worker needs attention" },
 			{ active: false },
 		]);
 
@@ -186,7 +239,7 @@ describe("Herdr status bridge", () => {
 		const events = new FakeEvents();
 		const blockedEvents: unknown[] = [];
 		const intervals = new FakeIntervals();
-		let authoritativeRuns = [{ id: "run-1", agent: "builder", needsAttention: false }];
+		let authoritativeRuns = [{ id: "run-1", agent: "worker", needsAttention: false }];
 		events.on("herdr:blocked", (payload) => blockedEvents.push(payload));
 		const bridge = registerHerdrStatusBridge({
 			events,
@@ -199,16 +252,16 @@ describe("Herdr status bridge", () => {
 		bridge.sessionStarted({ hasUI: true, runs: authoritativeRuns });
 		events.emit(SUBAGENT_CONTROL_EVENT, {
 			source: "async",
-			noticeText: "builder needs attention",
+			noticeText: "worker needs attention",
 			event: { type: "needs_attention", runId: "run-1" },
 		});
-		authoritativeRuns = [{ id: "run-1", agent: "builder", needsAttention: true }];
+		authoritativeRuns = [{ id: "run-1", agent: "worker", needsAttention: true }];
 		bridge.agentStarted();
 
 		intervals.fireAll();
 		await bridge.flush();
 		assert.deepEqual(blockedEvents, [
-			{ active: true, label: "builder needs attention" },
+			{ active: true, label: "worker needs attention" },
 			{ active: false },
 		]);
 
@@ -216,12 +269,12 @@ describe("Herdr status bridge", () => {
 		// raise the overlay again even if the tracker flag never dropped.
 		events.emit(SUBAGENT_CONTROL_EVENT, {
 			source: "async",
-			noticeText: "builder still needs attention",
+			noticeText: "worker still needs attention",
 			event: { type: "needs_attention", runId: "run-1" },
 		});
 		assert.deepEqual(blockedEvents.at(-1), {
 			active: true,
-			label: "builder still needs attention",
+			label: "worker still needs attention",
 		});
 
 		bridge.dispose();
@@ -239,7 +292,7 @@ describe("Herdr status bridge", () => {
 		});
 		bridge.sessionStarted({ hasUI: true, runs: [] });
 
-		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "builder" });
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "worker" });
 		events.emit(SUBAGENT_CONTROL_EVENT, {
 			source: "async",
 			event: { type: "needs_attention", runId: "run-1", message: "stuck" },
@@ -265,28 +318,28 @@ describe("Herdr status bridge", () => {
 			refreshMs: 0,
 		});
 		bridge.sessionStarted({ hasUI: true, runs: [] });
-		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "builder" });
-		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-2", agent: "commentator" });
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "worker" });
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-2", agent: "reviewer" });
 
 		events.emit(SUBAGENT_CONTROL_EVENT, {
 			source: "async",
-			noticeText: "builder needs attention",
+			noticeText: "worker needs attention",
 			event: { type: "needs_attention", runId: "run-1" },
 		});
 		events.emit(SUBAGENT_CONTROL_EVENT, {
 			source: "async",
-			noticeText: "commentator needs attention",
+			noticeText: "reviewer needs attention",
 			event: { type: "needs_attention", runId: "run-2" },
 		});
 		events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, { runId: "run-2" });
 		events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, { runId: "run-1" });
 
 		assert.deepEqual(blockedEvents, [
-			{ active: true, label: "builder needs attention" },
+			{ active: true, label: "worker needs attention" },
 			{ active: false },
-			{ active: true, label: "commentator needs attention" },
+			{ active: true, label: "reviewer needs attention" },
 			{ active: false },
-			{ active: true, label: "builder needs attention" },
+			{ active: true, label: "worker needs attention" },
 			{ active: false },
 		]);
 
@@ -311,22 +364,22 @@ describe("Herdr status bridge", () => {
 			hasUI: true,
 			runs: [{
 				id: "run-restored",
-				agents: ["builder", "commentator"],
+				agents: ["worker", "reviewer"],
 				needsAttention: true,
-				attentionLabel: "commentator needs attention",
+				attentionLabel: "reviewer needs attention",
 			}],
 		});
 		await bridge.flush();
 
 		assert.deepEqual(busyEvents, [{
 			active: true,
-			label: "⏳ 1 subagent (builder, commentator)",
+			label: "⏳ 1 subagent (worker, reviewer)",
 		}]);
 		assert.deepEqual(blockedEvents, [{
 			active: true,
-			label: "commentator needs attention",
+			label: "reviewer needs attention",
 		}]);
-		assert.ok(commands[0]?.includes("summary=⏳ 1 subagent (builder, commentator)"));
+		assert.ok(commands[0]?.includes("summary=⏳ 1 subagent (worker, reviewer)"));
 
 		bridge.dispose();
 		await bridge.flush();
@@ -350,7 +403,7 @@ describe("Herdr status bridge", () => {
 		bridge.sessionStarted({ hasUI: true, runs: [] });
 
 		assert.equal(intervals.pendingCount(), 0);
-		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "builder" });
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "worker" });
 		assert.equal(intervals.pendingCount(), 1);
 		await bridge.flush();
 		intervals.fireAll();
@@ -370,7 +423,7 @@ describe("Herdr status bridge", () => {
 		const commands: string[][] = [];
 		const busyEvents: unknown[] = [];
 		const intervals = new FakeIntervals();
-		let authoritativeRuns = [{ id: "run-1", agent: "builder" }];
+		let authoritativeRuns = [{ id: "run-1", agent: "worker" }];
 		events.on("herdr:busy", (payload) => busyEvents.push(payload));
 		const bridge = registerHerdrStatusBridge({
 			events,
@@ -391,7 +444,7 @@ describe("Herdr status bridge", () => {
 		await bridge.flush();
 
 		assert.deepEqual(busyEvents, [
-			{ active: true, label: "⏳ 1 subagent (builder)" },
+			{ active: true, label: "⏳ 1 subagent (worker)" },
 			{ active: false },
 		]);
 		assert.equal(intervals.pendingCount(), 0);
@@ -418,20 +471,20 @@ describe("Herdr status bridge", () => {
 		});
 		bridge.sessionStarted({ hasUI: true, runs: [] });
 
-		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "builder" });
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "worker" });
 		await Promise.resolve();
 		assert.equal(commands.length, 1);
 
 		// These snapshots all arrive while the first CLI call is blocked. Only
 		// the final clear matters once that call returns.
-		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-2", agent: "commentator" });
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-2", agent: "reviewer" });
 		events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, { runId: "run-1" });
 		events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, { runId: "run-2" });
 		releaseFirst?.();
 		await bridge.flush();
 
 		assert.equal(commands.length, 2);
-		assert.ok(commands[0]?.includes("summary=⏳ 1 subagent (builder)"));
+		assert.ok(commands[0]?.includes("summary=⏳ 1 subagent (worker)"));
 		assert.ok(commands[1]?.includes("--clear-state-labels"));
 
 		bridge.dispose();
@@ -450,25 +503,25 @@ describe("Herdr status bridge", () => {
 		});
 
 		// Before any session_start, the pane owner is unknown.
-		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-early", agent: "builder" });
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-early", agent: "worker" });
 		await bridge.flush();
 		assert.deepEqual(commands, []);
 		assert.deepEqual(busyEvents, []);
 
 		// A headless parent (print/json mode, or a test harness) must never publish.
-		bridge.sessionStarted({ hasUI: false, runs: [{ id: "run-headless", agent: "builder" }] });
-		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "builder" });
+		bridge.sessionStarted({ hasUI: false, runs: [{ id: "run-headless", agent: "worker" }] });
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "worker" });
 		await bridge.flush();
 		assert.deepEqual(commands, []);
 		assert.deepEqual(busyEvents, []);
 
 		// Only the root interactive session owns the pane.
 		bridge.sessionStarted({ hasUI: true, runs: [] });
-		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-2", agent: "commentator" });
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-2", agent: "reviewer" });
 		await bridge.flush();
 		assert.equal(commands.length, 1);
-		assert.ok(commands[0]?.includes("summary=⏳ 1 subagent (commentator)"));
-		assert.deepEqual(busyEvents, [{ active: true, label: "⏳ 1 subagent (commentator)" }]);
+		assert.ok(commands[0]?.includes("summary=⏳ 1 subagent (reviewer)"));
+		assert.deepEqual(busyEvents, [{ active: true, label: "⏳ 1 subagent (reviewer)" }]);
 
 		bridge.dispose();
 	});
@@ -483,8 +536,8 @@ describe("Herdr status bridge", () => {
 			refreshMs: 0,
 		});
 
-		bridge.sessionStarted({ hasUI: true, runs: [{ id: "run-2", agent: "commentator" }] });
-		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "builder" });
+		bridge.sessionStarted({ hasUI: true, runs: [{ id: "run-2", agent: "reviewer" }] });
+		events.emit(SUBAGENT_ASYNC_STARTED_EVENT, { id: "run-1", agent: "worker" });
 		bridge.agentStarted();
 		bridge.dispose();
 		await bridge.flush();