@selesai/code 0.13.12 → 0.13.13

package/dist/extensions/pi-subagents/test/unit/model-info.test.ts

@@ -1,162 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { findModelInfo, getSupportedThinkingLevels, splitKnownThinkingSuffix, toModelInfo, type ModelInfo } from "../../src/shared/model-info.ts";
-
-describe("model info helpers", () => {
-	const ambiguousModels: ModelInfo[] = [
-		{ provider: "openai", id: "gpt-5-mini", fullId: "openai/gpt-5-mini", reasoning: true, thinkingLevelMap: { high: "high" } },
-		{ provider: "github-copilot", id: "gpt-5-mini", fullId: "github-copilot/gpt-5-mini", reasoning: true, thinkingLevelMap: { off: null, high: "high", xhigh: "xhigh" } },
-	];
-
-	it("does not choose arbitrary metadata for ambiguous bare model ids", () => {
-		assert.equal(findModelInfo("gpt-5-mini", ambiguousModels), undefined);
-	});
-
-	it("uses the preferred provider for ambiguous bare model metadata", () => {
-		assert.equal(findModelInfo("gpt-5-mini", ambiguousModels, "github-copilot")?.fullId, "github-copilot/gpt-5-mini");
-	});
-
-	it("matches provider-qualified model metadata before bare ids", () => {
-		assert.equal(findModelInfo("openai/gpt-5-mini:high", ambiguousModels, "github-copilot")?.fullId, "openai/gpt-5-mini");
-	});
-
-	it("matches owner/name registry ids without treating the owner as a provider", () => {
-		const hfModels: ModelInfo[] = [
-			{
-				provider: "huggingface",
-				id: "thinkingmachines/Inkling",
-				fullId: "huggingface/thinkingmachines/Inkling",
-				reasoning: true,
-			},
-		];
-		assert.equal(findModelInfo("thinkingmachines/Inkling", hfModels)?.fullId, "huggingface/thinkingmachines/Inkling");
-		assert.equal(
-			findModelInfo("huggingface/thinkingmachines/Inkling", hfModels)?.fullId,
-			"huggingface/thinkingmachines/Inkling",
-		);
-	});
-
-	it("preserves registry API metadata", () => {
-		assert.equal(toModelInfo({ provider: "gateway", id: "model", api: "anthropic-messages" }).api, "anthropic-messages");
-	});
-
-	it("keeps the legacy thinking list for models without per-level metadata", () => {
-		assert.deepEqual(
-			getSupportedThinkingLevels({ provider: "openai", id: "gpt-5", fullId: "openai/gpt-5", reasoning: true }),
-			["off", "minimal", "low", "medium", "high", "xhigh"],
-		);
-		assert.deepEqual(getSupportedThinkingLevels(undefined), ["off", "minimal", "low", "medium", "high", "xhigh"]);
-	});
-
-	it("keeps the legacy thinking list when older model metadata omits reasoning", () => {
-		assert.deepEqual(
-			getSupportedThinkingLevels({ provider: "openai", id: "gpt-5", fullId: "openai/gpt-5" }),
-			["off", "minimal", "low", "medium", "high", "xhigh"],
-		);
-	});
-
-	it("filters levels only when per-level metadata is present", () => {
-		assert.deepEqual(
-			getSupportedThinkingLevels({
-				provider: "deepseek",
-				id: "deepseek-v4-pro",
-				fullId: "deepseek/deepseek-v4-pro",
-				reasoning: true,
-				thinkingLevelMap: { minimal: null, low: null, medium: null, high: "high", xhigh: "max" },
-			}),
-			["off", "high", "xhigh"],
-		);
-	});
-
-	it("honors metadata that marks off unsupported", () => {
-		assert.deepEqual(
-			getSupportedThinkingLevels({
-				provider: "always-thinking",
-				id: "model",
-				fullId: "always-thinking/model",
-				reasoning: true,
-				thinkingLevelMap: { off: null, minimal: null, low: null, medium: null, high: "high" },
-			}),
-			["high"],
-		);
-	});
-
-	it("honors an explicit max mapping and recognizes max suffixes", () => {
-		assert.deepEqual(
-			getSupportedThinkingLevels({
-				provider: "openai",
-				id: "gpt-5",
-				fullId: "openai/gpt-5",
-				reasoning: true,
-				thinkingLevelMap: { off: null, minimal: null, low: null, medium: null, high: null, xhigh: null, max: "max" },
-			}),
-			["max"],
-		);
-		assert.deepEqual(
-			splitKnownThinkingSuffix("openai/gpt-5:max"),
-			{ baseModel: "openai/gpt-5", thinkingSuffix: ":max" },
-		);
-	});
-});
-
-describe("toModelInfo registry fields", () => {
-	it("carries contextWindow, maxTokens, input, and cost from the registry", () => {
-		const info = toModelInfo({
-			provider: "openai",
-			id: "gpt-5-mini",
-			api: "openai-responses",
-			reasoning: true,
-			contextWindow: 272000,
-			maxTokens: 128000,
-			input: ["text", "image"],
-			cost: { input: 0.25, output: 2, cacheRead: 0.025, cacheWrite: 0.25 },
-		});
-		assert.equal(info.contextWindow, 272000);
-		assert.equal(info.maxTokens, 128000);
-		assert.deepEqual(info.input, ["text", "image"]);
-		assert.deepEqual(info.cost, { input: 0.25, output: 2, cacheRead: 0.025, cacheWrite: 0.25 });
-	});
-
-	it("omits fields the registry does not report", () => {
-		const info = toModelInfo({ provider: "local", id: "custom-model" });
-		assert.equal(info.fullId, "local/custom-model");
-		assert.equal("contextWindow" in info, false);
-		assert.equal("maxTokens" in info, false);
-		assert.equal("input" in info, false);
-		assert.equal("cost" in info, false);
-	});
-
-	it("ignores non-positive or malformed registry values", () => {
-		const info = toModelInfo({
-			provider: "local",
-			id: "broken",
-			contextWindow: 0,
-			maxTokens: -1,
-			input: [],
-			cost: { input: Number.NaN, output: 1 },
-		});
-		assert.equal("contextWindow" in info, false);
-		assert.equal("maxTokens" in info, false);
-		assert.equal("input" in info, false);
-		assert.equal("cost" in info, false);
-	});
-
-	it("copies the input array instead of aliasing the registry entry", () => {
-		const registryInput = ["text"];
-		const info = toModelInfo({ provider: "local", id: "m", input: registryInput });
-		assert.notEqual(info.input, registryInput);
-		assert.deepEqual(info.input, ["text"]);
-	});
-
-	it("preserves and copies tiered registry cost", () => {
-		const tiers = [{ inputTokensAbove: 100_000, input: 1, output: 2, cacheRead: 0.1, cacheWrite: 0.2 }];
-		const info = toModelInfo({
-			provider: "openai",
-			id: "tiered",
-			cost: { input: 0.5, output: 1, cacheRead: 0.05, cacheWrite: 0.1, tiers },
-		});
-		assert.deepEqual(info.cost?.tiers, tiers);
-		assert.notEqual(info.cost?.tiers, tiers);
-		assert.notEqual(info.cost?.tiers?.[0], tiers[0]);
-	});
-});

