@selesai/code 0.13.12 → 0.13.13

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

@@ -1,434 +0,0 @@
-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 createEmptyRepo(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;
-}
-
-function createRepo(prefix: string): string {
-	const repo = createEmptyRepo(prefix);
-	fs.writeFileSync(path.join(repo, ".watchdog-baseline"), "baseline\n", "utf-8");
-	git(repo, ["add", ".watchdog-baseline"]);
-	git(repo, ["commit", "-m", "initial"]);
-	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");
-	});
-
-	it("does not inspect untracked files in an empty repository", (t) => {
-		const repo = createEmptyRepo("watchdog-empty-");
-		t.after(() => fs.rmSync(repo, { recursive: true, force: true }));
-
-		fs.writeFileSync(path.join(repo, "untracked.txt"), "one\n", "utf-8");
-		const first = computeWatchdogRepoChangeSignature(repo);
-		assert.ok(first, "expected a signature");
-		assert.deepEqual(first?.changedPaths, []);
-
-		fs.writeFileSync(path.join(repo, "untracked.txt"), "two\n", "utf-8");
-		const afterChange = computeWatchdogRepoChangeSignature(repo);
-		assert.equal(afterChange?.key, first?.key, "untracked-only changes must not trigger an empty-repo scan");
-	});
-
-	it("does not inspect untracked files when the repository root is the user home", (t) => {
-		const repo = createRepo("watchdog-home-");
-		t.after(() => fs.rmSync(repo, { recursive: true, force: true }));
-		const previousHome = process.env.HOME;
-		const previousUserProfile = process.env.USERPROFILE;
-		process.env.HOME = repo;
-		process.env.USERPROFILE = repo;
-		t.after(() => {
-			if (previousHome === undefined) delete process.env.HOME;
-			else process.env.HOME = previousHome;
-			if (previousUserProfile === undefined) delete process.env.USERPROFILE;
-			else process.env.USERPROFILE = previousUserProfile;
-		});
-
-		fs.writeFileSync(path.join(repo, "untracked.txt"), "one\n", "utf-8");
-		const first = computeWatchdogRepoChangeSignature(repo);
-		assert.ok(first, "expected a signature");
-		assert.deepEqual(first?.changedPaths, []);
-
-		fs.writeFileSync(path.join(repo, ".watchdog-baseline"), "changed\n", "utf-8");
-		const trackedChange = computeWatchdogRepoChangeSignature(repo);
-		assert.deepEqual(trackedChange?.changedPaths, [".watchdog-baseline"]);
-		assert.notEqual(trackedChange?.key, first?.key, "tracked changes remain visible for a home-root repository");
-	});
-
-	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

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

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