@selesai/code 0.5.20 → 0.5.21

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

@@ -0,0 +1,144 @@
+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 {
+	WatchdogLspDiagnosticsLedger,
+	collectWatchdogLspDiagnostics,
+	formatWatchdogLspDiagnosticsBlock,
+	watchdogWarningFromLspDiagnostics,
+} from "../../src/watchdog/lsp-diagnostics.ts";
+import type { WatchdogLspResult } from "../../src/watchdog/types.ts";
+
+function result(diagnostics: WatchdogLspResult["diagnostics"]): WatchdogLspResult {
+	return {
+		status: "ok",
+		provider: "stub-lsp",
+		checkedPaths: ["src/file.ts"],
+		skippedPaths: [],
+		diagnostics,
+	};
+}
+
+describe("watchdog LSP diagnostics", () => {
+	it("formats diagnostics for watchdog review input", () => {
+		const block = formatWatchdogLspDiagnosticsBlock(result([{
+			path: "src/file.ts",
+			line: 2,
+			column: 3,
+			severity: "error",
+			source: "typescript",
+			code: "TS2322",
+			message: "Type mismatch.",
+		}]));
+
+		assert.match(block, /^LSP diagnostics:/);
+		assert.match(block, /src\/file\.ts:2:3 error TS2322 typescript: Type mismatch\./);
+	});
+
+	it("omits info and hints from watchdog review input", () => {
+		const block = formatWatchdogLspDiagnosticsBlock(result([{
+			path: "src/file.ts",
+			line: 2,
+			column: 3,
+			severity: "info",
+			source: "typescript",
+			message: "Helpful note.",
+		}, {
+			path: "src/file.ts",
+			line: 3,
+			column: 4,
+			severity: "hint",
+			source: "typescript",
+			message: "Suggestion.",
+		}]));
+
+		assert.equal(block, "");
+	});
+
+	it("maps errors to blockers and warnings to concerns", () => {
+		const blocker = watchdogWarningFromLspDiagnostics(result([{
+			path: "src/file.ts",
+			line: 1,
+			column: 1,
+			severity: "error",
+			source: "typescript",
+			message: "Cannot find name 'x'.",
+		}]));
+		assert.equal(blocker?.severity, "blocker");
+		assert.equal(blocker?.source, "lsp");
+
+		const concern = watchdogWarningFromLspDiagnostics(result([{
+			path: "src/file.ts",
+			line: 1,
+			column: 1,
+			severity: "warning",
+			source: "typescript",
+			message: "Unused value.",
+		}]));
+		assert.equal(concern?.severity, "concern");
+
+		const info = watchdogWarningFromLspDiagnostics(result([{
+			path: "src/file.ts",
+			line: 1,
+			column: 1,
+			severity: "info",
+			source: "typescript",
+			message: "Helpful note.",
+		}]));
+		assert.equal(info, undefined);
+	});
+
+	it("returns a failed result for malformed language-server JSON", async () => {
+		const temp = fs.mkdtempSync(path.join(os.tmpdir(), "pi-watchdog-lsp-"));
+		try {
+			const binDir = path.join(temp, "node_modules", ".bin");
+			fs.mkdirSync(path.join(temp, "src"), { recursive: true });
+			fs.mkdirSync(binDir, { recursive: true });
+			fs.writeFileSync(path.join(temp, "src", "file.ts"), "export const value = 1;\n", "utf-8");
+			const scriptPath = path.join(binDir, "tls-malformed.js");
+			fs.writeFileSync(scriptPath, "process.stdout.write('Content-Length: 8\\r\\n\\r\\nnot-json'); setTimeout(() => process.exit(0), 50);\n", "utf-8");
+			if (process.platform === "win32") {
+				fs.writeFileSync(path.join(binDir, "typescript-language-server.cmd"), `@echo off\r\n"${process.execPath}" "%~dp0\\tls-malformed.js" %*\r\n`, "utf-8");
+			} else {
+				const commandPath = path.join(binDir, "typescript-language-server");
+				fs.writeFileSync(commandPath, `#!/bin/sh\nexec "${process.execPath}" "$(dirname "$0")/tls-malformed.js" "$@"\n`, { encoding: "utf-8", mode: 0o755 });
+			}
+
+			const diagnostics = await collectWatchdogLspDiagnostics({
+				cwd: temp,
+				root: temp,
+				changedPaths: ["src/file.ts"],
+				config: { enabled: true, timeoutMs: 500, maxFiles: 10, maxDiagnostics: 10 },
+			});
+
+			assert.equal(diagnostics.status, "failed");
+			assert.match(diagnostics.message ?? "", /Invalid LSP JSON-RPC response/);
+		} finally {
+			try {
+				fs.rmSync(temp, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+			} catch (error) {
+				if (process.platform !== "win32" || (error as NodeJS.ErrnoException).code !== "EPERM") throw error;
+			}
+		}
+	});
+
+	it("suppresses repeated diagnostic identities until the file clears", () => {
+		const ledger = new WatchdogLspDiagnosticsLedger();
+		const diagnostic = {
+			path: "src/file.ts",
+			line: 1,
+			column: 1,
+			severity: "warning" as const,
+			source: "typescript",
+			code: "TS6133",
+			message: "Unused value.",
+		};
+
+		assert.equal(ledger.reduce(result([diagnostic])).diagnostics.length, 1);
+		assert.equal(ledger.reduce(result([{ ...diagnostic, line: 4, column: 9 }])).diagnostics.length, 0);
+		assert.equal(ledger.reduce(result([])).diagnostics.length, 0);
+		assert.equal(ledger.reduce(result([{ ...diagnostic, line: 8 }])).diagnostics.length, 1);
+	});
+});

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

@@ -0,0 +1,121 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { recommendStrongWatchdogModel, resolveWatchdogModelInput } from "../../src/watchdog/model-selection.ts";
+
+function createCtx(
+	current: { provider: string; id: string },
+	authenticated: string[] = ["openai-codex/gpt-5.5", "anthropic/claude-opus-4-8"],
+	models: Array<{ provider: string; id: string; reasoning: boolean; thinkingLevelMap?: Record<string, string | null> }> = [
+		{ provider: "openai-codex", id: "gpt-5.5", reasoning: true },
+		{ provider: "anthropic", id: "claude-opus-4-8", reasoning: true },
+	],
+) {
+	return {
+		cwd: "/tmp/watchdog-model-selection",
+		model: current,
+		modelRegistry: {
+			getAvailable: () => models,
+			find: (provider: string, id: string) => models.find((model) => model.provider === provider && model.id === id),
+			hasConfiguredAuth: (model: { provider: string; id: string }) => authenticated.includes(`${model.provider}/${model.id}`),
+		},
+	} as never;
+}
+
+describe("watchdog model selection", () => {
+	it("recommends Opus 4.8 high when the main session is GPT 5.5", () => {
+		const recommendation = recommendStrongWatchdogModel(createCtx({ provider: "openai-codex", id: "gpt-5.5" }));
+
+		assert.equal(recommendation.model, "anthropic/claude-opus-4-8");
+		assert.equal(recommendation.thinking, "high");
+	});
+
+	it("recommends GPT 5.5 high when the main session is Opus 4.8", () => {
+		const recommendation = recommendStrongWatchdogModel(createCtx({ provider: "anthropic", id: "claude-opus-4-8" }));
+
+		assert.equal(recommendation.model, "openai-codex/gpt-5.5");
+		assert.equal(recommendation.thinking, "high");
+	});
+
+	it("requires the complementary strong model to be authenticated", () => {
+		assert.throws(
+			() => recommendStrongWatchdogModel(createCtx({ provider: "openai-codex", id: "gpt-5.5" }, ["openai-codex/gpt-5.5"])),
+			/No authenticated strong complementary watchdog model/,
+		);
+	});
+
+	it("does not treat GPT 5.5 mini variants as the strong GPT 5.5 watchdog", () => {
+		const models = [
+			{ provider: "openai-codex", id: "gpt-5.5-mini", reasoning: true },
+			{ provider: "openai-codex", id: "gpt-5.5-20250101-mini", reasoning: true },
+		];
+		const ctx = {
+			cwd: "/tmp/watchdog-model-selection",
+			model: { provider: "anthropic", id: "claude-opus-4-8" },
+			modelRegistry: {
+				getAvailable: () => models,
+				find: (provider: string, id: string) => models.find((model) => model.provider === provider && model.id === id),
+				hasConfiguredAuth: (model: { provider: string; id: string }) => `${model.provider}/${model.id}` === "openai-codex/gpt-5.5-mini" || `${model.provider}/${model.id}` === "openai-codex/gpt-5.5-20250101-mini",
+			},
+		} as never;
+
+		assert.throws(
+			() => recommendStrongWatchdogModel(ctx),
+			/No authenticated strong complementary watchdog model/,
+		);
+	});
+
+	it("does not treat dated Opus mini variants as the strong Opus 4.8 watchdog", () => {
+		const models = [{ provider: "anthropic", id: "claude-opus-4-8-20250101-mini", reasoning: true }];
+		const ctx = {
+			cwd: "/tmp/watchdog-model-selection",
+			model: { provider: "openai-codex", id: "gpt-5.5" },
+			modelRegistry: {
+				getAvailable: () => models,
+				find: (provider: string, id: string) => models.find((model) => model.provider === provider && model.id === id),
+				hasConfiguredAuth: (model: { provider: string; id: string }) => `${model.provider}/${model.id}` === "anthropic/claude-opus-4-8-20250101-mini",
+			},
+		} as never;
+
+		assert.throws(
+			() => recommendStrongWatchdogModel(ctx),
+			/No authenticated strong complementary watchdog model/,
+		);
+	});
+
+	it("does not treat cheap-prefixed variants as strong watchdog families", () => {
+		const models = [
+			{ provider: "openai-codex", id: "cheap-gpt-5.5", reasoning: true },
+			{ provider: "anthropic", id: "cheap-claude-opus-4-8", reasoning: true },
+		];
+		const ctx = {
+			cwd: "/tmp/watchdog-model-selection",
+			model: { provider: "anthropic", id: "claude-opus-4-8" },
+			modelRegistry: {
+				getAvailable: () => models,
+				find: (provider: string, id: string) => models.find((model) => model.provider === provider && model.id === id),
+				hasConfiguredAuth: (model: { provider: string; id: string }) => `${model.provider}/${model.id}` === "openai-codex/cheap-gpt-5.5" || `${model.provider}/${model.id}` === "anthropic/cheap-claude-opus-4-8",
+			},
+		} as never;
+
+		assert.throws(
+			() => recommendStrongWatchdogModel(ctx),
+			/No authenticated strong complementary watchdog model/,
+		);
+	});
+
+	it("canonicalizes explicit models and preserves thinking suffixes", () => {
+		const resolved = resolveWatchdogModelInput(createCtx({ provider: "anthropic", id: "claude-opus-4-8" }), "openai-codex/gpt-5-5:high");
+
+		assert.equal(resolved.model, "openai-codex/gpt-5.5");
+		assert.equal(resolved.thinking, "high");
+	});
+
+	it("accepts a max suffix for an authenticated watchdog model", () => {
+		const ctx = createCtx(
+			{ provider: "openai", id: "gpt-5" },
+			["openai/gpt-5"],
+			[{ provider: "openai", id: "gpt-5", reasoning: true, thinkingLevelMap: { max: "max" } }],
+		);
+		assert.equal(resolveWatchdogModelInput(ctx, "openai/gpt-5:max").thinking, "max");
+	});
+});

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

@@ -0,0 +1,76 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { formatWatchdogWarningRenderText } from "../../src/watchdog/render.ts";
+import { createWatchdogWarningMessage, formatWatchdogWarningContent } from "../../src/watchdog/warning-format.ts";
+import { SUBAGENT_WATCHDOG_WARNING_TYPE, type WatchdogWarningDetails } from "../../src/watchdog/types.ts";
+
+describe("watchdog warning formatting and rendering", () => {
+	it("puts all LLM-needed warning fields in custom message content", () => {
+		const content = formatWatchdogWarningContent({
+			severity: "blocker",
+			category: "correctness",
+			source: "main",
+			summary: "Fix <bug>",
+			evidence: "The failing assertion says A & B differ.",
+			recommendedAction: "Update the parser before finalizing.",
+			confidence: "high",
+			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">/);
+		assert.match(content, /<summary>Fix &lt;bug&gt;<\/summary>/);
+		assert.match(content, /<evidence>The failing assertion says A &amp; B differ\.<\/evidence>/);
+		assert.match(content, /<recommended_action>Update the parser before finalizing\.<\/recommended_action>/);
+		assert.match(content, /<confidence>high<\/confidence>/);
+		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.match(content, /<blocker_guidance>/);
+	});
+
+	it("keeps structured details alongside the LLM-visible content", () => {
+		const message = createWatchdogWarningMessage({
+			severity: "concern",
+			summary: "Missing focused test",
+			evidence: "The parser changed without a unit test.",
+			recommendedAction: "Add a parser regression test.",
+		});
+
+		assert.equal(message.customType, SUBAGENT_WATCHDOG_WARNING_TYPE);
+		assert.equal(message.display, true);
+		assert.equal(message.details.category, "other");
+		assert.equal(message.details.source, "main");
+		assert.match(message.content, /<summary>Missing focused test<\/summary>/);
+		assert.match(message.content, /<recommended_action>Add a parser regression test\.<\/recommended_action>/);
+	});
+
+	it("renders concern, blocker, stale, failed, and stalemate states in text", () => {
+		const base: WatchdogWarningDetails = {
+			severity: "blocker",
+			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.",
+			state: "stalemate",
+			stalemateRepeats: 3,
+		};
+
+		const stalemate = formatWatchdogWarningRenderText(base);
+		const stale = formatWatchdogWarningRenderText({ ...base, severity: "concern", state: "stale", stale: true });
+		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(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

@@ -0,0 +1,327 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { StreamFn } from "@earendil-works/pi-agent-core";
+import {
+	createAssistantMessageEventStream,
+	fauxAssistantMessage,
+	fauxToolCall,
+	type AssistantMessage,
+	type Context,
+	type Model,
+	type SimpleStreamOptions,
+} from "@earendil-works/pi-ai";
+import { DEFAULT_WATCHDOG_CONFIG } from "../../src/watchdog/settings.ts";
+import { createMainWatchdogReview, resolveWatchdogReviewModel } from "../../src/watchdog/review.ts";
+import type { WatchdogReviewRequest } from "../../src/watchdog/runtime.ts";
+import type { ResolvedWatchdogConfig, WatchdogWarning } from "../../src/watchdog/types.ts";
+
+function model(provider: string, id: string, overrides: Partial<Model<any>> = {}): Model<any> {
+	return {
+		id,
+		name: id,
+		api: "faux",
+		provider,
+		baseUrl: "https://example.invalid",
+		reasoning: true,
+		input: ["text"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 100_000,
+		maxTokens: 4_096,
+		...overrides,
+	};
+}
+
+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 },
+	};
+}
+
+function enabledConfig(main: Partial<ResolvedWatchdogConfig["main"]> = {}): ResolvedWatchdogConfig {
+	const config = cloneConfig();
+	config.enabled = true;
+	config.main = { ...config.main, enabled: true, ...main };
+	return config;
+}
+
+function createCtx(input: {
+	current?: Model<any>;
+	models?: Model<any>[];
+	authenticated?: string[];
+	thinkingLevel?: string;
+	providerConfig?: { provider: string; api: string; streamSimple: StreamFn };
+}) {
+	const allModels = input.models ?? (input.current ? [input.current] : []);
+	const authenticated = new Set(input.authenticated ?? allModels.map((entry) => `${entry.provider}/${entry.id}`));
+	return {
+		cwd: "/tmp/watchdog-review",
+		model: input.current,
+		...(input.thinkingLevel ? { thinkingLevel: input.thinkingLevel } : {}),
+		signal: undefined,
+		getSystemPrompt: () => "Parent system prompt",
+		modelRegistry: {
+			getAvailable: () => allModels.filter((entry) => authenticated.has(`${entry.provider}/${entry.id}`)),
+			find: (provider: string, id: string) => allModels.find((entry) => entry.provider === provider && entry.id === id),
+			hasConfiguredAuth: (entry: Model<any>) => authenticated.has(`${entry.provider}/${entry.id}`),
+			getApiKeyAndHeaders: async (entry: Model<any>) => authenticated.has(`${entry.provider}/${entry.id}`)
+				? { ok: true as const, apiKey: `key-${entry.provider}-${entry.id}`, headers: { "x-model": entry.id }, env: { WATCHDOG_PROVIDER: entry.provider } }
+				: { ok: false as const, error: `No auth for ${entry.provider}/${entry.id}` },
+			getRegisteredProviderConfig: (provider: string) => input.providerConfig?.provider === provider ? input.providerConfig : undefined,
+		},
+	} as never;
+}
+
+function responseStream(message: AssistantMessage) {
+	const stream = createAssistantMessageEventStream();
+	queueMicrotask(() => {
+		if (message.stopReason === "error" || message.stopReason === "aborted") {
+			stream.push({ type: "error", reason: message.stopReason, error: message });
+		} else {
+			stream.push({ type: "done", reason: message.stopReason, message });
+		}
+	});
+	return stream;
+}
+
+function createStreamFn(responses: AssistantMessage[]) {
+	const calls: Array<{ model: Model<any>; context: Context; options?: SimpleStreamOptions }> = [];
+	const streamFn: StreamFn = (nextModel, context, options) => {
+		calls.push({ model: nextModel, context, options });
+		return responseStream(responses.shift() ?? fauxAssistantMessage("done", { stopReason: "stop" }));
+	};
+	return { streamFn, calls };
+}
+
+function request(config: ResolvedWatchdogConfig, warnings: WatchdogWarning[]): WatchdogReviewRequest {
+	return {
+		delta: "Assistant changed src/example.ts and said tests passed.",
+		epoch: 1,
+		reviewId: 7,
+		config,
+		emitWarning(warning) {
+			warnings.push(warning);
+			return true;
+		},
+	};
+}
+
+describe("main watchdog review adapter", () => {
+	it("ignores clean freeform review text and emits no warnings", async () => {
+		const current = model("openai", "gpt-clean");
+		const ctx = createCtx({ current });
+		const { streamFn } = createStreamFn([fauxAssistantMessage("No concerns.", { stopReason: "stop" })]);
+		const warnings: WatchdogWarning[] = [];
+
+		const result = await createMainWatchdogReview(ctx, { streamFn })(request(enabledConfig(), warnings));
+
+		assert.deepEqual(warnings, []);
+		assert.equal(result?.stopReason, "stop");
+	});
+
+	it("records watchdog_warn emissions through the runtime seam", async () => {
+		const current = model("openai", "gpt-warning");
+		const ctx = createCtx({ current });
+		const { streamFn } = createStreamFn([
+			fauxAssistantMessage(fauxToolCall("watchdog_warn", {
+				severity: "blocker",
+				category: "correctness",
+				confidence: "high",
+				summary: "The test claim is unverified",
+				evidence: "The delta says tests passed but no test command appears.",
+				recommendedAction: "Run the focused test before accepting the result.",
+			}), { stopReason: "toolUse" }),
+			fauxAssistantMessage("done", { stopReason: "stop" }),
+		]);
+		const warnings: WatchdogWarning[] = [];
+
+		await createMainWatchdogReview(ctx, { streamFn })(request(enabledConfig(), warnings));
+
+		assert.equal(warnings.length, 1);
+		assert.deepEqual(warnings[0], {
+			severity: "blocker",
+			category: "correctness",
+			confidence: "high",
+			source: "main",
+			summary: "The test claim is unverified",
+			evidence: "The delta says tests passed but no test command appears.",
+			recommendedAction: "Run the focused test before accepting the result.",
+		});
+	});
+
+	it("does not start the agent stream when the review request signal is already aborted", async () => {
+		const current = model("openai", "gpt-pre-abort");
+		const ctx = createCtx({ current });
+		const controller = new AbortController();
+		controller.abort();
+		let streamStarted = false;
+		const streamFn: StreamFn = () => {
+			streamStarted = true;
+			return responseStream(fauxAssistantMessage("should not start", { stopReason: "stop" }));
+		};
+		const warnings: WatchdogWarning[] = [];
+
+		const result = await createMainWatchdogReview(ctx, { streamFn })(
+			{ ...request(enabledConfig(), warnings), signal: controller.signal },
+		);
+
+		assert.equal(streamStarted, false);
+		assert.equal(result?.stopReason, "aborted");
+	});
+
+	it("does not start the agent stream when the review request aborts during model setup", async () => {
+		const current = model("openai", "gpt-setup-abort");
+		const controller = new AbortController();
+		let releaseAuth!: () => void;
+		const authStarted = new Promise<void>((resolve) => { releaseAuth = resolve; });
+		let streamStarted = false;
+		const ctx = {
+			...createCtx({ current }),
+			modelRegistry: {
+				...createCtx({ current }).modelRegistry,
+				async getApiKeyAndHeaders(entry: Model<any>) {
+					await authStarted;
+					return { ok: true as const, apiKey: `key-${entry.provider}-${entry.id}` };
+				},
+			},
+		} as never;
+		const streamFn: StreamFn = () => {
+			streamStarted = true;
+			return responseStream(fauxAssistantMessage("should not start", { stopReason: "stop" }));
+		};
+		const warnings: WatchdogWarning[] = [];
+
+		const review = createMainWatchdogReview(ctx, { streamFn })(
+			{ ...request(enabledConfig(), warnings), signal: controller.signal },
+		);
+		controller.abort();
+		releaseAuth();
+		const result = await review;
+
+		assert.equal(streamStarted, false);
+		assert.equal(result?.stopReason, "aborted");
+	});
+
+	it("aborts the underlying agent stream when the review request signal aborts", async () => {
+		const current = model("openai", "gpt-abort");
+		const ctx = createCtx({ current });
+		const controller = new AbortController();
+		let streamStarted!: () => void;
+		let streamAborted = false;
+		const started = new Promise<void>((resolve) => { streamStarted = resolve; });
+		const streamFn: StreamFn = (_nextModel, _context, options) => {
+			const stream = createAssistantMessageEventStream();
+			options?.signal?.addEventListener("abort", () => {
+				streamAborted = true;
+				stream.push({ type: "error", reason: "aborted", error: fauxAssistantMessage("aborted", { stopReason: "aborted" }) });
+			}, { once: true });
+			streamStarted();
+			return stream;
+		};
+		const warnings: WatchdogWarning[] = [];
+
+		const review = createMainWatchdogReview(ctx, { streamFn })(
+			{ ...request(enabledConfig(), warnings), signal: controller.signal },
+		);
+		await started;
+		controller.abort();
+		const result = await review;
+
+		assert.equal(streamAborted, true);
+		assert.equal(result?.stopReason, "aborted");
+	});
+
+	it("does not expose mutating tools to the watchdog agent", async () => {
+		const current = model("openai", "gpt-readonly");
+		const ctx = createCtx({ current });
+		const { streamFn, calls } = createStreamFn([
+			fauxAssistantMessage(fauxToolCall("bash", { command: "touch should-not-run" }), { stopReason: "toolUse" }),
+			fauxAssistantMessage("done", { stopReason: "stop" }),
+		]);
+		const warnings: WatchdogWarning[] = [];
+
+		await createMainWatchdogReview(ctx, { streamFn })(request(enabledConfig(), warnings));
+
+		assert.equal(warnings.length, 0);
+		assert.deepEqual(calls[0]?.context.tools?.map((tool) => tool.name).sort(), ["find", "grep", "ls", "read", "watchdog_warn"]);
+		const toolResult = calls[1]?.context.messages.find((message) => message.role === "toolResult" && message.toolName === "bash");
+		assert.equal(toolResult?.isError, true);
+	});
+
+	it("fails loudly for explicit unauthenticated watchdog models", async () => {
+		const current = model("openai", "gpt-current");
+		const watchdog = model("anthropic", "claude-watchdog");
+		const ctx = createCtx({ current, models: [current, watchdog], authenticated: [`${current.provider}/${current.id}`] });
+
+		await assert.rejects(
+			() => resolveWatchdogReviewModel(ctx, enabledConfig({ model: "anthropic/claude-watchdog" })),
+			/authenticated.*anthropic/s,
+		);
+	});
+
+	it("fails loudly for explicit missing watchdog models", async () => {
+		const current = model("openai", "gpt-current");
+		const ctx = createCtx({ current });
+
+		await assert.rejects(
+			() => resolveWatchdogReviewModel(ctx, enabledConfig({ model: "anthropic/missing-watchdog" })),
+			/was not found.*anthropic\/missing-watchdog/s,
+		);
+	});
+
+	it("uses the registered stream for matching custom providers", async () => {
+		const current = model("custom-provider", "watchdog", { api: "custom-api" });
+		const { streamFn, calls } = createStreamFn([fauxAssistantMessage("clean", { stopReason: "stop" })]);
+		const ctx = createCtx({ current, providerConfig: { provider: current.provider, api: "custom-api", streamSimple: streamFn } });
+		const warnings: WatchdogWarning[] = [];
+
+		const result = await createMainWatchdogReview(ctx)(request(enabledConfig(), warnings));
+
+		assert.equal(result?.stopReason, "stop");
+		assert.equal(calls.length, 1);
+		assert.equal(calls[0]?.model, current);
+		assert.equal(calls[0]?.options?.apiKey, "key-custom-provider-watchdog");
+		assert.equal(calls[0]?.options?.headers?.["x-model"], "watchdog");
+		assert.deepEqual(calls[0]?.options?.env, { WATCHDOG_PROVIDER: "custom-provider" });
+	});
+
+	it("falls back to the current session model and thinking when no watchdog model is configured", async () => {
+		const current = model("github-copilot", "gpt-session");
+		const ctx = createCtx({ current });
+		const { streamFn, calls } = createStreamFn([fauxAssistantMessage("clean", { stopReason: "stop" })]);
+		const warnings: WatchdogWarning[] = [];
+
+		await createMainWatchdogReview(ctx, { streamFn, getThinkingLevel: () => "high" })(request(enabledConfig(), warnings));
+
+		assert.equal(calls[0]?.model, current);
+		assert.equal(calls[0]?.options?.apiKey, "key-github-copilot-gpt-session");
+		assert.equal(calls[0]?.options?.reasoning, "high");
+		assert.deepEqual(calls[0]?.options?.env, { WATCHDOG_PROVIDER: "github-copilot" });
+	});
+
+	it("resolves configured model suffixes and thinking deterministically", async () => {
+		const current = model("openai", "gpt-current");
+		const dated = model("openai", "gpt-5-20260707");
+		const ctx = createCtx({ current, models: [current, dated] });
+
+		const suffixWins = await resolveWatchdogReviewModel(ctx, enabledConfig({ model: "openai.gpt_5:high", thinking: "low" }));
+		const explicitOff = await resolveWatchdogReviewModel(ctx, enabledConfig({ model: "openai/gpt-5-20260707", thinking: false }));
+		const suffixBeatsFalse = await resolveWatchdogReviewModel(ctx, enabledConfig({ model: "openai/gpt-5-20260707:medium", thinking: false }));
+
+		assert.equal(suffixWins.model, dated);
+		assert.equal(suffixWins.thinkingLevel, "high");
+		assert.equal(explicitOff.model, dated);
+		assert.equal(explicitOff.thinkingLevel, "off");
+		assert.equal(suffixBeatsFalse.model, dated);
+		assert.equal(suffixBeatsFalse.thinkingLevel, "medium");
+	});
+});