@selesai/code 0.8.2 → 0.8.4

package/dist/extensions/pi-subagents/test/unit/delegation-api.test.ts

@@ -48,7 +48,7 @@ const request: SubagentDelegationRequest = {
 	requestId: "attempt-1",
 	ownerRunId: "owner-1",
 	nodeId: "node-1",
-	agent: "commentator",
+	agent: "reviewer",
 	task: "Review evidence",
 	context: "fresh",
 	cwd: "/repo",
@@ -137,13 +137,13 @@ describe("public subagent delegation contract", () => {
 			},
 			executeStructured: async (_id, params, _signal, _ctx, onUpdate) => {
 				observedParams = params as unknown as Record<string, unknown>;
-				onUpdate({ details: { mode: "single", runId: "run-1", results: [{ agent: "commentator", model: "openai/gpt-5", thinking: "high" }], progress: [{ currentTool: "read" }] } });
+				onUpdate({ details: { mode: "single", runId: "run-1", results: [{ agent: "reviewer", model: "openai/gpt-5", thinking: "high" }], progress: [{ currentTool: "read" }] } });
 				return {
 					details: {
 						mode: "single",
 						runId: "run-1",
 						results: [{
-							agent: "commentator",
+							agent: "reviewer",
 							exitCode: 0,
 							model: "openai/gpt-5",
 							thinking: "high",
@@ -169,7 +169,7 @@ describe("public subagent delegation contract", () => {
 			nodeId: "node-1",
 			status: "completed",
 			runId: "run-1",
-			agent: "commentator",
+			agent: "reviewer",
 			model: "openai/gpt-5",
 			thinking: "high",
 			exitCode: 0,
@@ -179,7 +179,7 @@ describe("public subagent delegation contract", () => {
 		} satisfies SubagentDelegationResponse);
 		assert.equal(ordinaryCalls, 0);
 		assert.deepEqual(observedParams, {
-			agent: "commentator",
+			agent: "reviewer",
 			task: "Review evidence",
 			context: "fresh",
 			cwd: "/repo",
@@ -217,7 +217,7 @@ describe("public subagent delegation contract", () => {
 					details: {
 						mode: "single",
 						results: [{
-							agent: "commentator",
+							agent: "reviewer",
 							exitCode: 0,
 							...(structuredOutput === undefined ? {} : { structuredOutput }),
 							usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 1 },
@@ -345,7 +345,7 @@ describe("public subagent delegation contract", () => {
 					details: {
 						mode: "single",
 						results: [{
-							agent: "commentator",
+							agent: "reviewer",
 							exitCode: 0,
 							finalOutput: requestId,
 							usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 1 },
@@ -399,7 +399,7 @@ describe("public subagent delegation contract", () => {
 					details: {
 						mode: "single",
 						results: [{
-							agent: "commentator",
+							agent: "reviewer",
 							exitCode: 0,
 							finalOutput: requestId,
 							usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 1 },
@@ -445,37 +445,31 @@ describe("public subagent delegation contract", () => {
 		settledBridge.dispose();
 	});
 
-	it("retains the unversioned prompt-template bridge as legacy fallback", async () => {
+	it("rejects the unversioned prompt-template direct delegation fallback", async () => {
 		const events = new FakeEvents();
-		let structuredCalls = 0;
-		let legacyCalls = 0;
+		let executeCalls = 0;
 		const bridge = registerPromptTemplateDelegationBridge({
 			events,
 			getContext: () => ({ cwd: "/repo" }),
 			execute: async () => {
-				legacyCalls++;
-				return { content: [{ type: "text", text: "legacy done" }], details: { mode: "single", results: [{ agent: "commentator", finalOutput: "legacy done", exitCode: 0 }] } };
-			},
-			executeStructured: async () => {
-				structuredCalls++;
-				return { details: { mode: "single", results: [] } };
+				executeCalls++;
+				return { content: [{ type: "text", text: "unreachable" }], details: { mode: "single", results: [] } };
 			},
 		});
 		const responsePromise = once(events, SUBAGENT_DELEGATION_RESPONSE_EVENT);
 		events.emit(SUBAGENT_DELEGATION_REQUEST_EVENT, {
 			requestId: "legacy-1",
-			agent: "commentator",
+			agent: "reviewer",
 			task: "Legacy prompt-template delegation",
 			context: "fresh",
 			model: "openai/gpt-5",
 			cwd: "/repo",
 		});
-		const response = await responsePromise as { requestId: string; isError: boolean; contentText?: string };
+		const response = await responsePromise as { requestId: string; isError: boolean; errorText?: string };
 		assert.equal(response.requestId, "legacy-1");
-		assert.equal(response.isError, false);
-		assert.equal(response.contentText, "legacy done");
-		assert.equal(legacyCalls, 1);
-		assert.equal(structuredCalls, 0);
+		assert.equal(response.isError, true);
+		assert.match(response.errorText ?? "", /Legacy prompt-template direct delegation was removed/);
+		assert.equal(executeCalls, 0);
 		bridge.dispose();
 	});
 });

package/dist/extensions/pi-subagents/test/unit/doctor.test.ts

@@ -43,7 +43,7 @@ function makeChain(name: string, source: ChainConfig["source"]): ChainConfig {
 		description: `${name} chain`,
 		source,
 		filePath: `/tmp/${name}.chain.md`,
-		steps: [{ agent: "builder", task: "Work" }],
+		steps: [{ agent: "worker", task: "Work" }],
 	};
 }
 

package/dist/extensions/pi-subagents/test/unit/dynamic-fanout.test.ts

@@ -16,7 +16,7 @@ const outputs: ChainOutputMap = {
 	targets: {
 		text: "{\"items\":[{\"path\":\"src/a.ts\"},{\"path\":\"src/b.ts\"}]}",
 		structured: { items: [{ path: "src/a.ts" }, { path: "src/b.ts" }] },
-		agent: "explorer",
+		agent: "scout",
 		stepIndex: 0,
 	},
 };
@@ -26,7 +26,7 @@ describe("dynamic fanout helpers", () => {
 		assert.deepEqual(resolveJsonPointer({ items: [1, 2] }, "/items/1", "path"), 2);
 		const step: ChainStep = {
 			expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path", maxItems: 4 },
-			parallel: { agent: "commentator", task: "Review {target.path}", label: "Review {target.path}" },
+			parallel: { agent: "reviewer", task: "Review {target.path}", label: "Review {target.path}" },
 			collect: { as: "reviews" },
 		};
 		const materialized = materializeDynamicParallelStep(step, outputs, 1);
@@ -38,7 +38,7 @@ describe("dynamic fanout helpers", () => {
 	it("rejects missing structured sources, over-limit arrays, duplicate keys, colliding ids, and bad templates", () => {
 		const base: ChainStep = {
 			expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path", maxItems: 4 },
-			parallel: { agent: "commentator", task: "Review {target.path}" },
+			parallel: { agent: "reviewer", task: "Review {target.path}" },
 			collect: { as: "reviews" },
 		};
 		assert.throws(
@@ -46,7 +46,7 @@ describe("dynamic fanout helpers", () => {
 			/exceeding maxItems/,
 		);
 		assert.throws(
-			() => materializeDynamicParallelStep(base, { targets: { text: "plain", agent: "explorer", stepIndex: 0 } }, 1),
+			() => materializeDynamicParallelStep(base, { targets: { text: "plain", agent: "scout", stepIndex: 0 } }, 1),
 			/requires structured output/,
 		);
 		assert.throws(
@@ -58,15 +58,15 @@ describe("dynamic fanout helpers", () => {
 			/colliding item id/,
 		);
 		assert.throws(
-			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "commentator", task: "Review {other.path}" } }, outputs, 1),
+			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "reviewer", task: "Review {other.path}" } }, outputs, 1),
 			/Unsupported template reference/,
 		);
 		assert.throws(
-			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "commentator", task: "Review {target[path]}" } }, outputs, 1),
+			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "reviewer", task: "Review {target[path]}" } }, outputs, 1),
 			/Invalid item reference/,
 		);
 		assert.throws(
-			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "commentator", task: "Review {target.path" } }, outputs, 1),
+			() => materializeDynamicParallelStep({ ...base, parallel: { agent: "reviewer", task: "Review {target.path" } }, outputs, 1),
 			/Invalid item reference/,
 		);
 	});
@@ -74,13 +74,13 @@ describe("dynamic fanout helpers", () => {
 	it("allows config maxItems defaults and handles empty arrays deterministically", () => {
 		const base: ChainStep = {
 			expand: { from: { output: "targets", path: "/items" }, item: "target", key: "/path" },
-			parallel: { agent: "commentator", task: "Review {target.path}" },
+			parallel: { agent: "reviewer", task: "Review {target.path}" },
 			collect: { as: "reviews" },
 		};
 		const materialized = materializeDynamicParallelStep(base, outputs, 1, { maxItems: 4 });
 		assert.equal(materialized.parallel.length, 2);
 		assert.doesNotThrow(() => validateChainOutputBindings([
-			{ agent: "explorer", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+			{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
 			base,
 		], { maxItems: 4 }));
 		const empty = materializeDynamicParallelStep(base, { targets: { ...outputs.targets, structured: { items: [] } } }, 1, { maxItems: 4 });
@@ -95,29 +95,29 @@ describe("dynamic fanout helpers", () => {
 		const malformed = [
 			{
 				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: [{ agent: "commentator", task: "Review" }],
+				parallel: [{ agent: "reviewer", task: "Review" }],
 				collect: { as: "reviews" },
 			},
 			{
 				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: { agent: "commentator", task: "Review {item.path}" },
+				parallel: { agent: "reviewer", task: "Review {item.path}" },
 			},
 			{
 				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: { agent: "commentator", task: "Review {item.path}" },
+				parallel: { agent: "reviewer", task: "Review {item.path}" },
 				collect: { as: "reviews" },
 				when: "later",
 			},
 			{
 				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: { agent: "commentator", task: "Review {item.path}", as: "child" },
+				parallel: { agent: "reviewer", task: "Review {item.path}", as: "child" },
 				collect: { as: "reviews" },
 			},
 		] as ChainStep[];
 
 		for (const step of malformed) {
 			assert.throws(
-				() => validateChainOutputBindings([{ agent: "explorer", task: "Return targets", as: "targets", outputSchema: { type: "object" } }, step]),
+				() => validateChainOutputBindings([{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } }, step]),
 				ChainOutputValidationError,
 			);
 		}
@@ -129,7 +129,7 @@ describe("dynamic fanout helpers", () => {
 		// (allowRunnerFields) without leaking into the user-facing dynamic field whitelist.
 		const runnerStep = {
 			expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-			parallel: { agent: "commentator", task: "Review {item.path}", parentSessionId: "session-parent" },
+			parallel: { agent: "reviewer", task: "Review {item.path}", parentSessionId: "session-parent" },
 			collect: { as: "reviews" },
 		} as unknown as Parameters<typeof validateDynamicStepShape>[0];
 		assert.doesNotThrow(() => validateDynamicStepShape(runnerStep, 1, { allowRunnerFields: true }));
@@ -142,7 +142,7 @@ describe("dynamic fanout helpers", () => {
 	it("accepts toolBudget on dynamic parallel templates", () => {
 		const step = {
 			expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-			parallel: { agent: "commentator", task: "Review {item.path}", toolBudget: { hard: 3 } },
+			parallel: { agent: "reviewer", task: "Review {item.path}", toolBudget: { hard: 3 } },
 			collect: { as: "reviews" },
 		} as unknown as Parameters<typeof validateDynamicStepShape>[0];
 
@@ -151,10 +151,10 @@ describe("dynamic fanout helpers", () => {
 
 	it("validates source ordering and collect name collisions", () => {
 		const chain: ChainStep[] = [
-			{ agent: "explorer", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
+			{ agent: "scout", task: "Return targets", as: "targets", outputSchema: { type: "object" } },
 			{
 				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: { agent: "commentator", task: "Review {item.path}" },
+				parallel: { agent: "reviewer", task: "Review {item.path}" },
 				collect: { as: "targets" },
 			},
 		];
@@ -167,24 +167,24 @@ describe("dynamic fanout helpers", () => {
 
 	it("validates appended steps against prior and reserved output names", () => {
 		assert.doesNotThrow(() => validateChainOutputBindingsWithContext([
-			{ agent: "builder", task: "Use {outputs.targets}", as: "summary" },
+			{ agent: "worker", task: "Use {outputs.targets}", as: "summary" },
 		], {}, { priorOutputNames: ["targets"], startStepIndex: 2 }));
 		assert.throws(
 			() => validateChainOutputBindingsWithContext([
-				{ agent: "builder", task: "Use {outputs.missing}" },
+				{ agent: "worker", task: "Use {outputs.missing}" },
 			], {}, { priorOutputNames: ["targets"], startStepIndex: 2 }),
 			/Unknown chain output reference '\{outputs\.missing\}' at step 3/,
 		);
 		assert.throws(
 			() => validateChainOutputBindingsWithContext([
-				{ agent: "builder", task: "Use {previous}", as: "targets" },
+				{ agent: "worker", task: "Use {previous}", as: "targets" },
 			], {}, { priorOutputNames: ["targets"], startStepIndex: 2 }),
 			/Duplicate chain output name 'targets'/,
 		);
 		assert.doesNotThrow(() => validateChainOutputBindingsWithContext([
 			{
 				expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-				parallel: { agent: "commentator", task: "Review {item.path}" },
+				parallel: { agent: "reviewer", task: "Review {item.path}" },
 				collect: { as: "reviews" },
 			},
 		], {}, { priorOutputNames: ["targets"], startStepIndex: 2 }));
@@ -193,7 +193,7 @@ describe("dynamic fanout helpers", () => {
 	it("collects ordered child result records and validates aggregate schema", async () => {
 		const step: ChainStep = {
 			expand: { from: { output: "targets", path: "/items" }, key: "/path", maxItems: 4 },
-			parallel: { agent: "commentator", task: "Review {item.path}" },
+			parallel: { agent: "reviewer", task: "Review {item.path}" },
 			collect: { as: "reviews" },
 		};
 		const materialized = materializeDynamicParallelStep(step, outputs, 1);
@@ -207,8 +207,8 @@ describe("dynamic fanout helpers", () => {
 			finalOutput: "ok",
 			structuredOutput,
 		});
-		const timedOut = { ...result("commentator", { ok: "b" }), exitCode: 1, error: "Subagent timed out after 300ms.", timedOut: true };
-		const collected = collectDynamicResults(step, materialized.items, [result("commentator", { ok: "a" }), timedOut]);
+		const timedOut = { ...result("reviewer", { ok: "b" }), exitCode: 1, error: "Subagent timed out after 300ms.", timedOut: true };
+		const collected = collectDynamicResults(step, materialized.items, [result("reviewer", { ok: "a" }), timedOut]);
 		assert.deepEqual(collected.map((item) => item.key), ["src/a.ts", "src/b.ts"]);
 		assert.deepEqual(collected.map((item) => item.structured), [{ ok: "a" }, { ok: "b" }]);
 		assert.equal(collected[1]?.timedOut, true);

package/dist/extensions/pi-subagents/test/unit/extra-agent-dirs.test.ts

@@ -44,16 +44,16 @@ describe("SELESAI_SUBAGENT_EXTRA_AGENT_DIRS discovery", () => {
 
 	it("discovers agents from the env-provided dirs as a 'user' source", () => {
 		const bundledDir = path.join(tempDir, "store", "agents");
-		const bundledAgent = writeAgent(bundledDir, "bundled-commentator");
+		const bundledAgent = writeAgent(bundledDir, "bundled-reviewer");
 		process.env[EXTRA_AGENT_DIRS_ENV] = bundledDir;
 
 		const scoped = discoverAgents(cwd, "user");
-		const found = scoped.agents.find((agent) => agent.name === "bundled-commentator");
+		const found = scoped.agents.find((agent) => agent.name === "bundled-reviewer");
 		assert.ok(found, "expected bundled agent under 'user' scope");
 		assert.equal(found?.filePath, bundledAgent);
 
 		const all = discoverAgentsAll(cwd);
-		assert.ok(all.user.find((agent) => agent.name === "bundled-commentator" && agent.filePath === bundledAgent));
+		assert.ok(all.user.find((agent) => agent.name === "bundled-reviewer" && agent.filePath === bundledAgent));
 	});
 
 	it("scans every directory listed (PATH-style delimiter)", () => {

package/dist/extensions/pi-subagents/test/unit/file-coalescer.test.ts

@@ -53,6 +53,21 @@ describe("createFileCoalescer", () => {
 		assert.deepEqual(events.sort(), ["a.json", "b.json"]);
 	});
 
+	it("flushes a pending file immediately without a duplicate timer write", () => {
+		const events: string[] = [];
+		const timers = createFakeTimers();
+		const coalescer = createFileCoalescer((file) => events.push(file), 50, timers.timerApi);
+		coalescer.schedule("status.json");
+		coalescer.schedule("status.json");
+		assert.equal(timers.pendingCount(), 1);
+		assert.equal(coalescer.flush("status.json"), true);
+		assert.deepEqual(events, ["status.json"]);
+		assert.equal(timers.pendingCount(), 0);
+		timers.runAll();
+		assert.deepEqual(events, ["status.json"]);
+		assert.equal(coalescer.flush("status.json"), false);
+	});
+
 	it("clear cancels all pending handlers", () => {
 		const events: string[] = [];
 		const timers = createFakeTimers();

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

@@ -62,7 +62,7 @@ describe("below-editor subagent FleetView", () => {
 				mode: "single",
 				startedAt: now - 11_000 + index,
 				updatedAt: now,
-				currentAgent: `builder-${index}`,
+				currentAgent: `worker-${index}`,
 				description: index === 0 ? "Inspect\nmodule 0" : `Inspect module ${index}`,
 				...(index === 0 ? { model: "anthropic/fable-5", thinking: "low" } : {}),
 				tokens: index === 0 ? 13_100 : 100,
@@ -106,9 +106,9 @@ describe("below-editor subagent FleetView", () => {
 			assert.deepEqual(fleet.handleKey("\x1b[B"), { consume: true });
 			const expandedLines = component.render(80);
 			assert.ok(expandedLines.some((line) => line.includes("> main")));
-			assert.ok(expandedLines.some((line) => line.includes("  builder-0")), "unselected agents use blank focus space");
+			assert.ok(expandedLines.some((line) => line.includes("  worker-0")), "unselected agents use blank focus space");
 			assert.ok(expandedLines.every((line) => !/[⏺◯]/u.test(line)), "selection avoids terminal-ambiguous circle glyphs");
-			assert.ok(expandedLines.some((line) => line.includes("builder-0 (fable-5 · thinking low)")));
+			assert.ok(expandedLines.some((line) => line.includes("worker-0 (fable-5 · thinking low)")));
 			assert.ok(expandedLines.some((line) => line.includes("11s · ↓ 13.1k tokens")));
 			assert.ok(expandedLines.some((line) => line.includes("↓ 1 more")));
 			for (const line of expandedLines) assert.ok(visibleWidth(line) <= 80, `line exceeded width: ${line}`);
@@ -124,9 +124,9 @@ describe("below-editor subagent FleetView", () => {
 
 	it("keeps one queued agent visible in the compact summary", () => {
 		const state = stateForTest();
-		state.asyncJobs.set("run-builder", {
-			asyncId: "run-builder",
-			asyncDir: "/tmp/run-builder",
+		state.asyncJobs.set("run-worker", {
+			asyncId: "run-worker",
+			asyncDir: "/tmp/run-worker",
 			status: "queued",
 			mode: "single",
 			startedAt: 10,
@@ -160,12 +160,12 @@ describe("below-editor subagent FleetView", () => {
 
 	it("registers above the editor when configured", () => {
 		const state = stateForTest();
-		state.foregroundControls.set("run-builder", {
-			runId: "run-builder",
+		state.foregroundControls.set("run-worker", {
+			runId: "run-worker",
 			mode: "single",
 			startedAt: 10,
 			updatedAt: 20,
-			currentAgent: "builder",
+			currentAgent: "worker",
 		});
 		let placement: string | undefined;
 		const ctx = {
@@ -191,12 +191,12 @@ describe("below-editor subagent FleetView", () => {
 
 	it("stops refreshing when the captured extension context becomes stale", () => {
 		const state = stateForTest();
-		state.foregroundControls.set("run-builder", {
-			runId: "run-builder",
+		state.foregroundControls.set("run-worker", {
+			runId: "run-worker",
 			mode: "single",
 			startedAt: 10,
 			updatedAt: 20,
-			currentAgent: "builder",
+			currentAgent: "worker",
 		});
 		let stale = false;
 		let contextReads = 0;
@@ -238,12 +238,12 @@ describe("below-editor subagent FleetView", () => {
 
 	it("does not swallow unrelated widget cleanup errors", () => {
 		const state = stateForTest();
-		state.foregroundControls.set("run-builder", {
-			runId: "run-builder",
+		state.foregroundControls.set("run-worker", {
+			runId: "run-worker",
 			mode: "single",
 			startedAt: 10,
 			updatedAt: 20,
-			currentAgent: "builder",
+			currentAgent: "worker",
 		});
 		const ctx = {
 			hasUI: true,
@@ -264,12 +264,12 @@ describe("below-editor subagent FleetView", () => {
 
 	it("preserves multiple unrelated UI cleanup errors", () => {
 		const state = stateForTest();
-		state.foregroundControls.set("run-builder", {
-			runId: "run-builder",
+		state.foregroundControls.set("run-worker", {
+			runId: "run-worker",
 			mode: "single",
 			startedAt: 10,
 			updatedAt: 20,
-			currentAgent: "builder",
+			currentAgent: "worker",
 		});
 		const ctx = {
 			hasUI: true,
@@ -297,12 +297,12 @@ describe("below-editor subagent FleetView", () => {
 
 	it("keeps widget ownership through invalidation so an empty refresh removes it", () => {
 		const state = stateForTest();
-		state.foregroundControls.set("run-builder", {
-			runId: "run-builder",
+		state.foregroundControls.set("run-worker", {
+			runId: "run-worker",
 			mode: "single",
 			startedAt: 10,
 			updatedAt: 20,
-			currentAgent: "builder",
+			currentAgent: "worker",
 		});
 		let widgetFactory: ((tui: unknown, theme: typeof theme) => { render(width: number): string[]; invalidate(): void }) | undefined;
 		let removals = 0;
@@ -335,12 +335,12 @@ describe("below-editor subagent FleetView", () => {
 
 	it("removes the dynamic widget while the fleet inspector owns the viewport", () => {
 		const state = stateForTest();
-		state.foregroundControls.set("run-builder", {
-			runId: "run-builder",
+		state.foregroundControls.set("run-worker", {
+			runId: "run-worker",
 			mode: "single",
 			startedAt: 10,
 			updatedAt: 20,
-			currentAgent: "builder",
+			currentAgent: "worker",
 		});
 		const registrations: string[] = [];
 		const ctx = {
@@ -500,9 +500,9 @@ describe("below-editor subagent FleetView", () => {
 			startedAt: 50,
 			updatedAt: 200,
 			steps: [
-				{ agent: "explorer", index: 0, status: "complete" },
-				{ agent: "builder", index: 1, status: "running" },
-				{ agent: "commentator", index: 2, status: "pending" },
+				{ agent: "scout", index: 0, status: "complete" },
+				{ agent: "worker", index: 1, status: "running" },
+				{ agent: "reviewer", index: 2, status: "pending" },
 			],
 		});
 		state.asyncJobs.set("parallel-group", {
@@ -515,7 +515,7 @@ describe("below-editor subagent FleetView", () => {
 			startedAt: 100,
 			updatedAt: 200,
 			steps: [
-				{ agent: "commentator", index: 3, status: "running" },
+				{ agent: "reviewer", index: 3, status: "running" },
 				{ agent: "tester", index: 4, status: "pending" },
 			],
 		});
@@ -534,9 +534,9 @@ describe("below-editor subagent FleetView", () => {
 			startedAt: 10,
 			updatedAt: 30,
 			activeChildren: new Map([
-				[0, { index: 0, agent: "commentator", description: "Review correctness", startedAt: 11, updatedAt: 21, tokens: 100 }],
-				[1, { index: 1, agent: "commentator", description: "Review quality", startedAt: 12, updatedAt: 22, tokens: 200 }],
-				[2, { index: 2, agent: "commentator", description: "Review tests", startedAt: 13, updatedAt: 23, tokens: 300 }],
+				[0, { index: 0, agent: "reviewer", description: "Review correctness", startedAt: 11, updatedAt: 21, tokens: 100 }],
+				[1, { index: 1, agent: "reviewer", description: "Review quality", startedAt: 12, updatedAt: 22, tokens: 200 }],
+				[2, { index: 2, agent: "reviewer", description: "Review tests", startedAt: 13, updatedAt: 23, tokens: 300 }],
 			]),
 		});
 
@@ -550,6 +550,24 @@ describe("below-editor subagent FleetView", () => {
 		assert.deepEqual(collectFleetSnapshot(state).items.map((item) => item.key), entries.map((entry) => entry.key));
 	});
 
+	it("labels workflow-owned foreground children", () => {
+		const state = stateForTest();
+		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", description: "Review the change", startedAt: 10, updatedAt: 20 }]]),
+		});
+
+		assert.deepEqual(collectFleetStatusEntries(state).map((entry) => ({ agent: entry.agent, description: entry.description })), [{
+			agent: "reviewer",
+			description: "workflow child: workflow-1 (review) · Review the change",
+		}]);
+	});
+
 	it("uses the same item keys as the full inspector", () => {
 		const state = stateForTest();
 		state.foregroundControls.set("foreground", {
@@ -557,7 +575,7 @@ describe("below-editor subagent FleetView", () => {
 			mode: "single",
 			startedAt: 10,
 			updatedAt: 20,
-			currentAgent: "builder",
+			currentAgent: "worker",
 			currentIndex: 2,
 		});
 		const asyncJob = {
@@ -568,7 +586,7 @@ describe("below-editor subagent FleetView", () => {
 			mode: "single" as const,
 			startedAt: 10,
 			updatedAt: 20,
-			steps: [{ agent: "commentator", index: 0, status: "running" as const }],
+			steps: [{ agent: "reviewer", index: 0, status: "running" as const }],
 		};
 		state.asyncJobs.set(asyncJob.asyncId, asyncJob);
 		state.fleetJobs!.set(asyncJob.asyncId, asyncJob);
@@ -589,8 +607,8 @@ describe("below-editor subagent FleetView", () => {
 			startedAt: 100,
 			updatedAt: 200,
 			steps: [
-				{ agent: "commentator", index: 0, status: "running", description: "Review only authentication", startedAt: 120, model: "openai/gpt-5", thinking: "medium", tokens: { input: 4_000, output: 200, total: 4_200 } },
-				{ agent: "builder", index: 1, status: "running", description: "Implement only billing", startedAt: 121, tokens: { input: 100, output: 20, total: 120 } },
+				{ agent: "reviewer", index: 0, status: "running", description: "Review only authentication", startedAt: 120, model: "openai/gpt-5", thinking: "medium", tokens: { input: 4_000, output: 200, total: 4_200 } },
+				{ agent: "worker", index: 1, status: "running", description: "Implement only billing", startedAt: 121, tokens: { input: 100, output: 20, total: 120 } },
 			],
 		});
 		const fleet = new SubagentFleetStatus(state, () => {}, { refreshMs: 60_000 });
@@ -612,8 +630,8 @@ describe("below-editor subagent FleetView", () => {
 			const component = widgetFactory!(tui, theme);
 			assert.deepEqual(fleet.handleKey("\x1b[B"), { consume: true });
 			const lines = component.render(180);
-			assert.ok(lines.some((line) => line.includes("commentator (gpt-5 · thinking medium)") && line.includes("Review only authentication")));
-			assert.ok(lines.some((line) => line.includes("builder") && line.includes("Implement only billing")));
+			assert.ok(lines.some((line) => line.includes("reviewer (gpt-5 · thinking medium)") && line.includes("Review only authentication")));
+			assert.ok(lines.some((line) => line.includes("worker") && line.includes("Implement only billing")));
 			assert.ok(lines.every((line) => !line.includes("Review the authentication changes")), "per-child descriptions should replace the run-level fallback when present");
 			assert.ok(lines.some((line) => line.includes("↓ 4.2k tokens")));
 		} finally {
@@ -623,12 +641,12 @@ describe("below-editor subagent FleetView", () => {
 
 	it("only captures navigation at an empty editor and opens the selected child", async () => {
 		const state = stateForTest();
-		state.foregroundControls.set("run-builder", {
-			runId: "run-builder",
+		state.foregroundControls.set("run-worker", {
+			runId: "run-worker",
 			mode: "single",
 			startedAt: Date.now() - 1_000,
 			updatedAt: Date.now(),
-			currentAgent: "builder",
+			currentAgent: "worker",
 			description: "Implement FleetView",
 		});
 		let editorText = "draft";
@@ -682,16 +700,16 @@ describe("below-editor subagent FleetView", () => {
 			assert.deepEqual(inputHandler!("\x1b[B"), { consume: true }, "custom editors should activate FleetView across jiti boundaries");
 			assert.ok(component.render(100).length > 1, "keyboard activation should expand the roster");
 			assert.deepEqual(inputHandler!("j"), { consume: true }, "active FleetView should navigate down with j");
-			assert.ok(component.render(100).some((line) => line.includes("> builder")));
+			assert.ok(component.render(100).some((line) => line.includes("> worker")));
 			assert.deepEqual(inputHandler!("k"), { consume: true }, "active FleetView should navigate up with k");
 			assert.ok(component.render(100).some((line) => line.includes("> main")));
 
 			tui.focusedComponent = Object.create(Editor.prototype) as Editor;
 			assert.deepEqual(inputHandler!("\x1b[B"), { consume: true });
-			assert.ok(component.render(100).some((line) => line.includes("> builder")));
+			assert.ok(component.render(100).some((line) => line.includes("> worker")));
 			assert.deepEqual(inputHandler!("\r"), { consume: true });
 			await Promise.resolve();
-			assert.deepEqual(opened, ["foreground-active:run-builder:0"]);
+			assert.deepEqual(opened, ["foreground-active:run-worker:0"]);
 			assert.equal(widgetFactory, undefined, "the widget should unregister while the inspector owns the viewport");
 
 			closeInspector!();
@@ -699,7 +717,7 @@ describe("below-editor subagent FleetView", () => {
 			assert.ok(widgetFactory, "closing should restore the FleetView widget");
 			assert.notEqual(widgetFactory, component, "restoration should install a new component factory");
 			const restoredComponent = widgetFactory!(tui, theme);
-			assert.ok(restoredComponent.render(100).some((line) => line.includes("> builder")), "closing should restore the prior selected roster row");
+			assert.ok(restoredComponent.render(100).some((line) => line.includes("> worker")), "closing should restore the prior selected roster row");
 			assert.deepEqual(inputHandler!("\x1b"), { consume: true });
 			assert.equal(restoredComponent.render(100).length, 1, "Escape should return to the compact summary");
 		} finally {