package/dist/extensions/pi-subagents/test/unit/model-scope-settings.test.ts

@@ -1,101 +0,0 @@
-import assert from "node:assert/strict";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, it } from "node:test";
-import { discoverAgents } from "../../src/agents/agents.ts";
-
-let tempHome = "";
-let tempProject = "";
-const originalHome = process.env.HOME;
-const originalUserProfile = process.env.USERPROFILE;
-const originalPiCodingAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
-const originalExtraAgentDirs = process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS;
-
-function writeJson(filePath: string, value: unknown): void {
-	fs.mkdirSync(path.dirname(filePath), { recursive: true });
-	fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
-}
-
-describe("subagents.modelScope discovery", () => {
-	beforeEach(() => {
-		tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-scope-home-"));
-		tempProject = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-scope-project-"));
-		process.env.HOME = tempHome;
-		process.env.USERPROFILE = tempHome;
-		delete process.env.SELESAI_CODING_AGENT_DIR;
-		delete process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS;
-	});
-
-	afterEach(() => {
-		if (originalHome === undefined) delete process.env.HOME;
-		else process.env.HOME = originalHome;
-		if (originalUserProfile === undefined) delete process.env.USERPROFILE;
-		else process.env.USERPROFILE = originalUserProfile;
-		if (originalPiCodingAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
-		else process.env.SELESAI_CODING_AGENT_DIR = originalPiCodingAgentDir;
-		if (originalExtraAgentDirs === undefined) delete process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS;
-		else process.env.SELESAI_SUBAGENT_EXTRA_AGENT_DIRS = originalExtraAgentDirs;
-		fs.rmSync(tempHome, { recursive: true, force: true });
-		fs.rmSync(tempProject, { recursive: true, force: true });
-	});
-
-	it("exposes a user modelScope from discoverAgents", () => {
-		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
-			subagents: { modelScope: { enforce: true, strict: true, allow: ["anthropic/*", "openai/gpt-5-*"], agents: { reviewer: { allow: ["inherit"] } } } },
-		});
-		const result = discoverAgents(tempProject, "both");
-		assert.deepEqual(result.modelScope, { enforce: true, strict: true, allow: ["anthropic/*", "openai/gpt-5-*"], agents: { reviewer: { allow: ["inherit"] } } });
-	});
-
-	it("accepts enforcement with only named agent allow lists", () => {
-		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
-			subagents: { modelScope: { enforce: true, agents: { worker: { allow: ["openai/gpt-5-mini"] } } } },
-		});
-		assert.deepEqual(discoverAgents(tempProject, "both").modelScope, { enforce: true, agents: { worker: { allow: ["openai/gpt-5-mini"] } } });
-	});
-
-	it("returns undefined when no modelScope is configured", () => {
-		assert.equal(discoverAgents(tempProject, "both").modelScope, undefined);
-	});
-
-	it("prefers project modelScope over user modelScope", () => {
-		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
-			subagents: { modelScope: { enforce: true, allow: ["anthropic/*"], agents: { reviewer: { allow: ["inherit"] } } } },
-		});
-		writeJson(path.join(tempProject, ".selesai", "settings.json"), {
-			subagents: { modelScope: { enforce: true, agents: { worker: { allow: ["deepseek/*"] } } } },
-		});
-		const result = discoverAgents(tempProject, "both");
-		assert.deepEqual(result.modelScope, { enforce: true, agents: { worker: { allow: ["deepseek/*"] } } });
-	});
-
-	it("falls back to user modelScope when project does not set one", () => {
-		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
-			subagents: { modelScope: { enforce: true, allow: ["anthropic/*"] } },
-		});
-		const result = discoverAgents(tempProject, "both");
-		assert.deepEqual(result.modelScope, { enforce: true, allow: ["anthropic/*"] });
-	});
-
-	it("rejects an invalid modelScope config at discovery time", () => {
-		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
-			subagents: { modelScope: { enforce: true } },
-		});
-		assert.throws(() => discoverAgents(tempProject, "both"), /without a non-empty 'allow'/);
-	});
-
-	it("rejects a malformed modelScope value at discovery time", () => {
-		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
-			subagents: { modelScope: "anthropic/*" },
-		});
-		assert.throws(() => discoverAgents(tempProject, "both"), /invalid 'modelScope'/);
-	});
-
-	it("rejects malformed per-agent scopes at discovery time", () => {
-		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
-			subagents: { modelScope: { agents: { worker: { allow: [] } } } },
-		});
-		assert.throws(() => discoverAgents(tempProject, "both"), /modelScope\.agents\.worker\.allow/);
-	});
-});

