@selesai/code 0.8.2 → 0.8.4

package/dist/extensions/pi-subagents/test/integration/async-job-tracker.test.ts

@@ -1,9 +1,11 @@
 import assert from "node:assert/strict";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { describe, it } from "node:test";
+import { afterEach, describe, it } from "node:test";
 import { getProjectArtifactsDir } from "../../src/shared/artifacts.ts";
+import { updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
 import { SubagentFleetComponent } from "../../src/tui/fleet.ts";
+import { createNestedRoute } from "../../src/runs/shared/nested-events.ts";
 import { createTempDir, removeTempDir, tryImport } from "../support/helpers.ts";
 
 interface AsyncJobTrackerModule {
@@ -31,6 +33,20 @@ interface AsyncJobTrackerModule {
 const trackerMod = await tryImport<AsyncJobTrackerModule>("./src/runs/background/async-job-tracker.ts");
 const available = !!trackerMod;
 
+type AsyncJobTracker = ReturnType<AsyncJobTrackerModule["createAsyncJobTracker"]>;
+const activeTrackers = new Set<AsyncJobTracker>();
+
+function createTracker(...args: Parameters<AsyncJobTrackerModule["createAsyncJobTracker"]>): AsyncJobTracker {
+	const tracker = trackerMod!.createAsyncJobTracker(...args);
+	activeTrackers.add(tracker);
+	return tracker;
+}
+
+afterEach(() => {
+	for (const tracker of activeTrackers) tracker.resetJobs();
+	activeTrackers.clear();
+});
+
 function createState() {
 	return {
 		baseCwd: "/repo",
@@ -119,14 +135,14 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		try {
 			const state = createState();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot);
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot);
 			(state as { lastUiContext: unknown }).lastUiContext = {
 				get hasUI() {
 					throw new Error("This extension ctx is stale after session replacement or reload.");
 				},
 			};
 
-			tracker.handleStarted({ id: "run-stale-context", asyncDir: path.join(asyncRoot, "run-stale-context"), agent: "builder" });
+			tracker.handleStarted({ id: "run-stale-context", asyncDir: path.join(asyncRoot, "run-stale-context"), agent: "worker" });
 
 			assert.equal(state.lastUiContext, null);
 			if (state.poller) clearInterval(state.poller);
@@ -141,11 +157,11 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			const state = createState();
 			const ui = createUiContext();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				completionRetentionMs: 5,
 			});
 			tracker.resetJobs(ui.ctx as never);
-			tracker.handleStarted({ id: "run-1", asyncDir: path.join(asyncRoot, "run-1"), agent: "builder" });
+			tracker.handleStarted({ id: "run-1", asyncDir: path.join(asyncRoot, "run-1"), agent: "worker" });
 			tracker.handleComplete({ id: "run-1", success: true });
 
 			assert.equal(state.asyncJobs.size, 1);
@@ -167,11 +183,11 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			const state = createState();
 			const ui = createUiContext();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				widgetEnabled: false,
 			});
 			tracker.resetJobs(ui.ctx as never);
-			tracker.handleStarted({ id: "run-hidden", asyncDir: path.join(asyncRoot, "run-hidden"), agent: "builder" });
+			tracker.handleStarted({ id: "run-hidden", asyncDir: path.join(asyncRoot, "run-hidden"), agent: "worker" });
 
 			assert.equal(state.asyncJobs.size, 1, "disabled rendering must not disable lifecycle tracking");
 			assert.ok(ui.widgets.length > 0, "expected widget clear calls");
@@ -205,9 +221,9 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				chainStepCount: 3,
 				parallelGroups: [{ start: 1, count: 2, stepIndex: 1 }],
 				steps: [
-					{ agent: "explorer", status: "complete" },
-					{ agent: "commentator", status: "running", currentTool: "read", transcriptPath },
-					{ agent: "builder", status: "running" },
+					{ agent: "scout", status: "complete" },
+					{ agent: "reviewer", status: "running", currentTool: "read", transcriptPath },
+					{ agent: "worker", status: "running" },
 					{ agent: "writer", status: "pending" },
 				],
 			}), "utf-8");
@@ -219,16 +235,17 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 					to: "needs_attention",
 					ts: 123,
 					runId: "run-restored",
