pi-subagents 0.69.0 → 0.70.0

package/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/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 DEFAULT_MAX_HASH_FILE_BYTES = 64 * 1024 * 1024;
-const DEFAULT_MAX_HASH_TOTAL_BYTES = 64 * 1024 * 1024;
-const DEFAULT_MAX_HASH_ENTRIES = 2_000;
-const TRACKED_ENTRY_PROBE_MAX_BYTES = 1_024;
-
-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("PI_SUBAGENTS_MAX_HASH_FILE_BYTES", DEFAULT_MAX_HASH_FILE_BYTES);
-}
-
-function maxHashTotalBytes(): number {
-	return positiveEnvNumber("PI_SUBAGENTS_MAX_HASH_TOTAL_BYTES", DEFAULT_MAX_HASH_TOTAL_BYTES);
-}
-
-function maxHashEntries(): number {
-	return positiveEnvNumber("PI_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/src/watchdog/child-status.ts

@@ -1,225 +0,0 @@
-import type { ChildWatchdogProgress, ChildWatchdogWarningSummary } from "../shared/types.ts";
-import { WATCHDOG_WARNING_CATEGORIES, WATCHDOG_WARNING_IMPORTANCES, type ResolvedWatchdogConfig, type WatchdogCadenceConfig, type WatchdogLspConfig } from "./types.ts";
-
-export const CHILD_WATCHDOG_WARNING_LIMIT = 20;
-
-export const CHILD_WATCHDOG_STATUS_EVENT = "subagent.watchdog.status";
-
-export const CHILD_WATCHDOG_PHASES = ["idle", "reviewing", "stale", "failed"] as const;
-export type ChildWatchdogPhase = typeof CHILD_WATCHDOG_PHASES[number];
-
-export interface ChildWatchdogConfig {
-	runId?: string;
-	agent?: string;
-	childIndex?: number;
-	watchdogTailTimeoutMs: number;
-	agentEndTimeoutMs: number;
-	maxWarnings: number | null;
-	model?: string;
-	thinking?: string | false;
-	lsp: WatchdogLspConfig;
-	stalemateRepeats: number;
-	/** Mid-run review cadence; everyNTools null means boundary reviews only. */
-	cadence: WatchdogCadenceConfig;
-}
-
-export interface ChildWatchdogStatusEvent {
-	type: typeof CHILD_WATCHDOG_STATUS_EVENT;
-	runId?: string;
-	agent?: string;
-	childIndex?: number;
-	stepIndex?: number;
-	seq: number;
-	phase: ChildWatchdogPhase;
-	ts: number;
-	reason?: string;
-	warning?: ChildWatchdogWarningSummary;
-}
-
-export type ChildWatchdogStateSnapshot = ChildWatchdogProgress;
-
-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;
-	const cadence = override?.cadence ?? input.config.children.cadence ?? input.config.cadence;
-	return {
-		...(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 },
-		stalemateRepeats: input.config.stalemateRepeats,
-		cadence: { everyNTools: cadence.everyNTools ?? null },
-	};
-}
-
-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 childConfigCadence(value: unknown): WatchdogCadenceConfig {
-	const input = childConfigObject(value, "cadence");
-	const everyNTools = input.everyNTools;
-	if (everyNTools === null) return { everyNTools: null };
-	if (typeof everyNTools === "number" && Number.isInteger(everyNTools) && everyNTools >= 5) return { everyNTools };
-	throw new Error("Invalid child watchdog config: cadence.everyNTools must be null or an integer >= 5.");
-}
-
-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 (Object.hasOwn(parsed, "fallbackModels")) {
-		throw new Error("Invalid child watchdog config: fallbackModels was removed; configure one model instead.");
-	}
-	if (parsed.enabled === false) return undefined;
-	if ("enabled" in parsed && 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 {
-		...(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),
-		stalemateRepeats: childConfigPositiveInteger(parsed, "stalemateRepeats"),
-		cadence: childConfigCadence(parsed.cadence),
-	};
-}
-
-export function isChildWatchdogStatusEvent(value: unknown): value is ChildWatchdogStatusEvent {
-	if (!value || typeof value !== "object") return false;
-	const event = value as Partial<ChildWatchdogStatusEvent>;
-	const warningValue = event.warning;
-	const warning = warningValue as Partial<ChildWatchdogWarningSummary>;
-	const validWarning = warningValue === undefined || (warningValue !== null && typeof warningValue === "object" && !Array.isArray(warningValue)
-		&& (warning.severity === "concern" || warning.severity === "blocker")
-		&& typeof warning.importance === "string" && (WATCHDOG_WARNING_IMPORTANCES as readonly string[]).includes(warning.importance)
-		&& typeof warning.category === "string" && (WATCHDOG_WARNING_CATEGORIES as readonly string[]).includes(warning.category)
-		&& typeof warning.summary === "string" && typeof warning.evidence === "string" && typeof warning.recommendedAction === "string"
-		&& typeof warning.addressed === "boolean" && typeof warning.stalemate === "boolean"
-		&& (warning.displayedAt === undefined || typeof warning.displayedAt === "string"));
-	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.phase === "string"
-		&& (CHILD_WATCHDOG_PHASES as readonly string[]).includes(event.phase)
-		&& validWarning;
-}
-
-export function childWatchdogIsActive(snapshot: ChildWatchdogStateSnapshot | undefined): boolean {
-	if (!snapshot) return false;
-	return snapshot.phase === "reviewing";
-}
-
-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;
-	const warnings = input.event.warning
-		? [...(input.current?.warnings ?? []), input.event.warning].slice(-CHILD_WATCHDOG_WARNING_LIMIT)
-		: input.current?.warnings;
-	return {
-		phase: input.event.phase,
-		seq: input.event.seq,
-		lastUpdate: input.event.ts,
-		...(input.event.reason ? { reason: input.event.reason } : {}),
-		...(warnings?.length ? { warnings } : {}),
-	};
-}
-
-/** An assistant turn marks earlier warnings addressed. Undefined when unchanged. */
-export function applyChildWatchdogMessage(current: ChildWatchdogStateSnapshot | undefined, message: unknown): ChildWatchdogStateSnapshot | undefined {
-	if ((message as { role?: unknown } | undefined)?.role !== "assistant" || !current?.warnings?.some((entry) => !entry.addressed)) return undefined;
-	return { ...current, warnings: current.warnings.map((entry) => entry.addressed ? entry : { ...entry, addressed: true }) };
-}
-
-export function unresolvedChildWatchdogBlockers(progress: Pick<ChildWatchdogProgress, "warnings"> | undefined): ChildWatchdogWarningSummary[] {
-	return (progress?.warnings ?? []).filter((warning) => warning.severity === "blocker" && (!warning.addressed || warning.stalemate));
-}
-
-export function childWatchdogProgressForModel(progress: ChildWatchdogProgress | undefined): ChildWatchdogProgress | undefined {
-	if (!progress) return undefined;
-	const warnings = (progress.warnings ?? []).filter((warning) => warning.importance === "high");
-	return { ...progress, warnings: warnings.length ? warnings : undefined };
-}

