@selesai/code 0.5.20 → 0.5.21

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

@@ -0,0 +1,387 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import { createRequire, syncBuiltinESMExports } from "node:module";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import { computeWatchdogRepoChangeSignature } from "../../src/watchdog/change-signature.ts";
+
+// The module under test hashes file content via `fs.readFileSync`, whose ESM
+// binding cannot be reassigned (module namespaces are frozen) and mock.module is
+// gated behind an experimental flag not passed by the runner. However, the ESM
+// `readFileSync` dispatches through the CJS module's `openSync`, so patching
+// `require("node:fs").openSync` deterministically forces the inner read error
+// paths without touching lstat/readdir (which do not go through openSync).
+const require = createRequire(import.meta.url);
+const cjsFs = require("node:fs") as { openSync: typeof fs.openSync; lstatSync: typeof fs.lstatSync };
+
+function withOpenSyncError<T>(code: string, run: () => T): T {
+	const previous = cjsFs.openSync;
+	cjsFs.openSync = () => {
+		throw Object.assign(new Error("forced read failure"), { code });
+	};
+	try {
+		return run();
+	} finally {
+		cjsFs.openSync = previous;
+	}
+}
+
+function withLstatSyncError<T>(code: string, run: () => T): T {
+	const previous = cjsFs.lstatSync;
+	cjsFs.lstatSync = () => {
+		throw Object.assign(new Error("forced stat failure"), { code });
+	};
+	syncBuiltinESMExports();
+	try {
+		return run();
+	} finally {
+		cjsFs.lstatSync = previous;
+		syncBuiltinESMExports();
+	}
+}
+
+function git(cwd: string, args: string[]): string {
+	const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8" });
+	if (result.status !== 0) throw new Error(result.stderr.trim() || result.stdout.trim() || `git ${args.join(" ")} failed`);
+	return result.stdout.trim();
+}
+
+function createRepo(prefix: string): string {
+	const repo = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+	git(repo, ["init"]);
+	git(repo, ["config", "user.email", "watchdog@example.com"]);
+	git(repo, ["config", "user.name", "Watchdog Tests"]);
+	return repo;
+}
+
+describe("watchdog change signature", () => {
+	it("summarizes modified submodules as opaque Git worktrees", (t) => {
+		const childSource = createRepo("watchdog-child-");
+		const parent = createRepo("watchdog-parent-");
+		const checkout = path.join(parent, "vendor", "child");
+		const ignoredFile = path.join(checkout, "node_modules", "ignored.bin");
+		t.after(() => {
+			fs.rmSync(parent, { recursive: true, force: true });
+			fs.rmSync(childSource, { recursive: true, force: true });
+		});
+
+		fs.writeFileSync(path.join(childSource, ".gitignore"), "node_modules/\n", "utf-8");
+		fs.writeFileSync(path.join(childSource, "tracked.txt"), "one\n", "utf-8");
+		git(childSource, ["add", "-A"]);
+		git(childSource, ["commit", "-m", "initial"]);
+
+		git(parent, ["-c", "protocol.file.allow=always", "submodule", "add", childSource, "vendor/child"]);
+		git(parent, ["commit", "-am", "add submodule"]);
+		git(checkout, ["config", "user.email", "watchdog@example.com"]);
+		git(checkout, ["config", "user.name", "Watchdog Tests"]);
+
+		fs.mkdirSync(path.dirname(ignoredFile), { recursive: true });
+		fs.writeFileSync(ignoredFile, "ignored one\n", "utf-8");
+		fs.writeFileSync(path.join(checkout, "tracked.txt"), "two\n", "utf-8");
+
+		const first = computeWatchdogRepoChangeSignature(parent);
+		assert.deepEqual(first?.changedPaths, ["vendor/child"]);
+
+		fs.writeFileSync(ignoredFile, "ignored two\n", "utf-8");
+		const ignoredOnly = computeWatchdogRepoChangeSignature(parent);
+		assert.equal(ignoredOnly?.key, first?.key);
+
+		fs.writeFileSync(path.join(checkout, "tracked.txt"), "three\n", "utf-8");
+		const stillDirty = computeWatchdogRepoChangeSignature(parent);
+		assert.equal(stillDirty?.key, first?.key, "dirty submodule content is intentionally opaque");
+
+		git(checkout, ["add", "tracked.txt"]);
+		git(checkout, ["commit", "-m", "update tracked"]);
+		const headChange = computeWatchdogRepoChangeSignature(parent);
+		assert.notEqual(headChange?.key, first?.key, "submodule HEAD changes remain visible");
+	});
+
+	function setThreshold(bytes: number, t: { after: (fn: () => void) => void }): void {
+		const previous = process.env.SELESAI_SUBAGENTS_MAX_HASH_FILE_BYTES;
+		process.env.SELESAI_SUBAGENTS_MAX_HASH_FILE_BYTES = String(bytes);
+		t.after(() => {
+			if (previous === undefined) delete process.env.SELESAI_SUBAGENTS_MAX_HASH_FILE_BYTES;
+			else process.env.SELESAI_SUBAGENTS_MAX_HASH_FILE_BYTES = previous;
+		});
+	}
+
+	function setTotalThreshold(bytes: number, t: { after: (fn: () => void) => void }): void {
+		const previous = process.env.SELESAI_SUBAGENTS_MAX_HASH_TOTAL_BYTES;
+		process.env.SELESAI_SUBAGENTS_MAX_HASH_TOTAL_BYTES = String(bytes);
+		t.after(() => {
+			if (previous === undefined) delete process.env.SELESAI_SUBAGENTS_MAX_HASH_TOTAL_BYTES;
+			else process.env.SELESAI_SUBAGENTS_MAX_HASH_TOTAL_BYTES = previous;
+		});
+	}
+
+	function setEntryThreshold(entries: number, t: { after: (fn: () => void) => void }): void {
+		const previous = process.env.SELESAI_SUBAGENTS_MAX_HASH_ENTRIES;
+		process.env.SELESAI_SUBAGENTS_MAX_HASH_ENTRIES = String(entries);
+		t.after(() => {
+			if (previous === undefined) delete process.env.SELESAI_SUBAGENTS_MAX_HASH_ENTRIES;
+			else process.env.SELESAI_SUBAGENTS_MAX_HASH_ENTRIES = previous;
+		});
+	}
+
+	it("uses a metadata marker for files above the (lowered) threshold instead of hashing content", (t) => {
+		const repo = createRepo("watchdog-large-");
+		t.after(() => fs.rmSync(repo, { recursive: true, force: true }));
+		setThreshold(1024, t);
+
+		const filePath = path.join(repo, "big.txt");
+		fs.writeFileSync(filePath, Buffer.alloc(4096, 0x61)); // 4 KiB > 1 KiB threshold
+		const mtime = new Date(1_600_000_000_000);
+		fs.utimesSync(filePath, mtime, mtime);
+
+		const sig = computeWatchdogRepoChangeSignature(repo);
+		assert.ok(sig, "expected a signature");
+		assert.equal(typeof sig?.key, "string");
+		assert.ok(sig?.changedPaths.includes("big.txt"));
+
+		// The per-file hash is not exposed on the public signature, so prove the
+		// metadata marker (largeFileHash = "large:size:mtime") behaviorally: content
+		// is unchanged but the mtime changes, so a metadata-keyed hash yields a new
+		// key while a content SHA-256 (unfixed main) would produce the same key.
+		const laterMtime = new Date(1_600_000_100_000);
+		fs.utimesSync(filePath, laterMtime, laterMtime);
+		const afterMtime = computeWatchdogRepoChangeSignature(repo);
+		assert.notEqual(afterMtime?.key, sig?.key, "mtime-only change must alter the key for large files");
+	});
+
+	it("uses metadata markers after the total content hash budget", (t) => {
+		const repo = createRepo("watchdog-total-budget-");
+		t.after(() => fs.rmSync(repo, { recursive: true, force: true }));
+		setTotalThreshold(10, t);
+
+		const aPath = path.join(repo, "a.txt");
+		const bPath = path.join(repo, "b.txt");
+		const mtime = new Date(1_600_000_000_000);
+		fs.writeFileSync(aPath, "aaaaaaaa");
+		fs.writeFileSync(bPath, "bbbbbbbb");
+		fs.utimesSync(aPath, mtime, mtime);
+		fs.utimesSync(bPath, mtime, mtime);
+
+		const first = computeWatchdogRepoChangeSignature(repo);
+		assert.ok(first, "expected a signature");
+
+		fs.writeFileSync(bPath, "cccccccc");
+		fs.utimesSync(bPath, mtime, mtime);
+		assert.equal(computeWatchdogRepoChangeSignature(repo)?.key, first?.key, "over-budget files use size+mtime metadata instead of content");
+
+		fs.writeFileSync(aPath, "dddddddd");
+		fs.utimesSync(aPath, mtime, mtime);
+		assert.notEqual(computeWatchdogRepoChangeSignature(repo)?.key, first?.key, "within-budget files are still content hashed");
+	});
+
+	it("uses skipped markers after the entry budget", (t) => {
+		const repo = createRepo("watchdog-entry-budget-");
+		t.after(() => fs.rmSync(repo, { recursive: true, force: true }));
+		setEntryThreshold(3, t);
+
+		const dir = path.join(repo, "files");
+		fs.mkdirSync(dir);
+		for (const name of ["a.txt", "b.txt", "c.txt", "d.txt"]) {
+			fs.writeFileSync(path.join(dir, name), `${name}\n`, "utf-8");
+		}
+
+		const first = computeWatchdogRepoChangeSignature(repo);
+		assert.ok(first, "expected a signature");
+
+		fs.writeFileSync(path.join(dir, "d.txt"), "changed d\n", "utf-8");
+		assert.equal(computeWatchdogRepoChangeSignature(repo)?.key, first?.key, "over-budget entries are summarized instead of hashed individually");
+
+		fs.writeFileSync(path.join(dir, "a.txt"), "changed a\n", "utf-8");
+		assert.notEqual(computeWatchdogRepoChangeSignature(repo)?.key, first?.key, "within-budget entries are still content hashed");
+	});
+
+	it("produces deterministic keys keyed on size and mtime for large files", (t) => {
+		const repo = createRepo("watchdog-large-det-");
+		t.after(() => fs.rmSync(repo, { recursive: true, force: true }));
+		setThreshold(1024, t);
+
+		const filePath = path.join(repo, "big.txt");
+		fs.writeFileSync(filePath, Buffer.alloc(4096, 0x61));
+		const mtime = new Date(1_600_000_000_000);
+		fs.utimesSync(filePath, mtime, mtime);
+
+		const first = computeWatchdogRepoChangeSignature(repo);
+		const again = computeWatchdogRepoChangeSignature(repo);
+		assert.equal(again?.key, first?.key, "same size+mtime → same key");
+
+		const laterMtime = new Date(1_600_000_100_000);
+		fs.utimesSync(filePath, laterMtime, laterMtime);
+		const afterMtime = computeWatchdogRepoChangeSignature(repo);
+		assert.notEqual(afterMtime?.key, first?.key, "changed mtime → different key");
+
+		fs.writeFileSync(filePath, Buffer.alloc(8192, 0x61));
+		fs.utimesSync(filePath, laterMtime, laterMtime);
+		const afterSize = computeWatchdogRepoChangeSignature(repo);
+		assert.notEqual(afterSize?.key, afterMtime?.key, "changed size → different key");
+	});
+
+	it("handles a >2 GiB sparse file without throwing (default threshold)", { skip: process.platform === "win32" }, (t) => {
+		const repo = createRepo("watchdog-sparse-");
+		const filePath = path.join(repo, "huge.bin");
+		t.after(() => fs.rmSync(repo, { recursive: true, force: true }));
+
+		const fd = fs.openSync(filePath, "w");
+		try {
+			fs.ftruncateSync(fd, 2 * 1024 ** 3 + 1);
+		} finally {
+			fs.closeSync(fd);
+		}
+
+		const sig = computeWatchdogRepoChangeSignature(repo);
+		assert.ok(sig, "expected a signature");
+		assert.ok(sig?.changedPaths.includes("huge.bin"));
+	});
+
+	it("ignores node_modules below changed directories", (t) => {
+		const repo = createRepo("watchdog-nested-ignored-");
+		t.after(() => fs.rmSync(repo, { recursive: true, force: true }));
+
+		const subdir = path.join(repo, "nested");
+		fs.mkdirSync(path.join(subdir, "node_modules"), { recursive: true });
+		fs.writeFileSync(path.join(subdir, "keep.txt"), "one\n", "utf-8");
+		fs.writeFileSync(path.join(subdir, "node_modules", "cache.bin"), "ignored one\n", "utf-8");
+
+		const first = computeWatchdogRepoChangeSignature(repo);
+		assert.ok(first?.changedPaths.includes("nested/keep.txt"));
+		assert.ok(!first?.changedPaths.some((relPath) => relPath.includes("node_modules")));
+
+		fs.writeFileSync(path.join(subdir, "node_modules", "cache.bin"), "ignored two\n", "utf-8");
+		assert.equal(computeWatchdogRepoChangeSignature(repo)?.key, first?.key);
+
+		fs.writeFileSync(path.join(subdir, "keep.txt"), "two\n", "utf-8");
+		assert.notEqual(computeWatchdogRepoChangeSignature(repo)?.key, first?.key);
+	});
+
+	it("applies the threshold guard recursively into untracked subdirectories", (t) => {
+		const repo = createRepo("watchdog-recurse-");
+		t.after(() => fs.rmSync(repo, { recursive: true, force: true }));
+		setThreshold(1024, t);
+
+		const subdir = path.join(repo, "nested");
+		fs.mkdirSync(subdir, { recursive: true });
+		const filePath = path.join(subdir, "big.txt");
+		fs.writeFileSync(filePath, Buffer.alloc(4096, 0x62));
+		const mtime = new Date(1_600_000_000_000);
+		fs.utimesSync(filePath, mtime, mtime);
+
+		const sig = computeWatchdogRepoChangeSignature(repo);
+		assert.ok(sig, "expected a signature");
+		assert.ok(sig?.changedPaths.includes("nested/big.txt"));
+
+		// Same behavioral proof as above, for a file nested in a subdirectory.
+		const laterMtime = new Date(1_600_000_100_000);
+		fs.utimesSync(filePath, laterMtime, laterMtime);
+		const afterMtime = computeWatchdogRepoChangeSignature(repo);
+		assert.notEqual(afterMtime?.key, sig?.key, "mtime-only change must alter the key for large files in subdirs");
+	});
+
+	it("degrades to the metadata marker when a per-file read raises ERR_FS_FILE_TOO_LARGE", (t) => {
+		const repo = createRepo("watchdog-inner-toolarge-");
+		t.after(() => fs.rmSync(repo, { recursive: true, force: true }));
+
+		// Small file (default threshold) so it enters the content-hash try branch.
+		fs.writeFileSync(path.join(repo, "small.txt"), "hello\n", "utf-8");
+
+		const warnings: string[] = [];
+		const previousWarn = console.warn;
+		console.warn = (...args: unknown[]) => void warnings.push(args.join(" "));
+		let sig: ReturnType<typeof computeWatchdogRepoChangeSignature>;
+		try {
+			sig = withOpenSyncError("ERR_FS_FILE_TOO_LARGE", () => computeWatchdogRepoChangeSignature(repo));
+		} finally {
+			console.warn = previousWarn;
+		}
+
+		assert.ok(sig, "a single unreadable file must not discard the whole signature");
+		assert.equal(typeof sig?.key, "string");
+		assert.ok(sig?.changedPaths.includes("small.txt"));
+		assert.deepEqual(warnings, [], "the too-large case is expected and must stay quiet");
+	});
+
+	it("keeps a valid signature when a per-file read races into ENOENT", (t) => {
+		const repo = createRepo("watchdog-inner-enoent-");
+		t.after(() => fs.rmSync(repo, { recursive: true, force: true }));
+
+		fs.writeFileSync(path.join(repo, "small.txt"), "hello\n", "utf-8");
+
+		const sig = withOpenSyncError("ENOENT", () => computeWatchdogRepoChangeSignature(repo));
+		assert.ok(sig, "an ENOENT during read must degrade to the deleted marker, not undefined");
+		assert.equal(typeof sig?.key, "string");
+		assert.ok(sig?.changedPaths.includes("small.txt"));
+	});
+
+	it("warns and falls back to metadata for other per-file read errors", (t) => {
+		const repo = createRepo("watchdog-inner-eacces-");
+		t.after(() => fs.rmSync(repo, { recursive: true, force: true }));
+
+		fs.writeFileSync(path.join(repo, "small.txt"), "hello\n", "utf-8");
+
+		const warnings: string[] = [];
+		const previousWarn = console.warn;
+		console.warn = (...args: unknown[]) => void warnings.push(args.join(" "));
+		let sig: ReturnType<typeof computeWatchdogRepoChangeSignature>;
+		try {
+			sig = withOpenSyncError("EACCES", () => computeWatchdogRepoChangeSignature(repo));
+		} finally {
+			console.warn = previousWarn;
+		}
+
+		assert.ok(sig, "a single unreadable file must not discard the whole signature");
+		assert.equal(typeof sig?.key, "string");
+		assert.ok(warnings.some((line) => line.includes("hashFile fell back to metadata") && line.includes("small.txt")));
+	});
+
+	it("returns undefined instead of throwing when hashing a changed path raises", (t) => {
+		const repo = createRepo("watchdog-outer-");
+		t.after(() => fs.rmSync(repo, { recursive: true, force: true }));
+
+		// Use a deterministic stat failure to exercise the outer fail-safe on every
+		// platform without depending on POSIX permissions or ENOTDIR/ENOENT differences
+		// between Unix and Windows.
+		fs.writeFileSync(path.join(repo, "x.txt"), "changed\n", "utf-8");
+
+		const warnings: string[] = [];
+		const previousWarn = console.warn;
+		console.warn = (...args: unknown[]) => void warnings.push(args.join(" "));
+		let result: ReturnType<typeof computeWatchdogRepoChangeSignature>;
+		try {
+			assert.doesNotThrow(() => {
+				result = withLstatSyncError("EIO", () => computeWatchdogRepoChangeSignature(repo));
+			});
+		} finally {
+			console.warn = previousWarn;
+		}
+
+		assert.equal(result, undefined, "a throw in the hashing region must fail safe to undefined");
+	});
+
+	it("still hashes small files by content when under the threshold", (t) => {
+		const repo = createRepo("watchdog-small-");
+		t.after(() => fs.rmSync(repo, { recursive: true, force: true }));
+
+		const filePath = path.join(repo, "small.txt");
+		fs.writeFileSync(filePath, "hello\n", "utf-8");
+		const mtime = new Date(1_600_000_000_000);
+		fs.utimesSync(filePath, mtime, mtime);
+
+		const sig = computeWatchdogRepoChangeSignature(repo);
+		assert.ok(sig, "expected a signature");
+		assert.ok(sig?.changedPaths.includes("small.txt"));
+
+		// Content-hashed files ignore mtime: an mtime-only change must NOT alter the
+		// key (would fail if the metadata marker leaked into the normal path). A
+		// content change must alter it.
+		const laterMtime = new Date(1_600_000_100_000);
+		fs.utimesSync(filePath, laterMtime, laterMtime);
+		assert.equal(computeWatchdogRepoChangeSignature(repo)?.key, sig?.key, "mtime-only change must not alter key for small files");
+
+		fs.writeFileSync(filePath, "changed\n", "utf-8");
+		assert.notEqual(computeWatchdogRepoChangeSignature(repo)?.key, sig?.key, "content change must alter key");
+	});
+});

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