-					agent: "commentator",
+					agent: "reviewer",
 					message: "old notice",
 				},
 			})}\n`, "utf-8");
+			updateActiveRunIndex(runDir, "running");
 
 			const state = createState();
 			state.currentSessionId = "session-restored";
 			const ui = createUiContext();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 			});
 			tracker.resetJobs(ui.ctx as never);
@@ -239,7 +256,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			assert.equal(job.status, "running");
 			assert.equal(job.sessionId, "session-restored");
 			assert.equal(job.cwd, customCwd);
-			assert.deepEqual(job.agents, ["commentator", "builder"]);
+			assert.deepEqual(job.agents, ["reviewer", "worker"]);
 			assert.deepEqual(job.steps?.map((step: { index?: number }) => step.index), [1, 2]);
 			assert.equal(job.stepsTotal, 2);
 			assert.equal(job.runningSteps, 2);
@@ -269,7 +286,58 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		}
 	});
 
-	it("restores workflow state and refreshes live workflow progress after reload", async () => {
+	it("refreshes restored nested async children from event files before the liveness sweep", async () => {
+		const asyncRoot = createTempDir("pi-async-job-restore-nested-events-");
+		const nestedRoute = createNestedRoute("run-restored-nested");
+		const routeRoot = path.dirname(nestedRoute.eventSink);
+		try {
+			const runDir = path.join(asyncRoot, "run-restored-nested");
+			fs.mkdirSync(runDir, { recursive: true });
+			fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
+				runId: "run-restored-nested",
+				mode: "single",
+				state: "running",
+				sessionId: "session-restored-nested",
+				startedAt: 1000,
+				lastUpdate: 2000,
+				steps: [{ agent: "worker", status: "running" }],
+			}), "utf-8");
+			updateActiveRunIndex(runDir, "running");
+			const state = createState();
+			state.currentSessionId = "session-restored-nested";
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, { pollIntervalMs: 60_000 });
+			tracker.restoreActiveJobs();
+			assert.equal(state.asyncJobs.get("run-restored-nested")?.nestedRoute?.eventSink, nestedRoute.eventSink);
+
+			await new Promise((resolve) => setTimeout(resolve, 150));
+			fs.writeFileSync(path.join(nestedRoute.eventSink, "0000000003000-child.json"), JSON.stringify({
+				type: "subagent.nested.started",
+				ts: 3000,
+				rootRunId: nestedRoute.rootRunId,
+				parentRunId: "run-restored-nested",
+				parentStepIndex: 0,
+				capabilityToken: nestedRoute.capabilityToken,
+				child: {
+					id: "nested-child",
+					parentRunId: "run-restored-nested",
+					parentStepIndex: 0,
+					depth: 1,
+					path: [{ runId: "run-restored-nested", stepIndex: 0 }],
+					state: "running",
+					agent: "nested-worker",
+				},
+			}), "utf-8");
+
+			await waitForCondition(() => state.asyncJobs.get("run-restored-nested")?.nestedChildren?.[0]?.id === "nested-child", "restored evented nested child refresh", 1000);
+			assert.equal(state.asyncJobs.get("run-restored-nested")?.steps?.[0]?.children?.[0]?.id, "nested-child");
+			tracker.resetJobs();
+		} finally {
+			removeTempDir(asyncRoot);
+			removeTempDir(routeRoot);
+		}
+	});
+
+	it("refreshes restored workflow status from filesystem events before the liveness sweep", async () => {
 		const asyncRoot = createTempDir("pi-async-job-restore-workflow-");
 		try {
 			const runDir = path.join(asyncRoot, "workflow-run");
@@ -285,9 +353,10 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				steps: [{ agent: "scan", label: "scan", status: "running" }],
 				workflow: { trace: [{ operation: "run", key: "scan", state: "started" }], emits: [{ stage: "scan" }], console: [] },
 			}), "utf-8");
+			updateActiveRunIndex(runDir, "running");
 			const state = createState();
 			state.currentSessionId = "session-workflow";
-			const tracker = trackerMod!.createAsyncJobTracker(createEventRecorder().pi, state as never, asyncRoot, { pollIntervalMs: 10 });
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, { pollIntervalMs: 60_000 });
 			tracker.restoreActiveJobs();
 			assert.deepEqual(state.asyncJobs.get("workflow-run")?.workflow?.emits, [{ stage: "scan" }]);
 
@@ -301,7 +370,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				steps: [{ agent: "scan", label: "scan", status: "complete" }, { agent: "review", label: "review", status: "running" }],
 				workflow: { trace: [{ operation: "run", key: "review", state: "started" }], emits: [{ stage: "review" }], console: [] },
 			}), "utf-8");
-			await waitForCondition(() => JSON.stringify(state.asyncJobs.get("workflow-run")?.workflow?.emits) === JSON.stringify([{ stage: "review" }]), "workflow poll refresh", 1000);
+			await waitForCondition(() => JSON.stringify(state.asyncJobs.get("workflow-run")?.workflow?.emits) === JSON.stringify([{ stage: "review" }]), "evented workflow refresh", 1000);
 			assert.equal(state.asyncJobs.get("workflow-run")?.workflow?.trace[0]?.key, "review");
 			tracker.resetJobs();
 		} finally {
@@ -309,6 +378,81 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		}
 	});
 
+	it("refreshes newly started runs when status appears after the run directory", async () => {
+		const asyncRoot = createTempDir("pi-async-job-late-status-");
+		try {
+			const runDir = path.join(asyncRoot, "late-status-run");
+			fs.mkdirSync(runDir, { recursive: true });
+			const state = createState();
+			state.currentSessionId = "session-late-status";
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, { pollIntervalMs: 60_000 });
+			tracker.handleStarted({ id: "late-status-run", asyncDir: runDir, sessionId: "session-late-status", agent: "worker" });
+
+			await new Promise((resolve) => setTimeout(resolve, 150));
+			fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
+				runId: "late-status-run",
+				mode: "single",
+				state: "running",
+				sessionId: "session-late-status",
+				startedAt: 1000,
+				lastUpdate: 3000,
+				steps: [{ agent: "worker", status: "running", currentTool: "read" }],
+			}), "utf-8");
+
+			await waitForCondition(() => state.asyncJobs.get("late-status-run")?.steps?.[0]?.currentTool === "read", "late status refresh before liveness", 1000);
+			tracker.resetJobs();
+		} finally {
+			removeTempDir(asyncRoot);
+		}
+	});
+
+	it("refreshes nested async children from event files before the liveness sweep", async () => {
+		const asyncRoot = createTempDir("pi-async-job-nested-events-");
+		const nestedRoute = createNestedRoute("run-nested-events");
+		const routeRoot = path.dirname(nestedRoute.eventSink);
+		try {
+			const runDir = path.join(asyncRoot, "run-nested-events");
+			fs.mkdirSync(runDir, { recursive: true });
+			fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
+				runId: "run-nested-events",
+				mode: "single",
+				state: "running",
+				startedAt: 1000,
+				lastUpdate: 2000,
+				steps: [{ agent: "worker", status: "running" }],
+			}), "utf-8");
+			const state = createState();
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, { pollIntervalMs: 60_000 });
+			tracker.handleStarted({ id: "run-nested-events", asyncDir: runDir, agent: "worker", nestedRoute });
+
+			await new Promise((resolve) => setTimeout(resolve, 150));
+			fs.writeFileSync(path.join(nestedRoute.eventSink, "0000000003000-child.json"), JSON.stringify({
+				type: "subagent.nested.started",
+				ts: 3000,
+				rootRunId: nestedRoute.rootRunId,
+				parentRunId: "run-nested-events",
+				parentStepIndex: 0,
+				capabilityToken: nestedRoute.capabilityToken,
+				child: {
+					id: "nested-child",
+					parentRunId: "run-nested-events",
+					parentStepIndex: 0,
+					depth: 1,
+					path: [{ runId: "run-nested-events", stepIndex: 0 }],
+					state: "running",
+					agent: "nested-worker",
+				},
+			}), "utf-8");
+
+			await waitForCondition(() => state.asyncJobs.get("run-nested-events")?.nestedChildren?.[0]?.id === "nested-child", "evented nested child refresh", 1000);
+			assert.equal(state.asyncJobs.get("run-nested-events")?.steps?.[0]?.children?.[0]?.id, "nested-child");
+			tracker.resetJobs();
+		} finally {
+			removeTempDir(asyncRoot);
+			removeTempDir(routeRoot);
+		}
+	});
+
 	it("restores async workflow child ownership after reload", () => {
 		const asyncRoot = createTempDir("pi-async-job-restore-workflow-child-");
 		try {
@@ -322,11 +466,12 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				startedAt: 1000,
 				parentWorkflowRunId: "workflow-parent",
 				workflowKey: "review",
-				steps: [{ agent: "commentator", status: "running" }],
+				steps: [{ agent: "reviewer", status: "running" }],
 			}), "utf-8");
+			updateActiveRunIndex(runDir, "running");
 			const state = createState();
 			state.currentSessionId = "session-workflow";
-			const tracker = trackerMod!.createAsyncJobTracker(createEventRecorder().pi, state as never, asyncRoot, { pollIntervalMs: 10 });
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, { pollIntervalMs: 10 });
 			tracker.restoreActiveJobs();
 			assert.equal(state.asyncJobs.get("workflow-child")?.parentWorkflowRunId, "workflow-parent");
 			assert.equal(state.asyncJobs.get("workflow-child")?.workflowKey, "review");
@@ -349,7 +494,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				state: "running",
 				sessionId: "session-owner",
 				startedAt: 1000,
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			}), "utf-8");
 			fs.writeFileSync(path.join(otherDir, "status.json"), JSON.stringify({
 				runId: "run-other",
@@ -357,12 +502,14 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				state: "running",
 				sessionId: "session-other",
 				startedAt: 1000,
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			}), "utf-8");
+			updateActiveRunIndex(ownerDir, "running");
+			updateActiveRunIndex(otherDir, "running");
 
 			const state = createState();
 			state.currentSessionId = "session-owner";
-			const tracker = trackerMod!.createAsyncJobTracker(createEventRecorder().pi, state as never, asyncRoot, {
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 			});
 			tracker.restoreActiveJobs();
@@ -379,14 +526,14 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		try {
 			const state = createState();
 			state.currentSessionId = "session-owner";
-			const tracker = trackerMod!.createAsyncJobTracker(createEventRecorder().pi, state as never, asyncRoot, {
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, {
 				completionRetentionMs: 5,
 				pollIntervalMs: 10,
 			});
 
-			tracker.handleStarted({ id: "run-sessionless", asyncDir: path.join(asyncRoot, "run-sessionless"), agent: "builder" });
-			tracker.handleStarted({ id: "run-other", asyncDir: path.join(asyncRoot, "run-other"), agent: "builder", sessionId: "session-other" });
-			tracker.handleStarted({ id: "run-owner", asyncDir: path.join(asyncRoot, "run-owner"), agent: "builder", sessionId: "session-owner" });
+			tracker.handleStarted({ id: "run-sessionless", asyncDir: path.join(asyncRoot, "run-sessionless"), agent: "worker" });
+			tracker.handleStarted({ id: "run-other", asyncDir: path.join(asyncRoot, "run-other"), agent: "worker", sessionId: "session-other" });
+			tracker.handleStarted({ id: "run-owner", asyncDir: path.join(asyncRoot, "run-owner"), agent: "worker", sessionId: "session-owner" });
 
 			assert.deepEqual([...state.asyncJobs.keys()], ["run-owner"]);
 
@@ -408,6 +555,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			const runDir = path.join(asyncRoot, "run-bad-status");
 			fs.mkdirSync(runDir, { recursive: true });
 			fs.writeFileSync(path.join(runDir, "status.json"), "{bad json", "utf-8");
+			updateActiveRunIndex(runDir, "running");
 
 			const state = createState();
 			state.currentSessionId = "session-bad";
@@ -418,7 +566,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				errors.push(args);
 			};
 
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 			});
 			tracker.resetJobs(ui.ctx as never);
@@ -437,21 +585,21 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		try {
 			const state = createState();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot);
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot);
 
 			tracker.handleStarted({
 				id: "run-parallel-start",
 				asyncDir: path.join(asyncRoot, "run-parallel-start"),
 				cwd: path.join(asyncRoot, "custom-cwd"),
-				agent: "explorer",
-				agents: ["explorer", "commentator", "builder", "writer"],
-				chain: ["[explorer+commentator+builder]", "writer"],
+				agent: "scout",
+				agents: ["scout", "reviewer", "worker", "writer"],
+				chain: ["[scout+reviewer+worker]", "writer"],
 				chainStepCount: 2,
 				parallelGroups: [{ start: 0, count: 3, stepIndex: 0 }],
 			});
 
 			const job = state.asyncJobs.get("run-parallel-start");
-			assert.deepEqual(job?.agents, ["explorer", "commentator", "builder"]);
+			assert.deepEqual(job?.agents, ["scout", "reviewer", "worker"]);
 			assert.equal(job?.cwd, path.join(asyncRoot, "custom-cwd"));
 			assert.equal(job?.chainStepCount, 2);
 			assert.deepEqual(job?.parallelGroups, [{ start: 0, count: 3, stepIndex: 0 }]);
@@ -477,14 +625,14 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				chainStepCount: 3,
 				parallelGroups: [{ start: 1, count: 2, stepIndex: 1 }],
 				steps: [
-					{ agent: "explorer", status: "complete" },
+					{ agent: "scout", status: "complete" },
 					{
-						agent: "commentator",
+						agent: "reviewer",
 						status: "running",
 						currentTool: "read",
 						currentToolArgs: "src/tui/render.ts",
 						recentTools: [{ tool: "grep", args: "async widget", endMs: Date.now() - 100 }],
-						recentOutput: ["commentator line"],
+						recentOutput: ["reviewer line"],
 					},
 					{ agent: "auditor", status: "running" },
 					{ agent: "writer", status: "pending" },
@@ -494,56 +642,58 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			const state = createState();
 			const ui = createUiContext();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 			});
 			tracker.resetJobs(ui.ctx as never);
-			tracker.handleStarted({ id: "run-chain", asyncDir: runDir, mode: "chain", agents: ["explorer", "commentator", "auditor", "writer"] });
+			tracker.handleStarted({ id: "run-chain", asyncDir: runDir, mode: "chain", agents: ["scout", "reviewer", "auditor", "writer"] });
 
 			await new Promise((resolve) => setTimeout(resolve, 50));
 
 			const job = state.asyncJobs.get("run-chain");
 			assert.deepEqual(job?.steps?.map((step: { index?: number }) => step.index), [1, 2]);
-			assert.deepEqual(job?.agents, ["commentator", "auditor"]);
+			assert.deepEqual(job?.agents, ["reviewer", "auditor"]);
 			assert.equal(job?.steps?.[0]?.currentTool, "read");
 			assert.equal(job?.steps?.[0]?.currentToolArgs, "src/tui/render.ts");
 			assert.deepEqual(job?.steps?.[0]?.recentTools?.map((tool: { tool: string; args: string }) => ({ tool: tool.tool, args: tool.args })), [{ tool: "grep", args: "async widget" }]);
-			assert.deepEqual(job?.steps?.[0]?.recentOutput, ["commentator line"]);
+			assert.deepEqual(job?.steps?.[0]?.recentOutput, ["reviewer line"]);
 		} finally {
 			removeTempDir(asyncRoot);
 		}
 	});
 
-	it("rerenders changed polled status but not unchanged bookkeeping", async () => {
+	it("repaints unchanged running widgets without rebuilding them and stops at terminal status", async () => {
 		const asyncRoot = createTempDir("pi-async-job-tracker-");
+		let tracker: ReturnType<AsyncJobTrackerModule["createAsyncJobTracker"]> | undefined;
 		try {
 			const runDir = path.join(asyncRoot, "run-unchanged");
 			fs.mkdirSync(runDir, { recursive: true });
-			const writeStatus = (lastUpdate: number, toolCount?: number) => fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
+			const writeStatus = (lastUpdate: number, toolCount?: number, state = "running") => fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
 				runId: "run-unchanged",
 				mode: "single",
-				state: "running",
+				state,
 				startedAt: 1000,
 				lastUpdate,
 				...(toolCount !== undefined ? { toolCount } : {}),
-				steps: [{ agent: "builder", status: "running", startedAt: 1000 }],
+				steps: [{ agent: "worker", status: state === "running" ? "running" : "complete", startedAt: 1000 }],
 			}), "utf-8");
 			writeStatus(2000);
 
 			const state = createState();
 			const ui = createUiContext();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 			});
 			tracker.resetJobs(ui.ctx as never);
-			tracker.handleStarted({ id: "run-unchanged", asyncDir: runDir, agent: "builder" });
+			tracker.handleStarted({ id: "run-unchanged", asyncDir: runDir, agent: "worker" });
 
 			const requestsAfterStart = ui.renderRequests;
-			await new Promise((resolve) => setTimeout(resolve, 35));
+			await waitForCondition(() => state.asyncJobs.get("run-unchanged")?.updatedAt === 2000, "first status load");
 			assert.ok(ui.renderRequests > requestsAfterStart, "first status load should redraw the widget");
 
 			const requestsAfterStatusLoaded = ui.renderRequests;
+			const widgetsAfterStatusLoaded = ui.widgets.length;
 			fs.writeFileSync(path.join(runDir, "events.jsonl"), `${JSON.stringify({
 				type: "subagent.control",
 				channels: ["event"],
@@ -552,18 +702,25 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 					to: "needs_attention",
 					ts: 123,
 					runId: "run-unchanged",
-					agent: "builder",
-					message: "builder needs attention",
+					agent: "worker",
+					message: "worker needs attention",
 				},
 			})}\n`, "utf-8");
-			await new Promise((resolve) => setTimeout(resolve, 40));
-			assert.equal(recorder.events.some((event) => event.channel === "subagent:control-event"), true);
-			assert.equal(ui.renderRequests, requestsAfterStatusLoaded, "unchanged status and control cursors should not request widget redraws");
+			await waitForCondition(() => recorder.events.some((event) => event.channel === "subagent:control-event"), "control event delivery");
+			await waitForCondition(() => ui.renderRequests > requestsAfterStatusLoaded, "running widget cadence repaint");
+			assert.equal(ui.widgets.length, widgetsAfterStatusLoaded, "unchanged running status must not replace the widget component");
 
 			writeStatus(3000, 1);
-			await new Promise((resolve) => setTimeout(resolve, 40));
-			assert.ok(ui.renderRequests > requestsAfterStatusLoaded, "changed non-terminal status should redraw the widget");
+			await waitForCondition(() => state.asyncJobs.get("run-unchanged")?.toolCount === 1, "changed status load");
+			assert.ok(ui.widgets.length > widgetsAfterStatusLoaded, "changed status should replace the widget component");
+
+			writeStatus(4000, 1, "complete");
+			await waitForCondition(() => state.asyncJobs.get("run-unchanged")?.status === "complete", "terminal status load");
+			const requestsAfterTerminal = ui.renderRequests;
+			await new Promise((resolve) => setTimeout(resolve, 35));
+			assert.equal(ui.renderRequests, requestsAfterTerminal, "terminal-only jobs must not request cadence repaints");
 		} finally {
+			tracker?.resetJobs();
 			removeTempDir(asyncRoot);
 		}
 	});
@@ -579,18 +736,18 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				state: "complete",
 				startedAt: Date.now() - 1000,
 				lastUpdate: Date.now(),
-				steps: [{ agent: "builder", status: "complete" }],
+				steps: [{ agent: "worker", status: "complete" }],
 			}), "utf-8");
 
 			const state = createState();
 			const ui = createUiContext();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				completionRetentionMs: 5,
 				pollIntervalMs: 10,
 			});
 			tracker.resetJobs(ui.ctx as never);
-			tracker.handleStarted({ id: "run-2", asyncDir: runDir, agent: "builder" });
+			tracker.handleStarted({ id: "run-2", asyncDir: runDir, agent: "worker" });
 
 			await new Promise((resolve) => setTimeout(resolve, 80));
 
@@ -602,6 +759,35 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 		}
 	});
 
+	it("watches run directories created after the start event", async () => {
+		const asyncRoot = createTempDir("pi-async-job-late-dir-");
+		try {
+			const runDir = path.join(asyncRoot, "run-late-dir");
+			const state = createState();
+			const tracker = createTracker(createEventRecorder().pi, state as never, asyncRoot, {
+				completionRetentionMs: 5,
+				pollIntervalMs: 60_000,
+			});
+			tracker.handleStarted({ id: "run-late-dir", asyncDir: runDir, agent: "worker" });
+			await waitForCondition(() => state.asyncJobs.get("run-late-dir")?.status === "running", "initial event refresh");
+
+			fs.mkdirSync(runDir, { recursive: true });
+			fs.writeFileSync(path.join(runDir, "status.json"), JSON.stringify({
+				runId: "run-late-dir",
+				mode: "single",
+				state: "complete",
+				startedAt: Date.now() - 1000,
+				lastUpdate: Date.now(),
+				steps: [{ agent: "worker", status: "complete" }],
+			}), "utf-8");
+
+			await waitForCondition(() => !state.asyncJobs.has("run-late-dir"), "evented terminal cleanup");
+			tracker.resetJobs();
+		} finally {
+			removeTempDir(asyncRoot);
+		}
+	});
+
 	it("repairs stale running jobs during polling", async () => {
 		const asyncRoot = createTempDir("pi-async-job-stale-");
 		try {
@@ -615,13 +801,13 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				pid: 12345,
 				startedAt: Date.now() - 1000,
 				lastUpdate: Date.now() - 1000,
-				steps: [{ agent: "builder", status: "running", startedAt: Date.now() - 1000 }],
+				steps: [{ agent: "worker", status: "running", startedAt: Date.now() - 1000 }],
 			}), "utf-8");
 
 			const state = createState();
 			const ui = createUiContext();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				completionRetentionMs: 5,
 				pollIntervalMs: 10,
 				resultsDir,
@@ -629,7 +815,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				now: () => Date.now(),
 			});
 			tracker.resetJobs(ui.ctx as never);
-			tracker.handleStarted({ id: "run-stale", asyncDir: runDir, agent: "builder" });
+			tracker.handleStarted({ id: "run-stale", asyncDir: runDir, agent: "worker" });
 
 			await waitForCondition(() => state.asyncJobs.size === 0, "stale async job cleanup");
 
@@ -650,7 +836,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			const state = createState();
 			const ui = createUiContext();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				completionRetentionMs: 5,
 				pollIntervalMs: 10,
 				resultsDir,
@@ -664,7 +850,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				pid: 12345,
 				sessionId: "session-current",
 				mode: "parallel",
-				agents: ["explorer", "commentator", "builder"],
+				agents: ["scout", "reviewer", "worker"],
 				chainStepCount: 1,
 				parallelGroups: [{ start: 0, count: 3, stepIndex: 0 }],
 			});
@@ -681,9 +867,9 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			assert.equal(status.chainStepCount, 1);
 			assert.deepEqual(status.parallelGroups, [{ start: 0, count: 3, stepIndex: 0 }]);
 			assert.deepEqual(status.steps.map((step: { agent: string; status: string }) => [step.agent, step.status]), [
-				["explorer", "failed"],
-				["commentator", "failed"],
-				["builder", "failed"],
+				["scout", "failed"],
+				["reviewer", "failed"],
+				["worker", "failed"],
 			]);
 			assert.equal(result.success, false);
 			assert.equal(result.sessionId, "session-current");
@@ -702,12 +888,12 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			const state = createState();
 			const ui = createUiContext();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				completionRetentionMs: 5,
 				pollIntervalMs: 10,
 			});
 			tracker.resetJobs(ui.ctx as never);
-			tracker.handleStarted({ id: "run-bad-status", asyncDir: runDir, agent: "builder" });
+			tracker.handleStarted({ id: "run-bad-status", asyncDir: runDir, agent: "worker" });
 
 			await new Promise((resolve) => setTimeout(resolve, 80));
 
@@ -729,11 +915,11 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			fs.writeFileSync(path.join(runDir, "status.json"), "{", "utf-8");
 			const state = createState();
 			const recorder = createEventRecorder();
-			tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				completionRetentionMs: 5,
 				pollIntervalMs: 10,
 			});
-			tracker.handleStarted({ id: "run-bad-status-nested", asyncDir: runDir, agent: "builder" });
+			tracker.handleStarted({ id: "run-bad-status-nested", asyncDir: runDir, agent: "worker" });
 			const job = state.asyncJobs.get("run-bad-status-nested");
 			assert.ok(job);
 			job.nestedChildren = [{
@@ -742,7 +928,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				depth: 1,
 				path: [{ runId: "run-bad-status-nested" }],
 				state: "running",
-				agent: "nested-builder",
+				agent: "nested-worker",
 			}];
 
 			await new Promise((resolve) => setTimeout(resolve, 80));
@@ -771,19 +957,19 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				state: "running",
 				startedAt: Date.now() - 1000,
 				lastUpdate: Date.now(),
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			}), "utf-8");
 
 			const state = createState();
 			const recorder = createEventRecorder();
-			tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				completionRetentionMs: 5,
 				pollIntervalMs: 10,
 			});
 			tracker.handleStarted({
 				id: "run-nested-refresh",
 				asyncDir: runDir,
-				agent: "builder",
+				agent: "worker",
 				nestedRoute: {
 					rootRunId: "run-nested-refresh",
 					eventSink: path.join(asyncRoot, "not-contained-events"),
@@ -811,11 +997,11 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 			fs.mkdirSync(runDir, { recursive: true });
 			const state = createState();
 			const recorder = createEventRecorder();
-			tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				completionRetentionMs: 1_000,
 				pollIntervalMs: 10,
 			});
-			tracker.handleStarted({ id: "run-recovered", asyncDir: runDir, agent: "builder" });
+			tracker.handleStarted({ id: "run-recovered", asyncDir: runDir, agent: "worker" });
 			tracker.handleComplete({ id: "run-recovered", success: true });
 			assert.equal(state.cleanupTimers.has("run-recovered"), true);
 
@@ -825,7 +1011,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				state: "running",
 				startedAt: Date.now() - 1000,
 				lastUpdate: Date.now(),
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			}), "utf-8");
 
 			const deadline = Date.now() + 200;
@@ -852,7 +1038,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				state: "running",
 				startedAt: Date.now() - 1000,
 				lastUpdate: Date.now(),
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			}), "utf-8");
 			const eventPath = path.join(runDir, "events.jsonl");
 			const partialRecord = JSON.stringify({
@@ -863,18 +1049,18 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 					to: "needs_attention",
 					ts: 123,
 					runId: "run-partial",
-					agent: "builder",
-					message: "builder needs attention",
+					agent: "worker",
+					message: "worker needs attention",
 				},
 			});
 			fs.writeFileSync(eventPath, partialRecord, "utf-8");
 
 			const state = createState();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 			});
-			tracker.handleStarted({ id: "run-partial", asyncDir: runDir, agent: "builder" });
+			tracker.handleStarted({ id: "run-partial", asyncDir: runDir, agent: "worker" });
 
 			await new Promise((resolve) => setTimeout(resolve, 30));
 			assert.equal(recorder.events.length, 0);
@@ -900,7 +1086,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				state: "running",
 				startedAt: Date.now() - 1000,
 				lastUpdate: Date.now(),
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			}), "utf-8");
 			const largeDiagnostic = JSON.stringify({
 				type: "message_update",
@@ -914,8 +1100,8 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 					to: "needs_attention",
 					ts: 123,
 					runId: "run-chunked-control",
-					agent: "builder",
-					message: "builder needs attention",
+					agent: "worker",
+					message: "worker needs attention",
 				},
 			});
 			fs.writeFileSync(path.join(runDir, "events.jsonl"), `${largeDiagnostic}\n${controlEvent}\n`, "utf-8");
@@ -927,10 +1113,10 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 
 			const state = createState();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 			});
-			tracker.handleStarted({ id: "run-chunked-control", asyncDir: runDir, agent: "builder" });
+			tracker.handleStarted({ id: "run-chunked-control", asyncDir: runDir, agent: "worker" });
 
 			await waitForCondition(
 				() => recorder.events.some((event) => event.channel === "subagent:control-event"),
@@ -960,7 +1146,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				state: "running",
 				startedAt: Date.now() - 1000,
 				lastUpdate: Date.now(),
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			}), "utf-8");
 			const largeDiagnostic = JSON.stringify({
 				type: "message_update",
@@ -974,8 +1160,8 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 					to: "needs_attention",
 					ts: 123,
 					runId: "run-midline-oversized-control",
-					agent: "builder",
-					message: "builder needs attention",
+					agent: "worker",
+					message: "worker needs attention",
 				},
 			});
 			fs.writeFileSync(path.join(runDir, "events.jsonl"), `${largeDiagnostic}\n${controlEvent}\n`, "utf-8");
@@ -985,13 +1171,13 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				asyncId: "run-midline-oversized-control",
 				asyncDir: runDir,
 				status: "running",
-				agents: ["builder"],
+				agents: ["worker"],
 				startedAt: Date.now() - 1000,
 				updatedAt: Date.now(),
 				controlEventCursor: 0,
 			});
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 			});
 			tracker.ensurePoller();
@@ -1018,7 +1204,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				state: "running",
 				startedAt: Date.now() - 1000,
 				lastUpdate: Date.now(),
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			}), "utf-8");
 			const controlEvent = JSON.stringify({
 				type: "subagent.control",
@@ -1028,8 +1214,8 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 					to: "needs_attention",
 					ts: 123,
 					runId: "run-new-large-control",
-					agent: "builder",
-					message: "builder needs attention",
+					agent: "worker",
+					message: "worker needs attention",
 				},
 			});
 			const diagnosticLine = JSON.stringify({
@@ -1042,10 +1228,10 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 
 			const state = createState();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 			});
-			tracker.handleStarted({ id: "run-new-large-control", asyncDir: runDir, agent: "builder" });
+			tracker.handleStarted({ id: "run-new-large-control", asyncDir: runDir, agent: "worker" });
 
 			await waitForCondition(
 				() => recorder.events.some((event) => event.channel === "subagent:control-event"),
@@ -1071,7 +1257,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				state: "running",
 				startedAt: Date.now() - 1000,
 				lastUpdate: Date.now(),
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			}), "utf-8");
 			const diagnosticLine = JSON.stringify({
 				type: "message_update",
@@ -1085,8 +1271,8 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 					to: "needs_attention",
 					ts: 123,
 					runId: "run-large-legacy-control",
-					agent: "builder",
-					message: "builder needs attention",
+					agent: "worker",
+					message: "worker needs attention",
 				},
 			});
 			const eventsPath = path.join(runDir, "events.jsonl");
@@ -1104,12 +1290,12 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				asyncId: "run-large-legacy-control",
 				asyncDir: runDir,
 				status: "running",
-				agents: ["builder"],
+				agents: ["worker"],
 				startedAt: Date.now() - 1000,
 				updatedAt: Date.now(),
 			});
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 			});
 			tracker.ensurePoller();
@@ -1144,15 +1330,15 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				currentTool: "edit",
 				currentToolStartedAt: Date.now() - 100,
 				currentPath: "src/runs/background/subagent-runner.ts",
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			}), "utf-8");
 
 			const state = createState();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 			});
-			tracker.handleStarted({ id: "run-clear-tool", asyncDir: runDir, agent: "builder" });
+			tracker.handleStarted({ id: "run-clear-tool", asyncDir: runDir, agent: "worker" });
 
 			await new Promise((resolve) => setTimeout(resolve, 30));
 			let job = state.asyncJobs.get("run-clear-tool");
@@ -1165,7 +1351,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				state: "running",
 				startedAt: Date.now() - 1000,
 				lastUpdate: Date.now(),
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			}), "utf-8");
 
 			await new Promise((resolve) => setTimeout(resolve, 30));
@@ -1189,7 +1375,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				state: "running",
 				startedAt: Date.now() - 1000,
 				lastUpdate: Date.now(),
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			}), "utf-8");
 			fs.writeFileSync(path.join(runDir, "events.jsonl"), `${JSON.stringify({
 				type: "subagent.control",
@@ -1199,18 +1385,18 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 					to: "needs_attention",
 					ts: 123,
 					runId: "run-channels",
-					agent: "builder",
-					message: "builder needs attention",
+					agent: "worker",
+					message: "worker needs attention",
 				},
-				intercom: { to: "main", message: "SUBAGENT NEEDS ATTENTION: builder in run run-channels." },
+				intercom: { to: "main", message: "SUBAGENT NEEDS ATTENTION: worker in run run-channels." },
 			})}\n`, "utf-8");
 
 			const state = createState();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 			});
-			tracker.handleStarted({ id: "run-channels", asyncDir: runDir, agent: "builder" });
+			tracker.handleStarted({ id: "run-channels", asyncDir: runDir, agent: "worker" });
 
 			await new Promise((resolve) => setTimeout(resolve, 30));
 			assert.equal(recorder.events.some((event) => event.channel === "subagent:control-event"), false);
@@ -1231,7 +1417,7 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				state: "running",
 				startedAt: Date.now() - 1000,
 				lastUpdate: Date.now(),
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			}), "utf-8");
 			fs.writeFileSync(path.join(runDir, "events.jsonl"), `${JSON.stringify({
 				type: "subagent.control",
@@ -1241,18 +1427,18 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 					to: "active_long_running",
 					ts: 123,
 					runId: "run-active-intercom",
-					agent: "builder",
-					message: "builder is still active but long-running",
+					agent: "worker",
+					message: "worker is still active but long-running",
 				},
 				intercom: { to: "main", message: "stale active notice" },
 			})}\n`, "utf-8");
 
 			const state = createState();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 			});
-			tracker.handleStarted({ id: "run-active-intercom", asyncDir: runDir, agent: "builder" });
+			tracker.handleStarted({ id: "run-active-intercom", asyncDir: runDir, agent: "worker" });
 
 			await new Promise((resolve) => setTimeout(resolve, 30));
 			assert.equal(recorder.events.some((event) => event.channel === "subagent:control-event"), true);
@@ -1273,36 +1459,36 @@ describe("async job tracker", { skip: !available ? "pi packages not available" :
 				state: "running",
 				startedAt: Date.now() - 1000,
 				lastUpdate: Date.now(),
-				steps: [{ agent: "builder", status: "running" }],
+				steps: [{ agent: "worker", status: "running" }],
 			}), "utf-8");
 			fs.writeFileSync(path.join(runDir, "events.jsonl"), `${JSON.stringify({
 				type: "subagent.control",
 				channels: ["event", "intercom"],
-				childIntercomTarget: "subagent-builder-run-3-1",
-				noticeText: "Subagent needs attention: builder\nNudge: intercom({ action: \"send\", to: \"subagent-builder-run-3-1\", message: \"<message>\" })",
+				childIntercomTarget: "subagent-worker-run-3-1",
+				noticeText: "Subagent needs attention: worker\nNudge: intercom({ action: \"send\", to: \"subagent-worker-run-3-1\", message: \"<message>\" })",
 				event: {
 					type: "needs_attention",
 					to: "needs_attention",
 					ts: 123,
 					runId: "run-3",
-					agent: "builder",
-					message: "builder needs attention",
+					agent: "worker",
+					message: "worker needs attention",
 				},
-				intercom: { to: "main", message: "SUBAGENT NEEDS ATTENTION: builder in run run-3." },
+				intercom: { to: "main", message: "SUBAGENT NEEDS ATTENTION: worker in run run-3." },
 			})}\n`, "utf-8");
 
 			const state = createState();
 			const recorder = createEventRecorder();
-			const tracker = trackerMod!.createAsyncJobTracker(recorder.pi, state as never, asyncRoot, {
+			const tracker = createTracker(recorder.pi, state as never, asyncRoot, {
 				pollIntervalMs: 10,
 			});
-			tracker.handleStarted({ id: "run-3", asyncDir: runDir, agent: "builder" });
+			tracker.handleStarted({ id: "run-3", asyncDir: runDir, agent: "worker" });
 
 			await new Promise((resolve) => setTimeout(resolve, 40));
 
 			const controlEvent = recorder.events.find((event) => event.channel === "subagent:control-event");
 			assert.ok(controlEvent);
-			assert.match((controlEvent.data as { noticeText?: string }).noticeText ?? "", /subagent-builder-run-3-1/);
+			assert.match((controlEvent.data as { noticeText?: string }).noticeText ?? "", /subagent-worker-run-3-1/);
 			assert.equal(recorder.events.some((event) => event.channel === "subagent:control-intercom"), true);
 		} finally {
 			removeTempDir(asyncRoot);