@selesai/code 0.8.3 → 0.8.5

package/dist/extensions/pi-subagents/test/unit/tool-description.test.ts

@@ -28,29 +28,42 @@ function parentToolEnv(agentDir?: string): NodeJS.ProcessEnv {
 }
 
 describe("registered subagent tool description", () => {
-	it("describes workflowScript as the sole public orchestration surface", () => {
+	it("describes the four first-class execution modes", () => {
 		const description = buildSubagentToolDescription();
-		assert.match(description, /^Delegate one child with \{ agent, task \} or compose work with \{ workflowScript \}/i);
-		assert.match(description, /workflowScript is the sole public orchestration surface/i);
+		assert.match(description, /^Delegate one child with \{ agent, task \}/i);
+		assert.match(description, /SINGLE: \{ agent, task\? \}/i);
+		assert.match(description, /CHAIN: \{ chain: \[\{ agent: "explorer"/i);
+		assert.match(description, /PARALLEL: \{ tasks:/i);
 		assert.match(description, /runs\.run for one child and runs\.all for parallel children/i);
-		assert.match(description, /repository mutation lanes.*worktree:true.*direct single child.*runs\.run\/runs\.all.*managed isolation.*manual Git worktrees/i);
-		assert.match(description, /Sequential replacement/i);
-		assert.match(description, /Parallel replacement/i);
-		assert.doesNotMatch(description, /Compatibility tasks\[\]|CHAIN EXAMPLES|PARALLEL \(compatibility\)/i);
-		assert.match(description, /append-step.*step:/i);
+		assert.match(description, /repository mutation lanes.*worktree:true.*runs\.run\/runs\.all.*managed isolation/i);
+		assert.match(description, /ordinary JavaScript statement body.*explicit return/i);
+		assert.match(description, /Sequential example/i);
+		assert.match(description, /Parallel example/i);
+		assert.match(description, /append-step/i);
+		assert.match(description, /approve-checkpoint and reject-checkpoint/i);
 		assert.match(description, /cannot access filesystem, shell, arbitrary Pi tools, or host globals/i);
+		assert.match(description, /exactly one non-empty title or summary/i);
+		assert.match(description, /goal may only be true and requires budget:\{tokens\}/i);
 		assert.match(description, /SAFETY-CRITICAL SUBAGENT GUIDANCE/);
 		assert.match(description, /status\.json/);
 	});
 
+	it("includes legacy chain-control guidance when enabled", () => {
+		const description = buildSubagentToolDescription({ legacyChainControls: true });
+		assert.match(description, /append-step.*step:/i);
+		assert.match(description, /approve-checkpoint|reject-checkpoint/);
+	});
+
 	it("offers a compact mode that keeps the cutover and safety guidance", () => {
-		const description = buildSubagentToolDescription({ toolDescriptionMode: "compact" });
+		const description = buildSubagentToolDescription({ toolDescriptionMode: "compact", legacyChainControls: true });
 		assert.equal(description, COMPACT_SUBAGENT_TOOL_DESCRIPTION);
-		assert.match(description, /workflowScript is the sole public orchestration surface/i);
+		assert.match(description, /^Delegate one child with \{ agent, task \}/i);
 		assert.match(description, /runs\.run for one child and runs\.all for parallel work/i);
-		assert.match(description, /repository mutation lanes.*worktree:true.*direct single child.*runs\.run\/runs\.all.*managed isolation.*manual Git worktrees/i);
-		assert.doesNotMatch(description, /tasks\[\]|chain\[\]/i);
+		assert.match(description, /repository mutation lanes.*worktree:true.*runs\.run\/runs\.all.*managed isolation/i);
+		assert.match(description, /SINGLE \{agent, task\?\}|CHAIN \{chain:/i);
 		assert.match(description, /subagent_wait/i);
+		assert.match(description, /exactly one non-empty title or summary/i);
+		assert.match(description, /goal may only be true and requires budget:\{tokens\}/i);
 		assert.ok(description.length < FULL_SUBAGENT_TOOL_DESCRIPTION.length);
 	});
 
@@ -114,13 +127,33 @@ describe("registered subagent tool description", () => {
 		assert.match(description, /ordinary child subagents are not orchestrators/i);
 	});
 
+	it("preserves custom guidance while trimming built-in legacy chain guidance", () => {
+		const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-legacy-note-"));
+		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-agent-"));
+		fs.mkdirSync(path.join(cwd, ".selesai"), { recursive: true });
+		fs.writeFileSync(
+			path.join(cwd, ".selesai", "subagent-tool-description.md"),
+			[
+				"Custom migration note: append-step, approve-checkpoint, and reject-checkpoint appear here as audit context.",
+				"{{fullDescription}}",
+			].join("\n\n"),
+			"utf-8",
+		);
+
+		const description = buildSubagentToolDescription({ toolDescriptionMode: "custom" }, { cwd, agentDir });
+
+		assert.match(description, /Custom migration note: append-step, approve-checkpoint, and reject-checkpoint/);
+		assert.doesNotMatch(description, /appends one step to an already-running durable legacy chain/);
+		assert.doesNotMatch(description, /decide a paused durable legacy chain checkpoint/);
+	});
+
 	it("falls back to full mode when custom mode has no valid file", () => {
 		const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-missing-"));
 		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-agent-"));
 		const warnings: string[] = [];
 
 		const description = buildSubagentToolDescription(
-			{ toolDescriptionMode: "custom" },
+			{ toolDescriptionMode: "custom", legacyChainControls: true },
 			{ cwd, agentDir, warn: (message) => warnings.push(message) },
 		);
 
@@ -132,7 +165,7 @@ describe("registered subagent tool description", () => {
 		const warnings: string[] = [];
 
 		const description = buildSubagentToolDescription(
-			{ toolDescriptionMode: "tiny" } as never,
+			{ toolDescriptionMode: "tiny", legacyChainControls: true } as never,
 			{ warn: (message) => warnings.push(message) },
 		);
 
@@ -140,7 +173,7 @@ describe("registered subagent tool description", () => {
 		assert.ok(warnings.some((message) => message.includes("Ignoring invalid toolDescriptionMode")));
 	});
 
-	function readRegisteredDescription(agentDir: string): string {
+	function readRegisteredTool(agentDir: string): { description: string; properties: string[] } {
 		const script = String.raw`
 			import registerSubagentExtension from "./src/extension/index.ts";
 			const events = { on() { return () => {}; }, emit() {} };
@@ -161,7 +194,7 @@ describe("registered subagent tool description", () => {
 			});
 			registerSubagentExtension(fakePi);
 			if (!registeredTool) throw new Error("tool not registered");
-			process.stdout.write(JSON.stringify(registeredTool.description));
+			process.stdout.write(JSON.stringify({ description: registeredTool.description, properties: Object.keys(registeredTool.parameters.properties) }));
 		`;
 		const output = execFileSync(
 			process.execPath,
@@ -175,7 +208,7 @@ describe("registered subagent tool description", () => {
 			],
 			{ cwd: projectRoot, env: parentToolEnv(agentDir), encoding: "utf-8" },
 		);
-		return JSON.parse(output) as string;
+		return JSON.parse(output) as { description: string; properties: string[] };
 	}
 
 	function writeExtensionConfig(agentDir: string, config: Record<string, unknown>): void {
@@ -186,25 +219,43 @@ describe("registered subagent tool description", () => {
 
 	it("registers full, compact, custom, and fallback descriptions from extension config", () => {
 		const defaultAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-default-"));
-		assert.equal(readRegisteredDescription(defaultAgentDir), FULL_SUBAGENT_TOOL_DESCRIPTION);
+		writeExtensionConfig(defaultAgentDir, { legacyChainControls: true });
+		assert.equal(readRegisteredTool(defaultAgentDir).description, FULL_SUBAGENT_TOOL_DESCRIPTION);
 
 		const compactAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-compact-"));
-		writeExtensionConfig(compactAgentDir, { toolDescriptionMode: "compact" });
-		assert.equal(readRegisteredDescription(compactAgentDir), COMPACT_SUBAGENT_TOOL_DESCRIPTION);
+		writeExtensionConfig(compactAgentDir, { toolDescriptionMode: "compact", legacyChainControls: true });
+		assert.equal(readRegisteredTool(compactAgentDir).description, COMPACT_SUBAGENT_TOOL_DESCRIPTION);
 
 		const customAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-custom-"));
 		writeExtensionConfig(customAgentDir, { toolDescriptionMode: "custom" });
 		fs.writeFileSync(path.join(customAgentDir, "subagent-tool-description.md"), "Registered custom description.", "utf-8");
-		const customDescription = readRegisteredDescription(customAgentDir);
+		const customDescription = readRegisteredTool(customAgentDir).description;
 		assert.match(customDescription, /Registered custom description/);
 		assert.match(customDescription, /SAFETY-CRITICAL SUBAGENT GUIDANCE/);
 
 		const missingCustomAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-missing-"));
-		writeExtensionConfig(missingCustomAgentDir, { toolDescriptionMode: "custom" });
-		assert.equal(readRegisteredDescription(missingCustomAgentDir), FULL_SUBAGENT_TOOL_DESCRIPTION);
+		writeExtensionConfig(missingCustomAgentDir, { toolDescriptionMode: "custom", legacyChainControls: true });
+		assert.equal(readRegisteredTool(missingCustomAgentDir).description, FULL_SUBAGENT_TOOL_DESCRIPTION);
 
 		const invalidAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-invalid-"));
-		writeExtensionConfig(invalidAgentDir, { toolDescriptionMode: "tiny" });
-		assert.equal(readRegisteredDescription(invalidAgentDir), FULL_SUBAGENT_TOOL_DESCRIPTION);
+		writeExtensionConfig(invalidAgentDir, { toolDescriptionMode: "tiny", legacyChainControls: true });
+		assert.equal(readRegisteredTool(invalidAgentDir).description, FULL_SUBAGENT_TOOL_DESCRIPTION);
+	});
+
+	it("registers the full schema and first-class chain description by default", () => {
+		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-trimmed-"));
+		const tool = readRegisteredTool(agentDir);
+		assert.equal(tool.properties.includes("step"), true);
+		assert.equal(tool.properties.includes("chain"), true);
+		assert.equal(tool.properties.includes("tasks"), true);
+		assert.match(tool.description, /CHAIN: \{ chain:/i);
+	});
+
+	it("registers the trimmed schema and description when legacyChainControls is false", () => {
+		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-legacy-"));
+		writeExtensionConfig(agentDir, { legacyChainControls: false });
+		const tool = readRegisteredTool(agentDir);
+		assert.equal(tool.properties.includes("step"), false);
+		assert.doesNotMatch(tool.description, /append-step/i);
 	});
 });

package/dist/extensions/pi-subagents/test/unit/turn-budget.test.ts

@@ -50,13 +50,13 @@ describe("turn-budget module", () => {
 
 	describe("appendTurnBudgetSystemPrompt", () => {
 		it("returns the system prompt unchanged when no budget is configured", () => {
-			assert.equal(appendTurnBudgetSystemPrompt("You are a commentator.", undefined), "You are a commentator.");
+			assert.equal(appendTurnBudgetSystemPrompt("You are a reviewer.", undefined), "You are a reviewer.");
 			assert.equal(appendTurnBudgetSystemPrompt("", undefined), "");
 		});
 
 		it("appends a turn-budget block after an existing system prompt", () => {
-			const result = appendTurnBudgetSystemPrompt("You are a commentator.", budget({ maxTurns: 5, graceTurns: 2 }));
-			assert.ok(result.startsWith("You are a commentator.\n\n## Turn budget\n"), result);
+			const result = appendTurnBudgetSystemPrompt("You are a reviewer.", budget({ maxTurns: 5, graceTurns: 2 }));
+			assert.ok(result.startsWith("You are a reviewer.\n\n## Turn budget\n"), result);
 			assert.match(result, /soft budget of 5 assistant turns/);
 			assert.match(result, /2 additional assistant turns/);
 		});
@@ -68,8 +68,8 @@ describe("turn-budget module", () => {
 		});
 
 		it("trims surrounding whitespace from the existing system prompt before joining", () => {
-			const result = appendTurnBudgetSystemPrompt("\nYou are a commentator.\n\n", budget());
-			assert.ok(result.startsWith("You are a commentator.\n\n## Turn budget\n"), result);
+			const result = appendTurnBudgetSystemPrompt("\nYou are a reviewer.\n\n", budget());
+			assert.ok(result.startsWith("You are a reviewer.\n\n## Turn budget\n"), result);
 			assert.equal(result.startsWith("\n"), false);
 		});
 

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

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

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

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

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

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

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

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

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

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

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

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