@selesai/code 0.13.11 → 0.13.13

package/dist/extensions/pi-subagents/src/types/pi-runtime-compat.d.ts

@@ -1,8 +0,0 @@
-declare module "@earendil-works/pi-agent-core" {
-	interface AgentToolResult<T> {
-		/** Runtime error flag emitted and rendered by pi tool execution. */
-		isError?: boolean;
-	}
-}
-
-export {};

package/dist/extensions/pi-subagents/src/watchdog/change-signature.ts

@@ -1,260 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { PROJECT_SUBAGENTS_RELATIVE_DIR } from "../shared/artifacts.ts";
-
-const IGNORED_CHANGE_PREFIXES = [`${PROJECT_SUBAGENTS_RELATIVE_DIR}/`, "tmp/", "node_modules/"];
-const IGNORED_CHANGE_PATHS = new Set([PROJECT_SUBAGENTS_RELATIVE_DIR, "tmp", "node_modules"]);
-const IGNORED_CHANGE_SEGMENTS = new Set([".git", "node_modules"]);
-const TRACKED_ENTRY_PROBE_MAX_BYTES = 1_024;
-
-const DEFAULT_MAX_HASH_FILE_BYTES = 64 * 1024 * 1024;
-const DEFAULT_MAX_HASH_TOTAL_BYTES = 64 * 1024 * 1024;
-const DEFAULT_MAX_HASH_ENTRIES = 2_000;
-
-function positiveEnvNumber(name: string, fallback: number): number {
-	const parsed = Number(process.env[name]);
-	return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
-}
-
-// Read at call time (not module load) so tests can override env guards after
-// this module is imported.
-function maxHashFileBytes(): number {
-	return positiveEnvNumber("SELESAI_SUBAGENTS_MAX_HASH_FILE_BYTES", DEFAULT_MAX_HASH_FILE_BYTES);
-}
-
-function maxHashTotalBytes(): number {
-	return positiveEnvNumber("SELESAI_SUBAGENTS_MAX_HASH_TOTAL_BYTES", DEFAULT_MAX_HASH_TOTAL_BYTES);
-}
-
-function maxHashEntries(): number {
-	return positiveEnvNumber("SELESAI_SUBAGENTS_MAX_HASH_ENTRIES", DEFAULT_MAX_HASH_ENTRIES);
-}
-
-export interface WatchdogRepoChangeSignature {
-	root: string;
-	key: string;
-	changedPaths: string[];
-}
-
-function git(cwd: string, args: string[]): string | undefined {
-	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024, windowsHide: true });
-	if (result.status !== 0) return undefined;
-	return result.stdout;
-}
-
-function comparablePath(value: string): string {
-	let resolved = path.resolve(value);
-	try {
-		resolved = fs.realpathSync.native(resolved);
-	} catch {
-		// Keep the lexical path when canonicalization is unavailable.
-	}
-	return process.platform === "win32" ? resolved.toLowerCase() : resolved;
-}
-
-function isHomeRepoRoot(root: string): boolean {
-	return comparablePath(root) === comparablePath(os.homedir());
-}
-
-/**
- * Probe the index without asking Git to inspect the working tree. The output
- * cap keeps this check bounded even for repositories with a very large index;
- * an ENOBUFS result still proves that at least one tracked path exists.
- */
-function hasTrackedEntries(root: string): boolean | undefined {
-	const result = spawnSync("git", ["-C", root, "ls-files", "--cached", "--error-unmatch", "--", "."], {
-		encoding: "utf-8",
-		maxBuffer: TRACKED_ENTRY_PROBE_MAX_BYTES,
-		windowsHide: true,
-	});
-	const errorCode = (result.error as NodeJS.ErrnoException | undefined)?.code;
-	if (result.status === 0 || errorCode === "ENOBUFS") return true;
-	if (result.status === 1) return false;
-	return undefined;
-}
-
-function normalizeRelPath(value: string): string {
-	return value.replaceAll(path.sep, "/").replace(/^\.\//, "");
-}
-
-function ignoredRelPath(relPath: string): boolean {
-	const normalized = normalizeRelPath(relPath);
-	return IGNORED_CHANGE_PATHS.has(normalized)
-		|| IGNORED_CHANGE_PREFIXES.some((prefix) => normalized.startsWith(prefix))
-		|| normalized.split("/").some((segment) => IGNORED_CHANGE_SEGMENTS.has(segment));
-}
-
-interface HashBudget {
-	entries: number;
-	bytes: number;
-	maxEntries: number;
-	maxBytes: number;
-}
-
-function useHashEntryBudget(budget: HashBudget): boolean {
-	if (budget.entries >= budget.maxEntries) return false;
-	budget.entries++;
-	return true;
-}
-
-function hashFile(filePath: string): string {
-	return createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
-}
-
-function largeFileHash(stat: fs.Stats): string {
-	return "large:" + stat.size + ":" + Math.floor(stat.mtimeMs);
-}
-
-function hashFileEntry(normalized: string, fullPath: string, stat: fs.Stats, budget: HashBudget): unknown {
-	let hash: string;
-	if (stat.size > maxHashFileBytes() || budget.bytes + stat.size > budget.maxBytes) {
-		hash = largeFileHash(stat);
-	} else {
-		try {
-			hash = hashFile(fullPath);
-			budget.bytes += stat.size;
-		} catch (error) {
-			const code = (error as NodeJS.ErrnoException).code;
-			// A file racing away between lstat and read: mirror the lstat ENOENT path.
-			if (code === "ENOENT") return { path: normalized, state: "deleted" };
-			// Any other read failure (too-large, EACCES, EISDIR, ...) degrades to the
-			// metadata marker so one unreadable file never discards the whole signature.
-			hash = largeFileHash(stat);
-			if (code !== "ERR_FS_FILE_TOO_LARGE") {
-				console.warn("[pi-subagents] watchdog hashFile fell back to metadata for", normalized + ":", (error as Error)?.message);
-			}
-		}
-	}
-	return { path: normalized, state: "file", mode: stat.mode & 0o777, size: stat.size, hash };
-}
-
-function gitWorktreeEntry(normalized: string, fullPath: string): unknown {
-	const status = git(fullPath, ["status", "--porcelain=v1", "-z", "--untracked-files=no"]);
-	return {
-		path: normalized,
-		state: "git-worktree",
-		head: git(fullPath, ["rev-parse", "HEAD"])?.trim(),
-		dirty: Boolean(status),
-		statusKey: status ? createHash("sha256").update(status).digest("hex") : undefined,
-	};
-}
-
-function hashPath(root: string, relPath: string, budget: HashBudget): unknown {
-	const normalized = normalizeRelPath(relPath);
-	if (!useHashEntryBudget(budget)) return { path: normalized, state: "skipped", reason: "entry-limit" };
-	const fullPath = path.join(root, normalized);
-	let stat: fs.Stats;
-	try {
-		stat = fs.lstatSync(fullPath);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return { path: normalized, state: "deleted" };
-		throw error;
-	}
-	if (stat.isSymbolicLink()) {
-		return { path: normalized, state: "symlink", target: fs.readlinkSync(fullPath) };
-	}
-	if (stat.isDirectory()) {
-		if (fs.existsSync(path.join(fullPath, ".git"))) return gitWorktreeEntry(normalized, fullPath);
-		const entries = fs.readdirSync(fullPath)
-			.map((entry) => normalizeRelPath(path.posix.join(normalized, entry)))
-			.filter((entry) => !ignoredRelPath(entry))
-			.sort();
-		const remainingEntries = Math.max(0, budget.maxEntries - budget.entries);
-		const selectedEntries = entries.slice(0, remainingEntries);
-		const childEntries = selectedEntries.map((entry) => hashPath(root, entry, budget));
-		if (selectedEntries.length < entries.length) {
-			childEntries.push({ path: normalized, state: "skipped-children", reason: "entry-limit", count: entries.length - selectedEntries.length });
-		}
-		return { path: normalized, state: "dir", entries: childEntries };
-	}
-	if (stat.isFile()) return hashFileEntry(normalized, fullPath, stat, budget);
-	return { path: normalized, state: "other", mode: stat.mode };
-}
-
-function parsePorcelainZ(raw: string): Array<{ status: string; paths: string[] }> {
-	const tokens = raw.split("\0").filter(Boolean);
-	const entries: Array<{ status: string; paths: string[] }> = [];
-	for (let index = 0; index < tokens.length; index++) {
-		const token = tokens[index]!;
-		if (token.length < 4) continue;
-		const status = token.slice(0, 2);
-		const relPath = token.slice(3);
-		const paths = [relPath];
-		if (status[0] === "R" || status[0] === "C") {
-			const originalPath = tokens[++index];
-			if (originalPath) paths.push(originalPath);
-		}
-		entries.push({ status, paths });
-	}
-	return entries;
-}
-
-function buildRepoChangeSignature(root: string, statusOutput: string): WatchdogRepoChangeSignature {
-	const entries = parsePorcelainZ(statusOutput)
-		.map((entry) => ({
-			status: entry.status,
-			paths: entry.paths.map(normalizeRelPath).filter((relPath) => !ignoredRelPath(relPath)),
-		}))
-		.filter((entry) => entry.paths.length > 0)
-		.sort((a, b) => `${a.status} ${a.paths.join("\0")}`.localeCompare(`${b.status} ${b.paths.join("\0")}`));
-	const changedPaths = [...new Set(entries.flatMap((entry) => entry.paths))].sort();
-	const budget: HashBudget = { entries: 0, bytes: 0, maxEntries: maxHashEntries(), maxBytes: maxHashTotalBytes() };
-	const payload = entries.map((entry) => ({
-		status: entry.status,
-		paths: entry.paths,
-		content: entry.paths.map((relPath) => hashPath(root, relPath, budget)),
-	}));
-	const key = createHash("sha256").update(JSON.stringify(payload)).digest("hex");
-	return { root, key, changedPaths };
-}
-
-export function computeWatchdogRepoChangeSignature(cwd: string): WatchdogRepoChangeSignature | undefined {
-	const root = git(cwd, ["rev-parse", "--show-toplevel"])?.trim();
-	if (!root) return undefined;
-	const skipUntracked = isHomeRepoRoot(root) || hasTrackedEntries(root) === false;
-	const statusOutput = git(root, [
-		"status",
-		"--porcelain=v1",
-		"-z",
-		`--untracked-files=${skipUntracked ? "no" : "all"}`,
-	]);
-	if (statusOutput === undefined) return undefined;
-	try {
-		return buildRepoChangeSignature(root, statusOutput);
-	} catch (error) {
-		console.warn("[pi-subagents] watchdog repo change signature failed:", (error as Error)?.message);
-		return undefined;
-	}
-}
-
-function toolNameFromMessage(message: Record<string, unknown>): string {
-	const value = message.toolName ?? message.name;
-	return typeof value === "string" ? value : "";
-}
-
-function toolResultSucceeded(message: Record<string, unknown>): boolean {
-	return message.isError !== true && message.error === undefined;
-}
-
-function messageIndicatesRepoEdit(message: unknown): boolean {
-	if (!message || typeof message !== "object") return false;
-	const input = message as Record<string, unknown>;
-	const role = input.role;
-	if (role !== "toolResult" && role !== "tool") return false;
-	const toolName = toolNameFromMessage(input);
-	return (toolName === "edit" || toolName === "write") && toolResultSucceeded(input);
-}
-
-export function eventIndicatesRepoEdit(event: unknown): boolean {
-	if (!event || typeof event !== "object") return false;
-	const input = event as Record<string, unknown>;
-	if (input.type === "turn_end" || input.event === "turn_end") {
-		return [input.message, ...(Array.isArray(input.toolResults) ? input.toolResults : [])].some(messageIndicatesRepoEdit);
-	}
-	if (input.type === "tool_result" || input.event === "tool_result") return messageIndicatesRepoEdit({ role: "toolResult", ...input });
-	if (input.type !== "tool_result_end" && input.event !== "tool_result_end") return false;
-	return messageIndicatesRepoEdit(input.message);
-}

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

@@ -1,205 +0,0 @@
-import type { ResolvedWatchdogConfig, WatchdogLspConfig } from "./types.ts";
-
-export const CHILD_WATCHDOG_CONFIG_ENV = "SELESAI_SUBAGENT_WATCHDOG_CHILD_CONFIG";
-export const CHILD_WATCHDOG_STATUS_EVENT = "subagent.watchdog.status";
-
-export const CHILD_WATCHDOG_PHASES = ["idle", "reviewing", "autofollow", "settling", "stale", "failed"] as const;
-export type ChildWatchdogPhase = typeof CHILD_WATCHDOG_PHASES[number];
-
-export interface ChildWatchdogConfig {
-	enabled: boolean;
-	runId?: string;
-	agent?: string;
-	childIndex?: number;
-	watchdogTailTimeoutMs: number;
-	agentEndTimeoutMs: number;
-	maxWarnings: number | null;
-	model?: string;
-	thinking?: string | false;
-	lsp: WatchdogLspConfig;
-	autoFollowBlockers: boolean;
-	autoFollowMaxAttempts: number | null;
-	stalemateRepeats: number;
-}
-
-export interface ChildWatchdogStatusEvent {
-	type: typeof CHILD_WATCHDOG_STATUS_EVENT;
-	runId?: string;
-	agent?: string;
-	childIndex?: number;
-	stepIndex?: number;
-	seq: number;
-	phase: ChildWatchdogPhase;
-	ts: number;
-	followUpPending: boolean;
-	reason?: string;
-}
-
-export interface ChildWatchdogStateSnapshot {
-	phase: ChildWatchdogPhase;
-	seq: number;
-	lastUpdate: number;
-	followUpPending: boolean;
-	reason?: string;
-	timedOut?: boolean;
-}
-
-export function resolveChildWatchdogConfig(input: {
-	config: ResolvedWatchdogConfig;
-	agent?: string;
-	runId?: string;
-	childIndex?: number;
-}): ChildWatchdogConfig | undefined {
-	const override = input.agent ? input.config.children.overrides[input.agent] : undefined;
-	const enabled = input.config.enabled && (override?.enabled ?? input.config.children.enabled);
-	if (!enabled) return undefined;
-	const model = override?.model ?? input.config.children.model;
-	const thinking = override?.thinking ?? input.config.children.thinking;
-	return {
-		enabled: true,
-		...(input.runId ? { runId: input.runId } : {}),
-		...(input.agent ? { agent: input.agent } : {}),
-		...(input.childIndex !== undefined ? { childIndex: input.childIndex } : {}),
-		watchdogTailTimeoutMs: input.config.children.watchdogTailTimeoutMs,
-		agentEndTimeoutMs: input.config.agentEndTimeoutMs,
-		maxWarnings: input.config.maxWarnings,
-		...(model ? { model } : {}),
-		...(thinking !== undefined ? { thinking } : {}),
-		lsp: { ...input.config.lsp },
-		autoFollowBlockers: input.config.children.autoFollow.blockers,
-		autoFollowMaxAttempts: input.config.children.autoFollow.maxAttempts,
-		stalemateRepeats: input.config.children.autoFollow.stalemateRepeats,
-	};
-}
-
-export function encodeChildWatchdogConfig(config: ChildWatchdogConfig | undefined): string | undefined {
-	return config ? JSON.stringify(config) : undefined;
-}
-
-function childConfigObject(value: unknown, field: string): Record<string, unknown> {
-	if (value && typeof value === "object" && !Array.isArray(value)) return value as Record<string, unknown>;
-	throw new Error(`Invalid child watchdog config: ${field} must be an object.`);
-}
-
-function childConfigOptionalString(input: Record<string, unknown>, field: string): string | undefined {
-	if (!(field in input)) return undefined;
-	const value = input[field];
-	if (typeof value === "string" && value.trim()) return value;
-	throw new Error(`Invalid child watchdog config: ${field} must be a non-empty string.`);
-}
-
-function childConfigOptionalIndex(input: Record<string, unknown>, field: string): number | undefined {
-	if (!(field in input)) return undefined;
-	const value = input[field];
-	if (typeof value === "number" && Number.isInteger(value) && value >= 0) return value;
-	throw new Error(`Invalid child watchdog config: ${field} must be a non-negative integer.`);
-}
-
-function childConfigPositiveInteger(input: Record<string, unknown>, field: string): number {
-	const value = input[field];
-	if (typeof value === "number" && Number.isInteger(value) && value >= 1) return value;
-	throw new Error(`Invalid child watchdog config: ${field} must be a positive integer.`);
-}
-
-function childConfigNullableNonNegativeInteger(input: Record<string, unknown>, field: string): number | null {
-	const value = input[field];
-	if (value === null) return null;
-	if (typeof value === "number" && Number.isInteger(value) && value >= 0) return value;
-	throw new Error(`Invalid child watchdog config: ${field} must be null or a non-negative integer.`);
-}
-
-function childConfigBoolean(input: Record<string, unknown>, field: string): boolean {
-	const value = input[field];
-	if (typeof value === "boolean") return value;
-	throw new Error(`Invalid child watchdog config: ${field} must be a boolean.`);
-}
-
-function childConfigLsp(value: unknown): WatchdogLspConfig {
-	const input = childConfigObject(value, "lsp");
-	if (typeof input.enabled !== "boolean") throw new Error("Invalid child watchdog config: lsp.enabled must be a boolean.");
-	if (typeof input.timeoutMs !== "number" || !Number.isInteger(input.timeoutMs) || input.timeoutMs < 1) {
-		throw new Error("Invalid child watchdog config: lsp.timeoutMs must be a positive integer.");
-	}
-	if (typeof input.maxFiles !== "number" || !Number.isInteger(input.maxFiles) || input.maxFiles < 1) {
-		throw new Error("Invalid child watchdog config: lsp.maxFiles must be a positive integer.");
-	}
-	if (typeof input.maxDiagnostics !== "number" || !Number.isInteger(input.maxDiagnostics) || input.maxDiagnostics < 0) {
-		throw new Error("Invalid child watchdog config: lsp.maxDiagnostics must be a non-negative integer.");
-	}
-	return {
-		enabled: input.enabled,
-		timeoutMs: input.timeoutMs,
-		maxFiles: input.maxFiles,
-		maxDiagnostics: input.maxDiagnostics,
-	};
-}
-
-export function decodeChildWatchdogConfig(raw: string | undefined): ChildWatchdogConfig | undefined {
-	if (!raw) return undefined;
-	const parsed = childConfigObject(JSON.parse(raw), "root");
-	if (parsed.enabled === false) return undefined;
-	if (parsed.enabled !== true) throw new Error("Invalid child watchdog config: enabled must be true or false.");
-	const thinking = parsed.thinking;
-	if (thinking !== undefined && typeof thinking !== "string" && thinking !== false) {
-		throw new Error("Invalid child watchdog config: thinking must be a string or false.");
-	}
-	const runId = childConfigOptionalString(parsed, "runId");
-	const agent = childConfigOptionalString(parsed, "agent");
-	const childIndex = childConfigOptionalIndex(parsed, "childIndex");
-	const model = childConfigOptionalString(parsed, "model");
-	return {
-		enabled: true,
-		...(runId ? { runId } : {}),
-		...(agent ? { agent } : {}),
-		...(childIndex !== undefined ? { childIndex } : {}),
-		watchdogTailTimeoutMs: childConfigPositiveInteger(parsed, "watchdogTailTimeoutMs"),
-		agentEndTimeoutMs: childConfigPositiveInteger(parsed, "agentEndTimeoutMs"),
-		maxWarnings: childConfigNullableNonNegativeInteger(parsed, "maxWarnings"),
-		...(model ? { model } : {}),
-		...(thinking !== undefined ? { thinking: thinking as string | false } : {}),
-		lsp: childConfigLsp(parsed.lsp),
-		autoFollowBlockers: childConfigBoolean(parsed, "autoFollowBlockers"),
-		autoFollowMaxAttempts: childConfigNullableNonNegativeInteger(parsed, "autoFollowMaxAttempts"),
-		stalemateRepeats: childConfigPositiveInteger(parsed, "stalemateRepeats"),
-	};
-}
-
-export function isChildWatchdogStatusEvent(value: unknown): value is ChildWatchdogStatusEvent {
-	if (!value || typeof value !== "object") return false;
-	const event = value as Partial<ChildWatchdogStatusEvent>;
-	return event.type === CHILD_WATCHDOG_STATUS_EVENT
-		&& typeof event.seq === "number"
-		&& Number.isInteger(event.seq)
-		&& event.seq >= 0
-		&& typeof event.ts === "number"
-		&& Number.isFinite(event.ts)
-		&& typeof event.followUpPending === "boolean"
-		&& typeof event.phase === "string"
-		&& (CHILD_WATCHDOG_PHASES as readonly string[]).includes(event.phase);
-}
-
-export function childWatchdogIsActive(snapshot: ChildWatchdogStateSnapshot | undefined): boolean {
-	if (!snapshot) return false;
-	return snapshot.followUpPending || snapshot.phase === "reviewing" || snapshot.phase === "autofollow" || snapshot.phase === "settling";
-}
-
-export function acceptChildWatchdogEvent(input: {
-	current: ChildWatchdogStateSnapshot | undefined;
-	event: ChildWatchdogStatusEvent;
-	runId?: string;
-	agent?: string;
-	childIndex?: number;
-}): ChildWatchdogStateSnapshot | undefined {
-	if (input.runId !== undefined && input.event.runId !== input.runId) return undefined;
-	if (input.agent !== undefined && input.event.agent !== input.agent) return undefined;
-	const eventIndex = input.event.childIndex ?? input.event.stepIndex;
-	if (input.childIndex !== undefined && eventIndex !== input.childIndex) return undefined;
-	if (input.current && input.event.seq <= input.current.seq) return undefined;
-	return {
-		phase: input.event.phase,
-		seq: input.event.seq,
-		lastUpdate: input.event.ts,
-		followUpPending: input.event.followUpPending,
-		...(input.event.reason ? { reason: input.event.reason } : {}),
-	};
-}

package/dist/extensions/pi-subagents/src/watchdog/emission-guard.ts

@@ -1,123 +0,0 @@
-import type { WatchdogSeverity, WatchdogWarning } from "./types.ts";
-
-export type WatchdogEmissionSuppressionReason = "content-free" | "duplicate" | "max-warnings" | "update-budget";
-
-export type WatchdogEmissionDecision = {
-	accepted: true;
-	identity: string;
-	underlyingIdentity: string;
-	escalation: boolean;
-} | {
-	accepted: false;
-	reason: WatchdogEmissionSuppressionReason;
-	identity?: string;
-	underlyingIdentity?: string;
-};
-
-export interface WatchdogEmissionGuardOptions {
-	maxWarnings?: number | null;
-	dedupeHistoryLimit?: number;
-}
-
-const CONTENT_FREE_PHRASES = new Set([
-	"stop",
-	"done",
-	"complete",
-	"completed",
-	"no issue",
-	"no issues",
-	"no concern",
-	"no concerns",
-	"nothing to add",
-	"lgtm",
-	"looks good",
-	"looks good to me",
-	"all good",
-	"ok",
-	"okay",
-	"none",
-	"n a",
-]);
-
-export function normalizeWatchdogEmissionText(value: string): string {
-	return value
-		.normalize("NFKC")
-		.toLowerCase()
-		.replace(/[’'`]/g, "")
-		.replace(/[^\p{L}\p{N}]+/gu, " ")
-		.replace(/\s+/g, " ")
-		.trim();
-}
-
-export function watchdogWarningUnderlyingIdentity(warning: Pick<WatchdogWarning, "summary" | "evidence">): string {
-	return [normalizeWatchdogEmissionText(warning.summary), normalizeWatchdogEmissionText(warning.evidence)].join("\n");
-}
-
-export function watchdogWarningIdentity(warning: Pick<WatchdogWarning, "severity" | "summary" | "evidence">): string {
-	return [warning.severity, watchdogWarningUnderlyingIdentity(warning)].join("\n");
-}
-
-function isContentFree(value: string): boolean {
-	const normalized = normalizeWatchdogEmissionText(value);
-	return !normalized || CONTENT_FREE_PHRASES.has(normalized);
-}
-
-export class WatchdogEmissionGuard {
-	private maxWarnings: number | null;
-	private dedupeHistoryLimit: number;
-	private acceptedCount = 0;
-	private acceptedByUnderlyingIdentity = new Map<string, WatchdogSeverity>();
-	private historyOrder: string[] = [];
-	private updateAcceptedUnderlyingIdentity: string | undefined;
-	private updateAcceptedSeverity: WatchdogSeverity | undefined;
-
-	constructor(options: WatchdogEmissionGuardOptions = {}) {
-		this.maxWarnings = options.maxWarnings ?? null;
-		this.dedupeHistoryLimit = options.dedupeHistoryLimit ?? 200;
-	}
-
-	startModelUpdate(): void {
-		this.updateAcceptedUnderlyingIdentity = undefined;
-		this.updateAcceptedSeverity = undefined;
-	}
-
-	reset(): void {
-		this.acceptedCount = 0;
-		this.acceptedByUnderlyingIdentity.clear();
-		this.historyOrder = [];
-		this.startModelUpdate();
-	}
-
-	evaluate(warning: WatchdogWarning): WatchdogEmissionDecision {
-		if (isContentFree(warning.summary) || isContentFree(warning.evidence) || isContentFree(warning.recommendedAction)) {
-			return { accepted: false, reason: "content-free" };
-		}
-		const underlyingIdentity = watchdogWarningUnderlyingIdentity(warning);
-		const identity = watchdogWarningIdentity(warning);
-		const priorSeverity = this.acceptedByUnderlyingIdentity.get(underlyingIdentity);
-		const escalation = priorSeverity === "concern" && warning.severity === "blocker";
-		if (this.updateAcceptedUnderlyingIdentity !== undefined) {
-			const updateEscalation = this.updateAcceptedUnderlyingIdentity === underlyingIdentity
-				&& this.updateAcceptedSeverity === "concern"
-				&& warning.severity === "blocker";
-			if (!updateEscalation) return { accepted: false, reason: "update-budget", identity, underlyingIdentity };
-		}
-		if (priorSeverity !== undefined && !escalation) return { accepted: false, reason: "duplicate", identity, underlyingIdentity };
-		if (this.maxWarnings !== null && this.acceptedCount >= this.maxWarnings && !escalation) {
-			return { accepted: false, reason: "max-warnings", identity, underlyingIdentity };
-		}
-
-		this.acceptedByUnderlyingIdentity.set(underlyingIdentity, warning.severity);
-		if (!priorSeverity) {
-			this.acceptedCount++;
-			this.historyOrder.push(underlyingIdentity);
-		}
-		while (this.historyOrder.length > this.dedupeHistoryLimit) {
-			const stale = this.historyOrder.shift();
-			if (stale) this.acceptedByUnderlyingIdentity.delete(stale);
-		}
-		this.updateAcceptedUnderlyingIdentity = underlyingIdentity;
-		this.updateAcceptedSeverity = warning.severity;
-		return { accepted: true, identity, underlyingIdentity, escalation };
-	}
-}