@selesai/code 0.13.12 → 0.13.14

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

@@ -17,7 +17,6 @@ describe("watchdog warning formatting and rendering", () => {
 			agent: "main",
 			runId: "run-1",
 			stale: true,
-			autoFollowAttempt: 2,
 		});
 
 		assert.match(content, /^<subagent_watchdog severity="blocker" category="correctness" source="main" guidance="weigh, don't blindly obey">/);
@@ -28,7 +27,7 @@ describe("watchdog warning formatting and rendering", () => {
 		assert.match(content, /<agent>main<\/agent>/);
 		assert.match(content, /<run_id>run-1<\/run_id>/);
 		assert.match(content, /<stale>true<\/stale>/);
-		assert.match(content, /<auto_follow_attempt>2<\/auto_follow_attempt>/);
+		assert.doesNotMatch(content, /auto_follow/);
 		assert.match(content, /<blocker_guidance>/);
 	});
 
@@ -54,8 +53,8 @@ describe("watchdog warning formatting and rendering", () => {
 			category: "loop-risk",
 			source: "main",
 			summary: "Repeated blocker",
-			evidence: "The same issue survived another auto-follow.",
-			recommendedAction: "Stop auto-follow and ask for user review.",
+			evidence: "The same issue survived another continuation.",
+			recommendedAction: "Ask for user review.",
 			state: "stalemate",
 			stalemateRepeats: 3,
 		};
@@ -65,10 +64,10 @@ describe("watchdog warning formatting and rendering", () => {
 		const failed = formatWatchdogWarningRenderText({ ...base, state: "failed", error: "provider aborted" });
 		const displayed = formatWatchdogWarningRenderText({ ...base, state: "displayed" });
 
-		assert.match(stalemate, /Subagent watchdog Blocker \(stalemate · auto-follow stopped\): Repeated blocker/);
-		assert.match(stalemate, /Auto-follow stopped after 3 repeated blocker warnings\./);
-		assert.match(stale, /Subagent watchdog Concern \(stale · no auto-follow\): Repeated blocker/);
-		assert.match(stale, /must not auto-follow/);
+		assert.match(stalemate, /Subagent watchdog Blocker \(stalemate\): Repeated blocker/);
+		assert.match(stalemate, /Same warning 3 times in a row; the watchdog stopped continuing the run\./);
+		assert.match(stale, /Subagent watchdog Concern \(stale\): Repeated blocker/);
+		assert.match(stale, /arrived after the watchdog catch-up timeout\./);
 		assert.match(failed, /failed review/);
 		assert.match(failed, /Failure: provider aborted/);
 		assert.match(displayed, /Subagent watchdog Blocker \(displayed\): Repeated blocker/);

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

@@ -1,6 +1,10 @@
 import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 import { describe, it } from "node:test";
 import type { StreamFn } from "@earendil-works/pi-agent-core";
+import { WATCHDOG_GUIDANCE_MAX_CHARS } from "../../src/watchdog/guidance.ts";
 import {
 	createAssistantMessageEventStream,
 	fauxAssistantMessage,
@@ -35,14 +39,11 @@ function cloneConfig(): ResolvedWatchdogConfig {
 	return {
 		...DEFAULT_WATCHDOG_CONFIG,
 		guidance: { ...DEFAULT_WATCHDOG_CONFIG.guidance },
-		autoFollow: { ...DEFAULT_WATCHDOG_CONFIG.autoFollow },
 		main: { ...DEFAULT_WATCHDOG_CONFIG.main },
 		children: {
 			...DEFAULT_WATCHDOG_CONFIG.children,
-			autoFollow: { ...DEFAULT_WATCHDOG_CONFIG.children.autoFollow },
 			overrides: { ...DEFAULT_WATCHDOG_CONFIG.children.overrides },
 		},
-		asyncCompletion: { ...DEFAULT_WATCHDOG_CONFIG.asyncCompletion },
 		lsp: { ...DEFAULT_WATCHDOG_CONFIG.lsp },
 	};
 }
@@ -240,6 +241,50 @@ describe("main watchdog review adapter", () => {
 		assert.equal(result?.stopReason, "aborted");
 	});
 
+	it("includes WATCHDOG.md guidance in the system prompt", async () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "watchdog-review-guidance-"));
+		const originalAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+		try {
+			process.env.SELESAI_CODING_AGENT_DIR = path.join(dir, "agent");
+			fs.mkdirSync(path.join(dir, "project", ".selesai"), { recursive: true });
+			fs.writeFileSync(path.join(dir, "project", ".selesai", "WATCHDOG.md"), "Never accept skipped tests.\n", "utf-8");
+			fs.mkdirSync(path.join(dir, "agent"), { recursive: true });
+			fs.writeFileSync(path.join(dir, "agent", "WATCHDOG.md"), "u".repeat(WATCHDOG_GUIDANCE_MAX_CHARS), "utf-8");
+			const current = model("openai", "gpt-guidance");
+			const ctx = { ...(createCtx({ current }) as object), cwd: path.join(dir, "project") } as never;
+			const { streamFn, calls } = createStreamFn([fauxAssistantMessage("done", { stopReason: "stop" })]);
+
+			await createMainWatchdogReview(ctx, { streamFn })(request(enabledConfig(), []));
+			const prompt = String(calls[0]?.context.systemPrompt ?? "");
+			assert.match(prompt, /Standing instructions from WATCHDOG\.md \(project first, then user\):\nNever accept skipped tests\.\n\nu+$/);
+			assert.equal(prompt.split("(project first, then user):\n")[1]?.length, WATCHDOG_GUIDANCE_MAX_CHARS, "combined guidance is capped from the head");
+
+			const disabled = enabledConfig();
+			disabled.guidance = { watchdogMd: false };
+			const second = createStreamFn([fauxAssistantMessage("done", { stopReason: "stop" })]);
+			await createMainWatchdogReview(ctx, { streamFn: second.streamFn })(request(disabled, []));
+			assert.doesNotMatch(String(second.calls[0]?.context.systemPrompt ?? ""), /Standing instructions/);
+		} finally {
+			if (originalAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+			else process.env.SELESAI_CODING_AGENT_DIR = originalAgentDir;
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
+	it("offers watchdog_diff only when a repo baseline is available", async () => {
+		const current = model("openai", "gpt-diff");
+		const ctx = createCtx({ current });
+		const withBaseline = createStreamFn([fauxAssistantMessage("done", { stopReason: "stop" })]);
+		await createMainWatchdogReview(ctx, { streamFn: withBaseline.streamFn, diffBaseline: () => ({ root: "/tmp/watchdog-review", ref: "abc123" }) })(request(enabledConfig(), []));
+		assert.deepEqual(withBaseline.calls[0]?.context.tools?.map((tool) => tool.name).sort(), ["find", "grep", "ls", "read", "watchdog_diff", "watchdog_warn"]);
+		assert.match(String(withBaseline.calls[0]?.context.systemPrompt ?? ""), /watchdog_diff/);
+
+		const without = createStreamFn([fauxAssistantMessage("done", { stopReason: "stop" })]);
+		await createMainWatchdogReview(ctx, { streamFn: without.streamFn, diffBaseline: () => undefined })(request(enabledConfig(), []));
+		assert.deepEqual(without.calls[0]?.context.tools?.map((tool) => tool.name).sort(), ["find", "grep", "ls", "read", "watchdog_warn"]);
+		assert.doesNotMatch(String(without.calls[0]?.context.systemPrompt ?? ""), /watchdog_diff/);
+	});
+
 	it("does not expose mutating tools to the watchdog agent", async () => {
 		const current = model("openai", "gpt-readonly");
 		const ctx = createCtx({ current });

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

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { evaluateLaunchRule, ruleViolationWarning, watchdogGlobMatch } from "../../src/watchdog/rules.ts";
+import type { WatchdogRulesConfig } from "../../src/watchdog/types.ts";
+
+describe("watchdog launch rules", () => {
+	it("matches globs anchored and case-sensitively", () => {
+		assert.equal(watchdogGlobMatch("openai-codex/gpt-5.6-*:max", "openai-codex/gpt-5.6-luna:max"), true);
+		assert.equal(watchdogGlobMatch("openai-codex/gpt-5.6-*", "openai-codex/gpt-5.6-luna:max"), true);
+		assert.equal(watchdogGlobMatch("gpt-5.6-*", "openai-codex/gpt-5.6-luna"), false, "patterns are anchored at the start");
+		assert.equal(watchdogGlobMatch("*", "anything/at-all"), true);
+		assert.equal(watchdogGlobMatch("anthropic/claude-opus-4.?", "anthropic/claude-opus-4.8"), true);
+		assert.equal(watchdogGlobMatch("anthropic/claude-opus-4.8", "anthropic/claude-opus-4x8"), false);
+		assert.equal(watchdogGlobMatch("Anthropic/*", "anthropic/claude"), false);
+	});
+
+	it("applies deny before allow, matches the base model when the suffix differs, and shapes a concern", () => {
+		const config: WatchdogRulesConfig = { action: "warn", roleModels: { scout: { allow: ["openai-codex/gpt-5.6-luna"], deny: ["openai-codex/gpt-5.6-sol*"], note: "scout is cheap" } } };
+		assert.equal(evaluateLaunchRule(config, "scout", "openai-codex/gpt-5.6-luna:max"), undefined);
+		const denied = evaluateLaunchRule(config, "scout", "openai-codex/gpt-5.6-sol:high");
+		assert.match(denied?.summary ?? "", /denied model 'openai-codex\/gpt-5\.6-sol:high'/);
+		assert.match(denied?.evidence ?? "", /scout is cheap/);
+		const outside = evaluateLaunchRule(config, "scout", "anthropic/claude-opus-4-8");
+		assert.match(outside?.summary ?? "", /not in its allowed list/);
+		assert.match(outside?.recommendedAction ?? "", /openai-codex\/gpt-5\.6-luna/);
+		assert.equal(evaluateLaunchRule(config, "worker", "anthropic/claude-opus-4-8"), undefined, "other roles are unaffected");
+		assert.equal(evaluateLaunchRule(config, "scout", undefined), undefined, "an unknown model cannot be judged");
+		assert.equal(evaluateLaunchRule(undefined, "scout", "x/y"), undefined);
+
+		const warning = ruleViolationWarning(denied!);
+		assert.equal(warning.severity, "concern");
+		assert.equal(warning.category, "missed-constraint");
+		assert.equal(warning.confidence, "high");
+		assert.equal(warning.source, "main");
+		assert.equal(warning.agent, "scout");
+	});
+});

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

@@ -6,22 +6,19 @@ import * as path from "node:path";
 import { describe, it } from "node:test";
 import { DEFAULT_WATCHDOG_CONFIG } from "../../src/watchdog/settings.ts";
 import { MainWatchdogRuntime, type WatchdogReviewFunction } from "../../src/watchdog/runtime.ts";
-import type { ResolvedWatchdogConfig, WatchdogLspResult, WatchdogSettingsResult, WatchdogWarning } from "../../src/watchdog/types.ts";
+import type { ResolvedWatchdogConfig, WatchdogLspResult, WatchdogSettingsResult, WatchdogWarning, WatchdogWarningDetails } from "../../src/watchdog/types.ts";
 
 function cloneConfig(): ResolvedWatchdogConfig {
 	return {
 		...DEFAULT_WATCHDOG_CONFIG,
 		guidance: { ...DEFAULT_WATCHDOG_CONFIG.guidance },
-		autoFollow: { ...DEFAULT_WATCHDOG_CONFIG.autoFollow },
 		scope: { ...DEFAULT_WATCHDOG_CONFIG.scope },
 		cadence: { ...DEFAULT_WATCHDOG_CONFIG.cadence },
 		main: { ...DEFAULT_WATCHDOG_CONFIG.main },
 		children: {
 			...DEFAULT_WATCHDOG_CONFIG.children,
-			autoFollow: { ...DEFAULT_WATCHDOG_CONFIG.children.autoFollow },
 			overrides: { ...DEFAULT_WATCHDOG_CONFIG.children.overrides },
 		},
-		asyncCompletion: { ...DEFAULT_WATCHDOG_CONFIG.asyncCompletion },
 		lsp: { ...DEFAULT_WATCHDOG_CONFIG.lsp },
 	};
 }
@@ -40,7 +37,6 @@ function enabledConfig(overrides: Partial<ResolvedWatchdogConfig> = {}): Resolve
 	if (overrides.lsp) config.lsp = { ...config.lsp, ...overrides.lsp };
 	if (overrides.scope) config.scope = { ...config.scope, ...overrides.scope };
 	if (overrides.cadence) config.cadence = { ...config.cadence, ...overrides.cadence };
-	if (overrides.autoFollow) config.autoFollow = { ...config.autoFollow, ...overrides.autoFollow };
 	return config;
 }
 
@@ -173,7 +169,6 @@ describe("main watchdog runtime", () => {
 		assert.equal(snapshot.lastWarning?.state, "displayed");
 		assert.equal(displayed.length, 1);
 		assert.equal((displayed[0] as { state?: string }).state, "displayed");
-		assert.equal(snapshot.autoFollowQueued, false);
 	});
 
 	it("drops stale async warning callbacks after reset", async () => {
@@ -205,7 +200,7 @@ describe("main watchdog runtime", () => {
 		assert.equal(snapshot.lastWarning, undefined);
 	});
 
-	it("treats failed review stop reasons as failed and never auto-follows", async () => {
+	it("treats failed review stop reasons as failed", async () => {
 		const runtime = new MainWatchdogRuntime({
 			resolveConfig: () => configResult(enabledConfig()),
 			review: () => ({ stopReason: "length" }),
@@ -218,7 +213,6 @@ describe("main watchdog runtime", () => {
 		assert.equal(snapshot.status, "failed");
 		assert.match(snapshot.lastError ?? "", /stop reason 'length'/);
 		assert.equal(snapshot.failedReviews, 1);
-		assert.equal(snapshot.autoFollowQueued, false);
 	});
 
 	it("marks unresolved agent-end review work stale on timeout", async () => {
@@ -240,7 +234,6 @@ describe("main watchdog runtime", () => {
 		const snapshot = runtime.getSnapshot();
 		assert.equal(snapshot.status, "stale");
 		assert.equal(snapshot.staleReviews, 1);
-		assert.equal(snapshot.autoFollowQueued, false);
 		runtime.reset("cleanup");
 	});
 
@@ -303,7 +296,6 @@ describe("main watchdog runtime", () => {
 		const snapshot = runtime.getSnapshot();
 		assert.equal(snapshot.status, "stale");
 		assert.equal(snapshot.lastWarning, undefined);
-		assert.equal(snapshot.autoFollowQueued, false);
 	});
 
 	it("invalidates an in-flight review when refreshed config disables the watchdog", async () => {
@@ -350,8 +342,9 @@ describe("main watchdog runtime", () => {
 		runtime.enqueueDelta(`Assistant:\n${"x".repeat(30_000)}`);
 		await runtime.handleAgentEnd({ type: "agent_end", messages: [] }, { cwd: "/tmp/project" });
 
-		assert.equal(reviewedDelta.length, 24_000);
-		assert.match(reviewedDelta, /^x+$/);
+		assert.equal(reviewedDelta.length, 24_000, "head + marker + tail fill the cap exactly");
+		assert.match(reviewedDelta, /^Assistant:\nx+\n\n\[\.\.\. about \d+ characters omitted \.\.\.\]\n\nx+$/);
+		assert.equal(reviewedDelta.indexOf("\n\n[..."), 6_000, "the first 6,000 characters are kept as the head");
 	});
 
 	it("does not record duplicate signatures for stale invalidated reviews", async () => {
@@ -879,73 +872,6 @@ describe("main watchdog runtime", () => {
 		assert.deepEqual((delivered[0] as { options?: unknown }).options, { deliverAs: "steer" });
 	});
 
-	it("auto-follows agent-end blockers, respects max attempts, and real prompts reset attempts", async () => {
-		const sent: string[] = [];
-		const runtime = new MainWatchdogRuntime({
-			resolveConfig: () => configResult(enabledConfig({ autoFollow: { blockers: true, maxAttempts: 1, stalemateRepeats: 3 } })),
-			sendUserMessage: (message) => sent.push(message),
-			review: (request) => {
-				assert.equal(request.emitWarning({ ...warning(), severity: "blocker", summary: "Needs fixing" }), true);
-				return { stopReason: "stop" };
-			},
-		});
-
-		runtime.handleBeforeAgentStart({ prompt: "Patch carefully." }, { cwd: "/tmp/project" });
-		runtime.enqueueDelta("Assistant:\nBad patch.");
-		await runtime.handleAgentEnd({ type: "agent_end" }, { cwd: "/tmp/project" });
-		assert.equal(sent.length, 1);
-		assert.match(sent[0] ?? "", /Watchdog auto-follow/);
-		assert.equal(runtime.getSnapshot().autoFollowAttempts, 1);
-
-		runtime.handleBeforeAgentStart({ prompt: sent[0] }, { cwd: "/tmp/project" });
-		runtime.enqueueDelta("Assistant:\nStill bad.");
-		await runtime.handleAgentEnd({ type: "agent_end" }, { cwd: "/tmp/project" });
-		assert.equal(sent.length, 1);
-
-		runtime.handleBeforeAgentStart({ prompt: "Human says try again with a different edit." }, { cwd: "/tmp/project" });
-		runtime.enqueueDelta("Assistant:\nBad again in a different way.");
-		await runtime.handleAgentEnd({ type: "agent_end" }, { cwd: "/tmp/project" });
-		assert.equal(sent.length, 2);
-		assert.equal(runtime.getSnapshot().autoFollowAttempts, 1);
-	});
-
-	it("keeps a racing real prompt authoritative while a queued auto-follow is pending", async () => {
-		const sent: string[] = [];
-		let reviewedDelta = "";
-		let blockerSummary = "First blocker";
-		const runtime = new MainWatchdogRuntime({
-			resolveConfig: () => configResult(enabledConfig({ autoFollow: { blockers: true, maxAttempts: 1, stalemateRepeats: 5 } })),
-			sendUserMessage: (message) => sent.push(message),
-			review: (request) => {
-				reviewedDelta = request.delta;
-				assert.equal(request.emitWarning({ ...warning(), severity: "blocker", summary: blockerSummary }), true);
-				return { stopReason: "stop" };
-			},
-		});
-
-		runtime.handleBeforeAgentStart({ prompt: "Patch carefully." }, { cwd: "/tmp/project" });
-		runtime.enqueueDelta("Assistant:\nBad patch.");
-		await runtime.handleAgentEnd({ type: "agent_end" }, { cwd: "/tmp/project" });
-		assert.equal(sent.length, 1);
-		assert.equal(runtime.getSnapshot().autoFollowAttempts, 1);
-
-		// A real user prompt arrives before the queued auto-follow turn starts.
-		blockerSummary = "Second blocker";
-		runtime.handleBeforeAgentStart({ prompt: "Human: also update the docs." }, { cwd: "/tmp/project" });
-		runtime.enqueueDelta("Assistant:\nStill bad.");
-		await runtime.handleAgentEnd({ type: "agent_end" }, { cwd: "/tmp/project" });
-		assert.match(reviewedDelta, /also update the docs\./);
-		assert.equal(sent.length, 2, "real prompt resets attempts so a new blocker auto-follows again");
-
-		// The originally queued auto-follow prompt then arrives and stays excluded from scope.
-		blockerSummary = "Third blocker";
-		runtime.handleBeforeAgentStart({ prompt: sent[0] }, { cwd: "/tmp/project" });
-		runtime.enqueueDelta("Assistant:\nStill bad again.");
-		await runtime.handleAgentEnd({ type: "agent_end" }, { cwd: "/tmp/project" });
-		assert.doesNotMatch(reviewedDelta, /Watchdog auto-follow: address this blocker/);
-		assert.equal(sent.length, 2, "auto-follow turn must not reset the attempt counter");
-	});
-
 	it("cancels an in-flight cadence review so the agent-end boundary review still runs", async () => {
 		let releaseFirstReview!: () => void;
 		let reviewCalls = 0;
@@ -979,56 +905,48 @@ describe("main watchdog runtime", () => {
 		assert.equal(snapshot.status, "idle");
 	});
 
-	it("stops auto-following repeated blocker identities at stalemate threshold", async () => {
-		const sent: string[] = [];
+	it("marks the third consecutive identical boundary warning as stalemate and delivers it held", async () => {
+		const delivered: Array<{ warning: WatchdogWarningDetails; options?: unknown }> = [];
 		const runtime = new MainWatchdogRuntime({
-			resolveConfig: () => configResult(enabledConfig({ autoFollow: { blockers: true, maxAttempts: 5, stalemateRepeats: 2 } })),
-			sendUserMessage: (message) => sent.push(message),
+			resolveConfig: () => configResult(enabledConfig({ stalemateRepeats: 3 })),
+			displayWarning: (details, options) => { delivered.push({ warning: details, options }); },
 			review: (request) => {
-				assert.equal(request.emitWarning({ ...warning(), severity: "blocker", summary: "Same blocker" }), true);
+				request.emitWarning({ ...warning(), severity: "blocker", summary: "Same blocker" });
 				return { stopReason: "stop" };
 			},
 		});
 
 		runtime.handleBeforeAgentStart({ prompt: "Patch carefully." }, { cwd: "/tmp/project" });
-		runtime.enqueueDelta("Assistant:\nBad patch.");
-		await runtime.handleAgentEnd({ type: "agent_end" }, { cwd: "/tmp/project" });
-		assert.equal(sent.length, 1);
-
-		runtime.handleBeforeAgentStart({ prompt: sent[0] }, { cwd: "/tmp/project" });
-		runtime.enqueueDelta("Assistant:\nStill bad but not identical input.");
-		await runtime.handleAgentEnd({ type: "agent_end" }, { cwd: "/tmp/project" });
+		for (const delta of ["Assistant:\nBad patch.", "Assistant:\nStill bad.", "Assistant:\nStill bad again."]) {
+			runtime.enqueueDelta(delta);
+			await runtime.handleAgentEnd({ type: "agent_end" }, { cwd: "/tmp/project" });
+		}
 
-		const snapshot = runtime.getSnapshot();
-		assert.equal(sent.length, 1);
-		assert.equal(snapshot.autoFollowStalemate, true);
+		assert.equal(delivered.length, 3, "repeats keep nudging until the stalemate threshold");
+		assert.equal(delivered[0]?.options, undefined);
+		assert.equal(delivered[1]?.options, undefined);
+		assert.deepEqual(delivered[2]?.options, { triggerTurn: false });
+		assert.equal(delivered[2]?.warning.state, "stalemate");
+		assert.equal(delivered[2]?.warning.stalemateRepeats, 3);
+		let snapshot = runtime.getSnapshot();
+		assert.equal(snapshot.stalemate, true);
+		assert.equal(snapshot.boundaryRepeats, 3);
 		assert.equal(snapshot.lastWarning?.state, "stalemate");
-	});
 
-	it("does not auto-follow stale blocker warnings", async () => {
-		let emitWarning!: (candidate: WatchdogWarning) => boolean;
-		let finishReview!: () => void;
-		let started!: () => void;
-		const reviewStarted = new Promise<void>((resolve) => { started = resolve; });
-		const sent: string[] = [];
-		const runtime = new MainWatchdogRuntime({
-			resolveConfig: () => configResult(enabledConfig({ agentEndTimeoutMs: 5 })),
-			sendUserMessage: (message) => sent.push(message),
-			review: async (request) => {
-				emitWarning = request.emitWarning;
-				started();
-				await new Promise<void>((resolve) => { finishReview = resolve; });
-			},
-		});
+		// After stalemate the same finding is a plain duplicate again: no further delivery.
+		runtime.enqueueDelta("Assistant:\nStill bad, fourth time.");
+		await runtime.handleAgentEnd({ type: "agent_end" }, { cwd: "/tmp/project" });
+		assert.equal(delivered.length, 3);
 
-		runtime.enqueueDelta("Assistant:\nStill working");
-		const end = runtime.handleAgentEnd({ type: "agent_end", messages: [] }, { cwd: "/tmp/project" });
-		await reviewStarted;
-		await end;
-		assert.equal(emitWarning({ ...warning(), severity: "blocker" }), false);
-		finishReview();
-		await tick();
-		assert.equal(sent.length, 0);
+		// A real prompt resets the counter.
+		runtime.handleBeforeAgentStart({ prompt: "Human: try a different approach." }, { cwd: "/tmp/project" });
+		runtime.enqueueDelta("Assistant:\nNew attempt.");
+		await runtime.handleAgentEnd({ type: "agent_end" }, { cwd: "/tmp/project" });
+		assert.equal(delivered.length, 4);
+		assert.equal(delivered[3]?.options, undefined);
+		snapshot = runtime.getSnapshot();
+		assert.equal(snapshot.boundaryRepeats, 1);
+		assert.equal(snapshot.stalemate, false);
 	});
 
 	it("session on/off overrides explicit main enabled settings", () => {

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

@@ -30,4 +30,4 @@ describe("watchdog scope artifact", () => {
 		assert.equal(isWatchdogAutoFollowPromptEvent(event), true);
 		assert.equal(isWatchdogAutoFollowPromptEvent({ prompt: "Watchdog auto-follow: address this blocker" }), false);
 	});
-});
+});

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

@@ -51,12 +51,10 @@ describe("watchdog settings", () => {
 		assert.equal(result.config.enabled, false);
 		assert.equal(result.config.main.enabled, false);
 		assert.equal(result.config.children.enabled, false);
-		assert.equal(result.config.asyncCompletion.enabled, false);
-		assert.equal(result.config.delivery, "held");
-		assert.equal(result.config.showDuringRun, false);
+		assert.equal(result.config.guidance.watchdogMd, true);
 		assert.equal(result.config.agentEndTimeoutMs, 30_000);
 		assert.equal(result.config.children.watchdogTailTimeoutMs, 120_000);
-		assert.equal(result.config.autoFollow.maxAttempts, 3);
+		assert.equal(result.config.stalemateRepeats, 3);
 		assert.deepEqual(result.config.scope, { enabled: true });
 		assert.deepEqual(result.config.cadence, { everyNTools: null });
 		assert.deepEqual(result.config.lsp, { enabled: true, timeoutMs: 3000, maxFiles: 20, maxDiagnostics: 50 });
@@ -83,14 +81,14 @@ describe("watchdog settings", () => {
 			subagents: {
 				watchdog: {
 					enabled: true,
-					autoFollow: { blockers: true, maxAttempts: 5 },
+					stalemateRepeats: 5,
 					children: {
-						autoFollow: { maxAttempts: 4 },
+						cadence: { everyNTools: 10 },
 						overrides: {
-							worker: { enabled: true, model: "anthropic/claude-test" },
+							worker: { enabled: true, model: "anthropic/claude-test", cadence: { everyNTools: 5 } },
 						},
 					},
-					guidance: { systemPromptPath: "/tmp/user-watchdog.md" },
+					guidance: { watchdogMd: false },
 					scope: { enabled: false },
 					cadence: { everyNTools: 10 },
 				},
@@ -99,11 +97,10 @@ describe("watchdog settings", () => {
 		writeJson(projectSettingsPath(), {
 			subagents: {
 				watchdog: {
-					autoFollow: { stalemateRepeats: 2 },
+					stalemateRepeats: 2,
 					lsp: { enabled: false, timeoutMs: 1500, maxFiles: 4, maxDiagnostics: 7 },
 					main: { model: "openai/gpt-test" },
 					children: {
-						autoFollow: { blockers: false },
 						overrides: {
 							worker: { thinking: "medium" },
 							reviewer: { enabled: false },
@@ -115,7 +112,6 @@ describe("watchdog settings", () => {
 
 		const result = resolveWatchdogConfig(tempProject, {
 			session: {
-				autoFollow: { maxAttempts: null },
 				children: {
 					overrides: {
 						worker: { enabled: false },
@@ -127,16 +123,17 @@ describe("watchdog settings", () => {
 		assert.equal(result.ok, true);
 		assert.equal(result.config.main.enabled, true);
 		assert.equal(result.config.main.model, "openai/gpt-test");
-		assert.deepEqual(result.config.autoFollow, { blockers: true, maxAttempts: null, stalemateRepeats: 2 });
-		assert.equal(result.config.guidance.systemPromptPath, "/tmp/user-watchdog.md");
+		assert.equal(result.config.stalemateRepeats, 2);
+		assert.equal(result.config.guidance.watchdogMd, false);
 		assert.deepEqual(result.config.scope, { enabled: false });
 		assert.deepEqual(result.config.cadence, { everyNTools: 10 });
+		assert.deepEqual(result.config.children.cadence, { everyNTools: 10 });
 		assert.deepEqual(result.config.lsp, { enabled: false, timeoutMs: 1500, maxFiles: 4, maxDiagnostics: 7 });
-		assert.deepEqual(result.config.children.autoFollow, { blockers: false, maxAttempts: 4, stalemateRepeats: 3 });
 		assert.deepEqual(result.config.children.overrides.worker, {
 			enabled: false,
 			model: "anthropic/claude-test",
 			thinking: "medium",
+			cadence: { everyNTools: 5 },
 		});
 		assert.deepEqual(result.config.children.overrides.reviewer, { enabled: false });
 	});
@@ -178,6 +175,29 @@ describe("watchdog settings", () => {
 		);
 	});
 
+	it("parses launch rules and rejects malformed rule fields", () => {
+		const rules = {
+			action: "block",
+			roleModels: { scout: { allow: ["openai-codex/gpt-5.6-luna:max"] }, oracle: { deny: ["*"], note: "ask first" } },
+		} as const;
+		writeJson(userSettingsPath(), {
+			subagents: {
+				watchdog: { rules },
+			},
+		});
+		const result = resolveWatchdogConfig(tempProject);
+		assert.equal(result.ok, true, result.errors[0]?.message);
+		assert.deepEqual(result.config.rules, rules);
+		assert.equal(resolveWatchdogConfig(tempProject, { session: { enabled: true } }).config.rules?.action, "block");
+
+		writeJson(userSettingsPath(), { subagents: { watchdog: { rules: { action: "shout" } } } });
+		assert.match(resolveWatchdogConfig(tempProject).errors[0]?.message ?? "", /invalid 'subagents\.watchdog\.rules\.action'; expected 'warn' or 'block'/);
+		writeJson(userSettingsPath(), { subagents: { watchdog: { rules: { roleModels: { scout: { allowed: ["x"] } } } } } });
+		assert.match(resolveWatchdogConfig(tempProject).errors[0]?.message ?? "", /unknown field 'subagents\.watchdog\.rules\.roleModels\.scout\.allowed'/);
+		writeJson(userSettingsPath(), { subagents: { watchdog: {} } });
+		assert.equal(resolveWatchdogConfig(tempProject).config.rules, undefined);
+	});
+
 	it("rejects invalid scope and cadence config at settings load", () => {
 		writeJson(userSettingsPath(), {
 			subagents: {
@@ -202,6 +222,9 @@ describe("watchdog settings", () => {
 		result = resolveWatchdogConfig(tempProject);
 		assert.equal(result.ok, false);
 		assert.match(result.errors[0]?.message ?? "", /invalid 'subagents\.watchdog\.cadence\.everyNTools'/);
+
+		writeJson(userSettingsPath(), { subagents: { watchdog: { children: { cadence: { everyNTools: 4 } } } } });
+		assert.match(resolveWatchdogConfig(tempProject).errors[0]?.message ?? "", /invalid 'subagents\.watchdog\.children\.cadence\.everyNTools'/);
 	});
 
 	it("rejects invalid LSP config at settings load", () => {

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

@@ -297,7 +297,7 @@ describe("workflow chat progress rendering", () => {
 		assert.doesNotMatch(text, /failed\s+detaches/);
 	});
 
-	it("seeds declared preflight lanes as planned before workflow trace entries", () => {
+	it("keeps advisory preflight lanes in plan metadata instead of runtime rows", () => {
 		const preflight = {
 			version: 1 as const,
 			coverage: "partial" as const,
@@ -306,40 +306,57 @@ describe("workflow chat progress rendering", () => {
 				{ key: "review", mode: "review" as const, expectedOutput: "review.md" },
 			],
 		};
-		assert.deepEqual(buildWorkflowChatProgressRows([], preflight).map((row) => ({ key: row.key, state: row.state })), [
-			{ key: "writer", state: "planned" },
-			{ key: "review", state: "planned" },
-		]);
-		const text = componentText(renderSubagentResult({
-			content: [{ type: "text", text: "Workflow running." }],
+		assert.deepEqual(buildWorkflowChatProgressRows([], preflight), []);
+		const result = {
+			content: [{ type: "text" as const, text: "Workflow running." }],
 			details: {
-				mode: "workflow",
+				mode: "workflow" as const,
 				runId: "wf_planned",
 				results: [],
 				preflight,
-				chatProgress: { mode: "live-card", repoRelation: "same", repoLabel: "pi-subagents" },
+				chatProgress: { mode: "live-card" as const, repoRelation: "same" as const, repoLabel: "pi-subagents" },
 				workflow: { trace: [], emits: [], console: [] },
 			},
-		}, { expanded: false }, theme as any));
-		assert.match(text, /planned\s+writer/);
-		assert.match(text, /planned\s+review/);
+		};
+		const text = componentText(renderSubagentResult(result, { expanded: false }, theme as any));
+		assert.match(text, /Plan: 2 lanes · writer, review/);
+		assert.match(text, /waiting for workflow child launches/);
+		assert.doesNotMatch(text, /planned\s+writer/);
+		assert.doesNotMatch(text, /planned\s+review/);
 		assert.doesNotMatch(text, /mode:mutation/);
 		assert.doesNotMatch(text, /expected:review\.md/);
-		assert.doesNotMatch(text, /waiting for workflow child launches/);
 
-		const expanded = componentText(renderSubagentResult({
-			content: [{ type: "text", text: "Workflow running." }],
-			details: {
-				mode: "workflow",
-				runId: "wf_planned",
-				results: [],
-				preflight,
-				chatProgress: { mode: "live-card", repoRelation: "same", repoLabel: "pi-subagents" },
-				workflow: { trace: [], emits: [], console: [] },
-			},
-		}, { expanded: true }, theme as any));
-		assert.match(expanded, /mode:mutation/);
-		assert.match(expanded, /expected:review\.md/);
+		const expanded = componentText(renderSubagentResult(result, { expanded: true }, theme as any));
+		assert.match(expanded, /Plan: 2 lanes · writer, review/);
+		assert.doesNotMatch(expanded, /planned\s+writer/);
+		assert.doesNotMatch(expanded, /planned\s+review/);
+	});
+
+	it("annotates an authoritative dotted child without adding its declared root", () => {
+		const preflight = { version: 1 as const, coverage: "partial" as const, lanes: [{ key: "pr14", mode: "review" as const }] };
+		const rows = buildWorkflowChatProgressRows([
+			{ operation: "run", key: "pr14.quality", generatedLaneKey: "pr14", state: "started", agent: "reviewer" },
+		], preflight);
+
+		assert.deepEqual(rows.map((row) => ({ key: row.key, state: row.state, mode: row.preflight?.mode })), [
+			{ key: "pr14.quality", state: "running", mode: "review" },
+		]);
+	});
+
+	it("prefers a specific preflight lane over an earlier broad generated alias", () => {
+		const preflight = {
+			version: 1 as const,
+			coverage: "partial" as const,
+			lanes: [
+				{ key: "writer", mode: "mutation" as const },
+				{ key: "writer.quality", mode: "review" as const },
+			],
+		};
+		const rows = buildWorkflowChatProgressRows([
+			{ operation: "run", key: "writer.quality.deep", generatedLaneKey: "writer", state: "started", agent: "reviewer" },
+		], preflight);
+
+		assert.equal(rows[0]?.preflight?.mode, "review");
 	});
 
 	it("uses the compact plan preview for collapsed workflow launch output", () => {
@@ -434,6 +451,7 @@ describe("workflow chat progress rendering", () => {
 			key: `step-${index}`,
 			state: "started" as const,
 			label: `review ${index}`,
+			phase: `phase-${index}`,
 		}));
 		const result = {
 			content: [{ type: "text" as const, text: "Workflow running." }],
@@ -454,6 +472,7 @@ describe("workflow chat progress rendering", () => {
 		const expanded = renderSubagentResult(result, { expanded: true }, theme as any, undefined, { horizontalSpacing: 0, compactResultMaxLines: 3 }).render(120);
 		assert.ok(expanded.length > 3);
 		assert.match(expanded[1]!, /^  Repo   pi-subagents\s*$/);
+		assert.match(expanded.join("\n"), /phase-9 1 active/);
 		assert.doesNotMatch(expanded.join("\n"), /rows hidden · .* expands/);
 	});