package/dist/extensions/pi-subagents/test/unit/model-scope.test.ts

@@ -1,198 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import {
-	checkModelScope,
-	matchesScopePattern,
-	parseModelScopeConfig,
-	resolveModelScopesForAgent,
-	type ModelScopeConfig,
-} from "../../src/runs/shared/model-scope.ts";
-
-describe("matchesScopePattern", () => {
-	it("matches an exact provider/id", () => {
-		assert.equal(matchesScopePattern("anthropic/claude-sonnet-4", "anthropic/claude-sonnet-4"), true);
-	});
-
-	it("matches a provider wildcard", () => {
-		assert.equal(matchesScopePattern("anthropic/claude-sonnet-4", "anthropic/*"), true);
-		assert.equal(matchesScopePattern("anthropic/claude-haiku-4-5", "anthropic/*"), true);
-	});
-
-	it("matches a model-prefix wildcard", () => {
-		assert.equal(matchesScopePattern("openai/gpt-5-mini", "openai/gpt-5-*"), true);
-		// The dash in the pattern is literal, so the bare id without a trailing part does not match.
-		assert.equal(matchesScopePattern("openai/gpt-5", "openai/gpt-5-*"), false);
-		assert.equal(matchesScopePattern("openai/gpt-5", "openai/gpt-5*"), true);
-	});
-
-	it("does not match across providers", () => {
-		assert.equal(matchesScopePattern("deepseek/deepseek-v4", "anthropic/*"), false);
-		assert.equal(matchesScopePattern("openai/gpt-5-mini", "anthropic/*"), false);
-	});
-
-	it("ignores case on both sides", () => {
-		assert.equal(matchesScopePattern("Anthropic/Claude-Sonnet-4", "anthropic/*"), true);
-		assert.equal(matchesScopePattern("anthropic/claude-sonnet-4", "ANTHROPIC/CLAUDE-*"), true);
-	});
-
-	it("strips a thinking suffix before matching", () => {
-		assert.equal(matchesScopePattern("anthropic/claude-sonnet-4:high", "anthropic/claude-sonnet-4"), true);
-		assert.equal(matchesScopePattern("anthropic/claude-sonnet-4:high", "anthropic/*"), true);
-	});
-
-	it("does not treat arbitrary colon text as a thinking suffix", () => {
-		assert.equal(matchesScopePattern("anthropic:claude-opus", "anthropic"), false);
-		assert.equal(matchesScopePattern("anthropic/claude-sonnet-4:experimental", "anthropic/claude-sonnet-4"), false);
-	});
-
-	it("requires a full match, not a substring", () => {
-		assert.equal(matchesScopePattern("anthropic/claude-sonnet-4", "anthropic/claude"), false);
-		assert.equal(matchesScopePattern("anthropic/claude-sonnet-4", "*claude*"), true);
-	});
-});
-
-describe("checkModelScope", () => {
-	const scope: ModelScopeConfig = { enforce: true, allow: ["anthropic/*", "openai/gpt-5-*"] };
-
-	it("returns undefined when enforcement is off", () => {
-		assert.equal(checkModelScope("deepseek/deepseek-v4", { enforce: false, allow: ["anthropic/*"] }, "explicit"), undefined);
-		assert.equal(checkModelScope("deepseek/deepseek-v4", undefined, "explicit"), undefined);
-	});
-
-	it("returns undefined when no allow list is configured", () => {
-		assert.equal(checkModelScope("deepseek/deepseek-v4", { enforce: true }, "explicit"), undefined);
-		assert.equal(checkModelScope("deepseek/deepseek-v4", { enforce: true, allow: [] }, "explicit"), undefined);
-	});
-
-	it("returns undefined when the model is in scope", () => {
-		assert.equal(checkModelScope("anthropic/claude-sonnet-4", scope, "explicit"), undefined);
-		assert.equal(checkModelScope("openai/gpt-5-mini:high", scope, "inherited"), undefined);
-	});
-
-	it("returns an error violation for an explicit out-of-scope model", () => {
-		const violation = checkModelScope("deepseek/deepseek-v4", scope, "explicit");
-		assert.equal(violation?.severity, "error");
-		assert.equal(violation?.model, "deepseek/deepseek-v4");
-		assert.deepEqual(violation?.allowedPatterns, ["anthropic/*", "openai/gpt-5-*"]);
-		assert.equal(violation?.origin, "modelScope");
-		assert.match(violation?.message ?? "", /outside the configured subagent model scope/);
-	});
-
-	it("returns a warn violation for an inherited out-of-scope model", () => {
-		const violation = checkModelScope("deepseek/deepseek-v4", scope, "inherited");
-		assert.equal(violation?.severity, "warn");
-	});
-
-	it("returns an error violation for an inherited model in strict mode", () => {
-		const violation = checkModelScope("deepseek/deepseek-v4", { ...scope, strict: true }, "inherited");
-		assert.equal(violation?.severity, "error");
-	});
-
-	it("defaults to inherited (warn) severity when source is omitted-ish via inherited", () => {
-		// Caller passes "inherited" for frontmatter/parent-inherited models.
-		assert.equal(checkModelScope("meta/llama-4", scope, "inherited")?.severity, "warn");
-	});
-
-	it("strips the thinking suffix from the reported model", () => {
-		const violation = checkModelScope("deepseek/deepseek-v4:high", scope, "explicit");
-		assert.equal(violation?.model, "deepseek/deepseek-v4");
-	});
-
-	it("returns undefined for an undefined model", () => {
-		assert.equal(checkModelScope(undefined, scope, "explicit"), undefined);
-	});
-});
-
-describe("resolveModelScopesForAgent", () => {
-	it("returns independent global and agent checks with inherited flags", () => {
-		assert.deepEqual(
-			resolveModelScopesForAgent({ enforce: true, strict: true, allow: ["openai/*"], agents: { worker: { allow: ["openai/gpt-5-mini"] } } }, "worker", { provider: "openai", id: "gpt-5" }),
-			[
-				{ enforce: true, strict: true, allow: ["openai/*"], origin: "modelScope" },
-				{ enforce: true, strict: true, allow: ["openai/gpt-5-mini"], origin: "modelScope.agents.worker" },
-			],
-		);
-	});
-
-	it("expands inherit against the current parent model", () => {
-		const scopes = resolveModelScopesForAgent({ enforce: true, allow: ["inherit"], agents: { reviewer: { allow: ["inherit"] } } }, "reviewer", { provider: "anthropic", id: "claude-sonnet-4" });
-		assert.deepEqual(scopes.map((scope) => scope.allow), [["anthropic/claude-sonnet-4"], ["anthropic/claude-sonnet-4"]]);
-	});
-
-	it("keeps inherit literal when no parent model is available so enforcement fails closed", () => {
-		const [scope] = resolveModelScopesForAgent({ enforce: true, allow: ["inherit"] }, "worker", undefined);
-		const violation = checkModelScope("openai/gpt-5-mini", scope, "explicit");
-		assert.equal(violation?.severity, "error");
-		assert.deepEqual(violation?.allowedPatterns, ["inherit"]);
-	});
-
-	it("does not apply another agent's scope", () => {
-		assert.deepEqual(resolveModelScopesForAgent({ enforce: true, agents: { reviewer: { allow: ["inherit"] } } }, "worker", { provider: "openai", id: "gpt-5" }), []);
-	});
-});
-
-describe("parseModelScopeConfig", () => {
-	const meta = { filePath: "~/.selesai/agent/settings.json" };
-
-	it("returns undefined when the field is absent", () => {
-		assert.equal(parseModelScopeConfig(undefined, meta), undefined);
-	});
-
-	it("parses a well-formed config", () => {
-		assert.deepEqual(
-			parseModelScopeConfig({ enforce: true, strict: true, allow: ["anthropic/*", "openai/gpt-5-*"] }, meta),
-			{ enforce: true, strict: true, allow: ["anthropic/*", "openai/gpt-5-*"] },
-		);
-	});
-
-	it("parses per-agent scopes and permits agent-only enforcement", () => {
-		assert.deepEqual(
-			parseModelScopeConfig({ enforce: true, strict: true, agents: { worker: { allow: [" openai/gpt-5-mini "] }, unknown: { enforce: false } } }, meta),
-			{ enforce: true, strict: true, agents: { worker: { allow: ["openai/gpt-5-mini"] }, unknown: { enforce: false } } },
-		);
-	});
-
-	it("parses enforce alone", () => {
-		assert.deepEqual(parseModelScopeConfig({ enforce: false }, meta), { enforce: false });
-	});
-
-	it("trims allow patterns and drops empties", () => {
-		assert.deepEqual(
-			parseModelScopeConfig({ enforce: true, allow: ["  anthropic/*  ", "", "  "] }, meta),
-			{ enforce: true, allow: ["anthropic/*"] },
-		);
-	});
-
-	it("rejects a non-object value", () => {
-		assert.throws(() => parseModelScopeConfig("anthropic/*", meta), /invalid 'modelScope'/);
-		assert.throws(() => parseModelScopeConfig([], meta), /invalid 'modelScope'/);
-	});
-
-	it("rejects a non-boolean enforce", () => {
-		assert.throws(() => parseModelScopeConfig({ enforce: "yes" }, meta), /invalid 'modelScope.enforce'/);
-	});
-
-	it("rejects a non-boolean strict value", () => {
-		assert.throws(() => parseModelScopeConfig({ strict: "yes" }, meta), /invalid 'modelScope.strict'/);
-	});
-
-	it("rejects a non-array allow", () => {
-		assert.throws(() => parseModelScopeConfig({ allow: "anthropic/*" }, meta), /invalid 'modelScope.allow'/);
-	});
-
-	it("rejects an allow array with non-string entries", () => {
-		assert.throws(() => parseModelScopeConfig({ enforce: true, allow: ["anthropic/*", 42] }, meta), /invalid 'modelScope.allow'/);
-	});
-
-	it("rejects enforce without a non-empty allow list", () => {
-		assert.throws(() => parseModelScopeConfig({ enforce: true }, meta), /without a non-empty 'allow'/);
-		assert.throws(() => parseModelScopeConfig({ enforce: true, allow: [] }, meta), /non-empty array of patterns/);
-	});
-
-	it("rejects invalid agent scope shapes with the full field path", () => {
-		assert.throws(() => parseModelScopeConfig({ enforce: true, agents: { worker: [] } }, meta), /modelScope\.agents\.worker/);
-		assert.throws(() => parseModelScopeConfig({ agents: { worker: { allow: [] } } }, meta), /modelScope\.agents\.worker\.allow/);
-		assert.throws(() => parseModelScopeConfig({ agents: { worker: { agents: {} } } }, meta), /modelScope\.agents\.worker\.agents/);
-		assert.throws(() => parseModelScopeConfig({ agents: { " ": { allow: ["inherit"] } } }, meta), /non-empty agent name/);
-	});
-});

