@selesai/code 0.5.20 → 0.5.21

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

@@ -0,0 +1,220 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const IGNORED_CHANGE_PREFIXES = [".pi-subagents/", "tmp/", "node_modules/"];
+const IGNORED_CHANGE_PATHS = new Set([".pi-subagents", "tmp", "node_modules"]);
+const IGNORED_CHANGE_SEGMENTS = new Set([".git", ".pi-subagents", "node_modules"]);
+
+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 });
+	if (result.status !== 0) return undefined;
+	return result.stdout;
+}
+
+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 statusOutput = git(root, ["status", "--porcelain=v1", "-z", "--untracked-files=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

@@ -0,0 +1,205 @@
+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

@@ -0,0 +1,123 @@
+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 };
+	}
+}