@@ -0,0 +1,110 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+	CHILD_WATCHDOG_STATUS_EVENT,
+	acceptChildWatchdogEvent,
+	childWatchdogIsActive,
+	decodeChildWatchdogConfig,
+	isChildWatchdogStatusEvent,
+	resolveChildWatchdogConfig,
+} from "../../src/watchdog/child-status.ts";
+import { DEFAULT_WATCHDOG_CONFIG } from "../../src/watchdog/settings.ts";
+
+describe("child watchdog status helpers", () => {
+	it("preserves child model and explicit override thinking when resolving config", () => {
+		const config = resolveChildWatchdogConfig({
+			config: {
+				...DEFAULT_WATCHDOG_CONFIG,
+				enabled: true,
+				children: {
+					...DEFAULT_WATCHDOG_CONFIG.children,
+					enabled: true,
+					model: "openai/gpt-test-child",
+					thinking: "low",
+					overrides: {
+						worker: {
+							model: "anthropic/claude-test-worker",
+							thinking: false,
+						},
+					},
+				},
+			},
+			agent: "worker",
+			runId: "run-1",
+			childIndex: 0,
+		});
+
+		assert.equal(config?.model, "anthropic/claude-test-worker");
+		assert.equal(config?.thinking, false);
+		assert.deepEqual(config?.lsp, DEFAULT_WATCHDOG_CONFIG.lsp);
+	});
+
+	it("decodes child watchdog config and rejects malformed enabled payloads", () => {
+		const payload = {
+			enabled: true,
+			runId: "run-1",
+			agent: "worker",
+			childIndex: 1,
+			watchdogTailTimeoutMs: 100,
+			agentEndTimeoutMs: 200,
+			maxWarnings: null,
+			lsp: { enabled: false, timeoutMs: 50, maxFiles: 2, maxDiagnostics: 3 },
+			autoFollowBlockers: true,
+			autoFollowMaxAttempts: 2,
+			stalemateRepeats: 3,
+		};
+		const config = decodeChildWatchdogConfig(JSON.stringify(payload));
+
+		assert.deepEqual(config, payload);
+		assert.equal(decodeChildWatchdogConfig(JSON.stringify({ enabled: false })), undefined);
+		assert.throws(
+			() => decodeChildWatchdogConfig(JSON.stringify({ ...payload, lsp: { ...payload.lsp, timeoutMs: 0 } })),
+			/lsp\.timeoutMs/,
+		);
+		assert.throws(
+			() => decodeChildWatchdogConfig(JSON.stringify({ ...payload, autoFollowBlockers: undefined })),
+			/autoFollowBlockers/,
+		);
+		assert.throws(
+			() => decodeChildWatchdogConfig(JSON.stringify({ ...payload, autoFollowBlockers: "yes" })),
+			/autoFollowBlockers/,
+		);
+		assert.throws(
+			() => decodeChildWatchdogConfig(JSON.stringify({ ...payload, stalemateRepeats: 0 })),
+			/stalemateRepeats/,
+		);
+	});
+
+	it("accepts latest matching status events and drops stale or foreign events", () => {
+		const firstEvent = {
+			type: CHILD_WATCHDOG_STATUS_EVENT,
+			runId: "run-1",
+			agent: "worker",
+			childIndex: 0,
+			seq: 1,
+			phase: "reviewing",
+			ts: 10,
+			followUpPending: false,
+		} as const;
+
+		assert.equal(isChildWatchdogStatusEvent(firstEvent), true);
+		const first = acceptChildWatchdogEvent({ event: firstEvent, runId: "run-1", agent: "worker", childIndex: 0, current: undefined });
+		assert.deepEqual(first, { phase: "reviewing", seq: 1, lastUpdate: 10, followUpPending: false });
+		assert.equal(childWatchdogIsActive(first), true);
+		assert.equal(acceptChildWatchdogEvent({ event: firstEvent, current: first, runId: "run-1", agent: "worker", childIndex: 0 }), undefined);
+		assert.equal(acceptChildWatchdogEvent({ event: { ...firstEvent, seq: 2, runId: undefined }, current: first, runId: "run-1", agent: "worker", childIndex: 0 }), undefined);
+		assert.equal(acceptChildWatchdogEvent({ event: { ...firstEvent, seq: 2, agent: undefined }, current: first, runId: "run-1", agent: "worker", childIndex: 0 }), undefined);
+		assert.equal(acceptChildWatchdogEvent({ event: { ...firstEvent, seq: 2, childIndex: undefined }, current: first, runId: "run-1", agent: "worker", childIndex: 0 }), undefined);
+		assert.equal(acceptChildWatchdogEvent({ event: { ...firstEvent, seq: 2, agent: "other" }, current: first, runId: "run-1", agent: "worker", childIndex: 0 }), undefined);
+
+		const settled = acceptChildWatchdogEvent({
+			event: { ...firstEvent, seq: 2, phase: "idle", ts: 20 },
+			current: first,
+			runId: "run-1",
+			agent: "worker",
+			childIndex: 0,
+		});
+		assert.equal(settled?.phase, "idle");
+		assert.equal(childWatchdogIsActive(settled), false);
+	});
+});

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