package/dist/extensions/pi-subagents/test/unit/mutation-evidence.test.ts

@@ -1,177 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { execFileSync } from "node:child_process";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { buildTimeoutRecoverySummary, collectTrackedMutationEvidence, snapshotTrackedMutations } from "../../src/runs/shared/mutation-evidence.ts";
-import { evaluateCompletionMutationGuard } from "../../src/runs/shared/completion-guard.ts";
-
-function git(cwd: string, args: string[]): void {
-	execFileSync("git", args, { cwd, stdio: "ignore" });
-}
-
-function withRepo(run: (repo: string) => void): void {
-	const repo = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-mutation-evidence-"));
-	try {
-		git(repo, ["init"]);
-		git(repo, ["config", "user.email", "test@example.com"]);
-		git(repo, ["config", "user.name", "Test User"]);
-		fs.writeFileSync(path.join(repo, "tracked.txt"), "base\n", "utf-8");
-		git(repo, ["add", "tracked.txt"]);
-		git(repo, ["commit", "-m", "base"]);
-		run(repo);
-	} finally {
-		fs.rmSync(repo, { recursive: true, force: true });
-	}
-}
-
-describe("tracked mutation evidence", () => {
-	it("detects edits to a tracked file that was already dirty at child start", () => {
-		withRepo((repo) => {
-			fs.writeFileSync(path.join(repo, "tracked.txt"), "dirty before child\n", "utf-8");
-			const snapshot = snapshotTrackedMutations(repo);
-
-			fs.writeFileSync(path.join(repo, "tracked.txt"), "dirty after child\n", "utf-8");
-			fs.writeFileSync(path.join(repo, "untracked.txt"), "ignored by evidence\n", "utf-8");
-			const evidence = collectTrackedMutationEvidence(snapshot, repo);
-
-			assert.equal(evidence.attemptedMutation, true);
-			assert.deepEqual(evidence.changedFiles, ["tracked.txt"]);
-		});
-	});
-
-	it("detects a child reverting a tracked file that was dirty at child start", () => {
-		withRepo((repo) => {
-			fs.writeFileSync(path.join(repo, "tracked.txt"), "dirty before child\n", "utf-8");
-			const snapshot = snapshotTrackedMutations(repo);
-
-			fs.writeFileSync(path.join(repo, "tracked.txt"), "base\n", "utf-8");
-			const evidence = collectTrackedMutationEvidence(snapshot, repo);
-
-			assert.equal(evidence.attemptedMutation, true);
-			assert.deepEqual(evidence.changedFiles, ["tracked.txt"]);
-		});
-	});
-
-	it("detects staged edits to a tracked file that was already staged dirty at child start", () => {
-		withRepo((repo) => {
-			fs.writeFileSync(path.join(repo, "tracked.txt"), "staged before child\n", "utf-8");
-			git(repo, ["add", "tracked.txt"]);
-			const snapshot = snapshotTrackedMutations(repo);
-
-			fs.writeFileSync(path.join(repo, "tracked.txt"), "staged after child\n", "utf-8");
-			git(repo, ["add", "tracked.txt"]);
-			const evidence = collectTrackedMutationEvidence(snapshot, repo);
-
-			assert.equal(evidence.attemptedMutation, true);
-			assert.deepEqual(evidence.changedFiles, ["tracked.txt"]);
-		});
-	});
-
-	it("distinguishes unchanged and changed tracked diffs that exceed the fast buffer", () => {
-		withRepo((repo) => {
-			const largeBefore = `${"before\n".repeat(180_000)}before-tail\n`;
-			const largeAfter = `${"after\n".repeat(180_000)}after-tail\n`;
-			fs.writeFileSync(path.join(repo, "tracked.txt"), largeBefore, "utf-8");
-			const snapshot = snapshotTrackedMutations(repo);
-			const unchangedEvidence = collectTrackedMutationEvidence(snapshot, repo);
-
-			assert.equal(unchangedEvidence.attemptedMutation, false);
-			assert.deepEqual(unchangedEvidence.changedFiles, []);
-
-			fs.writeFileSync(path.join(repo, "tracked.txt"), largeAfter, "utf-8");
-			const evidence = collectTrackedMutationEvidence(snapshot, repo);
-
-			assert.equal(evidence.attemptedMutation, true);
-			assert.deepEqual(evidence.changedFiles, ["tracked.txt"]);
-		});
-	});
-
-	it("does not invoke repository fsmonitor while collecting mutation evidence", () => {
-		withRepo((repo) => {
-			const marker = path.join(repo, "fsmonitor-invoked");
-			const hook = path.join(repo, "fsmonitor-hook.cjs");
-			fs.writeFileSync(hook, `require("node:fs").appendFileSync(${JSON.stringify(marker)}, "invoked\\n");\n`, "utf-8");
-			git(repo, ["config", "core.fsmonitor", `${JSON.stringify(process.execPath)} ${JSON.stringify(hook)}`]);
-			git(repo, ["status", "--short"]);
-			assert.equal(fs.existsSync(marker), true);
-			fs.rmSync(marker);
-			fs.writeFileSync(path.join(repo, "tracked.txt"), "dirty before child\n", "utf-8");
-
-			const snapshot = snapshotTrackedMutations(repo);
-			fs.writeFileSync(path.join(repo, "tracked.txt"), "dirty after child\n", "utf-8");
-			const evidence = collectTrackedMutationEvidence(snapshot, repo);
-
-			assert.equal(snapshot.unavailable, undefined);
-			assert.equal(evidence.attemptedMutation, true);
-			assert.equal(fs.existsSync(marker), false);
-		});
-	});
-
-	it("uses tracked evidence as completion guard mutation proof", () => {
-		const guard = evaluateCompletionMutationGuard({
-			agent: "worker",
-			task: "Implement the requested fix.",
-			messages: [{ role: "assistant", content: [{ type: "text", text: "Implemented." }] }],
-			tools: ["edit"],
-			mutationEvidence: {
-				source: "tracked-files",
-				trackedOnly: true,
-				changedFiles: ["tracked.txt"],
-				attemptedMutation: true,
-			},
-		});
-
-		assert.equal(guard.expectedMutation, true);
-		assert.equal(guard.attemptedMutation, true);
-		assert.equal(guard.triggered, false);
-	});
-
-	it("formats bounded timeout recovery data", () => {
-		const summary = buildTimeoutRecoverySummary({
-			termination: "timed-out",
-			evidence: {
-				source: "tracked-files",
-				trackedOnly: true,
-				changedFiles: ["tracked.txt"],
-				attemptedMutation: true,
-			},
-			currentTool: "edit",
-			currentPath: "tracked.txt",
-			sessionFile: "session.jsonl",
-		});
-
-		assert.deepEqual(summary.changedFiles, ["tracked.txt"]);
-		assert.match(summary.message, /termination: timed-out/);
-		assert.match(summary.message, /changed tracked files: tracked\.txt/);
-		assert.match(summary.message, /active tool: edit/);
-	});
-
-	it("classifies dirty timeouts with a missing requested report as recovery-needed", () => {
-		const changedFiles = Array.from({ length: 25 }, (_, index) => `src/file-${String(index + 1).padStart(2, "0")}.ts`);
-		const summary = buildTimeoutRecoverySummary({
-			termination: "timed-out",
-			evidence: {
-				source: "tracked-files",
-				trackedOnly: true,
-				changedFiles,
-				attemptedMutation: true,
-			},
-			requiredOutputMissing: true,
-		});
-
-		assert.equal(summary.changedFiles.length, 20);
-		assert.deepEqual(summary.changedFiles.slice(0, 2), ["src/file-01.ts", "src/file-02.ts"]);
-		assert.equal(summary.truncated, true);
-		assert.match(summary.message, /\.\.\. \(5 more\)/);
-		assert.doesNotMatch(summary.message, /src\/file-25\.ts/);
-		assert.equal(summary.recoveryNeeded, true);
-		assert.equal(summary.reason, "timed-out-with-dirty-worktree");
-		assert.equal(summary.reportStatus, "missing");
-		assert.match(summary.message, /Recovery needed/i);
-		assert.match(summary.message, /requested report: missing/i);
-		assert.match(summary.message, /review (?:the )?diff and artifacts before resuming/i);
-		assert.match(summary.message, /dependent stages/i);
-	});
-});