package/src/watchdog/diff-tool.ts

@@ -1,77 +0,0 @@
-import { spawnSync } from "node:child_process";
-import * as path from "node:path";
-import type { AgentTool } from "@earendil-works/pi-agent-core";
-import { Type, type Static } from "typebox";
-
-export const WATCHDOG_DIFF_TOOL_NAME = "watchdog_diff";
-export const WATCHDOG_DIFF_MAX_CHARS = 24_000;
-const MAX_UNTRACKED_FILES = 50;
-
-export interface WatchdogDiffBaseline {
-	root: string;
-	ref: string;
-}
-
-const WatchdogDiffParams = Type.Object({
-	path: Type.Optional(Type.String({ description: "Restrict the diff to one file or directory, relative to the repo root." })),
-	stat: Type.Optional(Type.Boolean({ description: "Return per-file change counts instead of the full diff." })),
-}, { additionalProperties: false });
-
-type WatchdogDiffParams = Static<typeof WatchdogDiffParams>;
-
-function runGit(root: string, args: string[]): { ok: boolean; stdout: string; stderr: string } {
-	const result = spawnSync("git", ["-C", root, ...args], { encoding: "utf-8", maxBuffer: 16 * 1024 * 1024, windowsHide: true });
-	return { ok: result.status === 0, stdout: result.stdout ?? "", stderr: (result.stderr ?? "").trim() };
-}
-
-/** HEAD at session start, so later child commits still show in the diff. */
-export function captureWatchdogDiffBaseline(cwd: string): WatchdogDiffBaseline | undefined {
-	const toplevel = runGit(cwd, ["rev-parse", "--show-toplevel"]);
-	if (!toplevel.ok) return undefined;
-	const head = runGit(cwd, ["rev-parse", "HEAD"]);
-	if (!head.ok) return undefined;
-	const root = toplevel.stdout.trim();
-	const ref = head.stdout.trim();
-	return root && ref ? { root, ref } : undefined;
-}
-
-function validatePath(value: string | undefined): string | undefined {
-	const trimmed = value?.trim();
-	if (!trimmed) return undefined;
-	if (trimmed.startsWith("-")) throw new Error("watchdog_diff path must not start with '-'.");
-	if (path.isAbsolute(trimmed)) throw new Error("watchdog_diff path must be relative to the repo root.");
-	if (trimmed.split(/[\\/]/).includes("..")) throw new Error("watchdog_diff path must not contain '..'.");
-	return trimmed;
-}
-
-function bound(text: string): string {
-	if (text.length <= WATCHDOG_DIFF_MAX_CHARS) return text;
-	const marker = `\n\n[... ${text.length - WATCHDOG_DIFF_MAX_CHARS} characters omitted; call again with a narrower path ...]`;
-	return `${text.slice(0, WATCHDOG_DIFF_MAX_CHARS - marker.length)}${marker}`;
-}
-
-/** In a shared cwd, changes already pending when the session started also appear. */
-export function createWatchdogDiffTool(baseline: WatchdogDiffBaseline): AgentTool<typeof WatchdogDiffParams, { chars: number }> {
-	return {
-		name: WATCHDOG_DIFF_TOOL_NAME,
-		label: "Watchdog diff",
-		description: "Show the repository diff since the review baseline, plus untracked file paths. Optional path narrows it; stat:true returns per-file counts only.",
-		parameters: WatchdogDiffParams,
-		executionMode: "sequential",
-		async execute(_toolCallId, params: WatchdogDiffParams) {
-			const pathFilter = validatePath(params.path);
-			const diff = runGit(baseline.root, ["diff", "--no-color", "--no-ext-diff", ...(params.stat === true ? ["--stat"] : []), baseline.ref, "--", ...(pathFilter ? [pathFilter] : [])]);
-			if (!diff.ok) throw new Error(`git diff failed: ${diff.stderr || "unknown error"}`);
-			const untrackedResult = runGit(baseline.root, ["ls-files", "--others", "--exclude-standard", "-z", "--", ...(pathFilter ? [pathFilter] : [])]);
-			const untracked = untrackedResult.ok ? untrackedResult.stdout.split("\0").filter(Boolean) : [];
-			const sections = [diff.stdout.trimEnd()];
-			if (untracked.length) {
-				const shown = untracked.slice(0, MAX_UNTRACKED_FILES);
-				sections.push(["Untracked files (use read to inspect):", ...shown.map((file) => ` ${file}`)].join("\n"));
-				if (untracked.length > shown.length) sections.push(`... ${untracked.length - shown.length} more untracked files`);
-			}
-			const text = bound(sections.filter(Boolean).join("\n\n")) || `No changes since baseline ${baseline.ref.slice(0, 12)}.`;
-			return { content: [{ type: "text", text }], details: { chars: text.length } };
-		},
-	};
-}