@@ -0,0 +1,62 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { WatchdogEmissionGuard, normalizeWatchdogEmissionText } from "../../src/watchdog/emission-guard.ts";
+import type { WatchdogWarning } from "../../src/watchdog/types.ts";
+
+function warning(overrides: Partial<WatchdogWarning> = {}): WatchdogWarning {
+	return {
+		severity: "concern",
+		summary: "Unvalidated file write",
+		evidence: "The implementation writes settings without a test.",
+		recommendedAction: "Add a focused settings write regression test.",
+		...overrides,
+	};
+}
+
+describe("watchdog emission guard", () => {
+	it("normalizes text with NFKC, punctuation folding, lowercase, and whitespace collapse", () => {
+		assert.equal(normalizeWatchdogEmissionText("  Ｆｉｘ—THE\tBug!!!  "), "fix the bug");
+	});
+
+	it("suppresses content-free and empty emissions", () => {
+		assert.deepEqual(new WatchdogEmissionGuard().evaluate(warning({ summary: "No concerns." })), { accepted: false, reason: "content-free" });
+		assert.deepEqual(new WatchdogEmissionGuard().evaluate(warning({ evidence: "LGTM" })), { accepted: false, reason: "content-free" });
+		assert.deepEqual(new WatchdogEmissionGuard().evaluate(warning({ recommendedAction: "" })), { accepted: false, reason: "content-free" });
+	});
+
+	it("dedupes normalized repeated warnings across model updates", () => {
+		const guard = new WatchdogEmissionGuard();
+		assert.equal(guard.evaluate(warning({ summary: "Fix Ｆｏｏ!!!", evidence: "Line 1: bad whitespace." })).accepted, true);
+		guard.startModelUpdate();
+		const duplicate = guard.evaluate(warning({ summary: "fix foo", evidence: "line 1 bad whitespace" }));
+
+		assert.equal(duplicate.accepted, false);
+		assert.equal(duplicate.reason, "duplicate");
+	});
+
+	it("allows concern to blocker escalation for the same issue despite per-update budget", () => {
+		const guard = new WatchdogEmissionGuard();
+		const first = guard.evaluate(warning({ severity: "concern", summary: "Tests missing", evidence: "No unit covers the parser." }));
+		const escalation = guard.evaluate(warning({ severity: "blocker", summary: "Tests missing", evidence: "No unit covers the parser." }));
+		const extra = guard.evaluate(warning({ severity: "blocker", summary: "Docs missing", evidence: "No README section exists." }));
+
+		assert.equal(first.accepted, true);
+		assert.equal(escalation.accepted, true);
+		assert.equal(escalation.escalation, true);
+		assert.equal(extra.accepted, false);
+		assert.equal(extra.reason, "update-budget");
+	});
+
+	it("enforces max warnings while still allowing escalation of an accepted concern", () => {
+		const guard = new WatchdogEmissionGuard({ maxWarnings: 1 });
+		assert.equal(guard.evaluate(warning({ severity: "concern", summary: "Parser gap", evidence: "Unknown fields are ignored." })).accepted, true);
+		guard.startModelUpdate();
+		const capped = guard.evaluate(warning({ severity: "concern", summary: "Renderer gap", evidence: "Stale state is hidden." }));
+		const escalation = guard.evaluate(warning({ severity: "blocker", summary: "Parser gap", evidence: "Unknown fields are ignored." }));
+
+		assert.equal(capped.accepted, false);
+		assert.equal(capped.reason, "max-warnings");
+		assert.equal(escalation.accepted, true);
+		assert.equal(escalation.escalation, true);
+	});
+});