mjolnir-qa 4.0.0 → 6.0.0

package/dist/mcp/stdio.mjs

@@ -5,6 +5,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { closeSync, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, statSync, unlinkSync, writeSync } from "node:fs";
 import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { execFileSync } from "node:child_process";
+import { AsyncLocalStorage } from "node:async_hooks";
 import * as ts$2 from "ts-morph";
 import ts, { Project, SyntaxKind, ts as ts$1 } from "ts-morph";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -35,6 +36,23 @@ const SEVERITY_ORDER = [
 *        retried, or timed out in the report).
 * INVARIANT (structurally enforced): L3–L5 require runtime
 * corroboration — a static-only finding can never claim L4/L5.
+*
+* THREE LADDER VOCABULARIES now share this shape, and the letters are the
+* only thing distinguishing them:
+*
+*   `L0`–`L5`  RUNTIME TRUST — how much a consumer can believe one finding.
+*              Here.
+*   `F0`–`F5`  FRAMEWORK SUPPORT — a hand-declared target per framework.
+*              `FrameworkSupportLevel`, src/frameworks/framework-inventory.ts
+*   `M0`–`M5`  CAPABILITY MATURITY — DERIVED from evidence, and the only
+*              one of the three that is a measurement.
+*              `Maturity`, src/v6/maturity.ts
+*
+* `tests/v6/maturity-vocabulary.spec.ts` holds the two vocabulary sets apart
+* and fails if they ever share a member. `M` is the only DERIVED of the three,
+* and that is the distinction worth remembering when reading a level out of a
+* report: `F` and `L` are declarations about the world, `M` is a function of
+* what this repository can demonstrate.
 */
 const TRUST_ORDER = [
 	"L0",
@@ -85,6 +103,7 @@ const DEDUCTIONS = {
 //#region src/engine/completion.ts
 function deriveCompletion(input) {
 	const truncationReasons = [...new Set(input.truncationReasons)].sort();
+	const degradations = [...input.degradations ?? []].sort((a, b) => a.reason < b.reason ? -1 : a.reason > b.reason ? 1 : 0);
 	const reasons = /* @__PURE__ */ new Set();
 	if (input.discoveryTruncated) reasons.add("discovery-truncated");
 	if (input.rulesPartial) reasons.add("rules-partial");
@@ -94,26 +113,73 @@ function deriveCompletion(input) {
 	if (input.scopeUnrecognized > 0) reasons.add(`scope-unrecognized:${input.scopeUnrecognized}`);
 	if (input.parseFailed > 0) reasons.add(`parse-failed:${input.parseFailed}`);
 	if (input.parseFallbacks && input.parseFallbacks > 0) reasons.add(`parse-fallbacks:${input.parseFallbacks}`);
+	if (input.astFallbackFiles && input.astFallbackFiles > 0) reasons.add(`ast-budget-fallback-files:${input.astFallbackFiles}`);
 	if (input.scopeDegraded) reasons.add(`scope-degraded:${input.scopeDegraded}`);
 	if (input.runtimeIncomplete) reasons.add("runtime-incomplete");
 	if (input.identityIncomplete) reasons.add("identity-incomplete");
 	for (const reason of truncationReasons) reasons.add(`truncated:${reason}`);
+	if ((input.rulesWithheld ?? 0) > 0) reasons.add(`coverage:quarantine:${input.rulesWithheld}`);
+	for (const entry of degradations) reasons.add(`degraded:${entry.reason}:${entry.count}`);
 	const discoveryPartial = input.discoveryTruncated || input.scopeIgnored > 0 || input.scopeUnrecognized > 0 || input.scopeDegraded !== void 0;
 	const rulesPartial = input.rulesPartial || input.rulesCrashed > 0 || input.parseFailed > 0;
+	const partial = discoveryPartial || rulesPartial || input.skippedFiles > 0 || input.runtimeIncomplete === true || input.identityIncomplete === true || truncationReasons.length > 0 || degradations.length > 0;
+	const rulesWithheld = input.rulesWithheld ?? 0;
 	return {
-		partial: discoveryPartial || rulesPartial || input.skippedFiles > 0 || input.runtimeIncomplete === true || input.identityIncomplete === true || truncationReasons.length > 0,
+		partial,
+		coverageState: rulesWithheld > 0 ? "PARTIAL" : "COMPLETE",
 		analysisStatus: {
 			discovery: discoveryPartial ? "partial" : "complete",
 			rules: rulesPartial ? "partial" : "complete",
 			skippedFiles: input.skippedFiles,
 			rulesCrashed: input.rulesCrashed,
 			parseFallbacks: input.parseFallbacks ?? 0,
+			rulesApplied: input.rulesApplied ?? 0,
+			rulesWithheld,
+			...input.withheldRuleIds !== void 0 && input.withheldRuleIds.length > 0 ? { withheldRuleIds: [...input.withheldRuleIds].sort() } : {},
 			...truncationReasons.length > 0 ? { truncationReasons } : {},
+			...degradations.length > 0 ? { degradations } : {},
 			reasons: [...reasons].sort()
 		}
 	};
 }
 //#endregion
+//#region src/engine/degradation-ledger.ts
+/**
+* Append-only. Records are never edited and never removed by a recording
+* site; a reader takes a window, and the window is defined by index, so
+* "delete my entry" is not an operation this module offers.
+*/
+const records = [];
+/** Record one capability loss. `count` is for a site that fails N at once. */
+function recordDegradation(reason, count = 1) {
+	if (!Number.isInteger(count) || count < 1) return;
+	for (let index = 0; index < count; index++) records.push({ reason });
+}
+/**
+* Mark where this reader's window opens. Everything appended from here on is
+* what the reader will see; see the file header for what a concurrent scan
+* does to that boundary.
+*/
+function beginDegradationWindow() {
+	return records.length;
+}
+/** The records appended since `marker`, without consuming them. */
+function degradationsSince(marker) {
+	return records.slice(marker);
+}
+/**
+* Per-reason counts for a window, sorted by reason so the output is
+* byte-deterministic for the same set of degradations.
+*/
+function summarizeDegradations(window) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const record of window) counts.set(record.reason, (counts.get(record.reason) ?? 0) + 1);
+	return [...counts.entries()].map(([reason, count]) => ({
+		reason,
+		count
+	})).sort((a, b) => a.reason < b.reason ? -1 : a.reason > b.reason ? 1 : 0);
+}
+//#endregion
 //#region src/engine/runtime-corroboration.ts
 /**
 * Stamp runtime corroboration + trust levels onto findings (mutates in
@@ -334,10 +400,10 @@ const MEASURED_FP = {
 	},
 	"QA-JV-101": {
 		fpRate: 0,
-		n: 23,
+		n: 35,
 		detectorRevision: 1,
 		ciLow: 0,
-		ciHigh: .1431
+		ciHigh: .0989
 	},
 	"QA-JV-102": {
 		fpRate: .261,
@@ -453,10 +519,10 @@ const MEASURED_FP = {
 	},
 	"QA-PW-117": {
 		fpRate: 0,
-		n: 24,
+		n: 35,
 		detectorRevision: 1,
 		ciLow: 0,
-		ciHigh: .138
+		ciHigh: .0989
 	},
 	"QA-PW-121": {
 		fpRate: 0,
@@ -543,25 +609,18 @@ const MEASURED_FP = {
 		ciHigh: .2425
 	},
 	"QA-PY-002": {
-		fpRate: .043,
-		n: 23,
+		fpRate: .12,
+		n: 25,
 		detectorRevision: 1,
-		ciLow: .0077,
-		ciHigh: .2099
+		ciLow: .0417,
+		ciHigh: .2996
 	},
 	"QA-PY-003": {
-		fpRate: .467,
-		n: 30,
+		fpRate: .515,
+		n: 33,
 		detectorRevision: 4,
-		ciLow: .3023,
-		ciHigh: .6386
-	},
-	"QA-PY-004": {
-		fpRate: .533,
-		n: 30,
-		detectorRevision: 3,
-		ciLow: .3614,
-		ciHigh: .6977
+		ciLow: .3522,
+		ciHigh: .675
 	},
 	"QA-PY-005": {
 		fpRate: .13,
@@ -844,6 +903,58 @@ function buildTrustSummary(result, declarationsByFile) {
 	};
 }
 //#endregion
+//#region src/governance/run-mode.ts
+/**
+* Which mode a run is in, and how the other one is reached.
+*
+* ADR 0012: `local-only` is the default and hosted mode is a declared state.
+* This module is the enforcement point, and its shape is the decision:
+*
+*   - `resolveRunMode` takes its inputs as an ARGUMENT, never from
+*     `process.env`. Nothing here can read the environment, so a stray
+*     `MJOLNIR_MODE` in a shell, in CI, or in a parent's environment cannot
+*     change what a run does. The first version of the test passed an `env`
+*     bag and asserted it was ignored — and that only means something because
+*     this function is structurally unable to consult one.
+*   - `isHostedModeReachable` is the single predicate every entry point has to
+*     pass through, and it answers the same question separately from
+*     `resolveRunMode`. Separating them is what stops a caller satisfying the
+*     easy one: the first says whether the mode MAY be entered, the second
+*     says which mode this run IS.
+*   - an unrecognised declaration THROWS. A typo in a build flag that fell back
+*     to `local-only` would mean a deployment believed it was hosted and was
+*     not — the same class of failure as a gate that reports success for
+*     something it did not run.
+*
+* Hosted mode is not implemented. This is the contract it will have to
+* satisfy, and it is deliberately the smallest thing that can be wrong in only
+* one direction.
+*/
+/**
+* The build-time declaration that opts a build into hosted mode.
+*
+* A build flag rather than an environment variable, because a build flag is
+* something a release engineer sets deliberately and reviews in a diff, and
+* because an environment variable is set by whatever CI last happened to run
+* with.
+*/
+const HOSTED_MODE_FLAG = "mjolnir-mode";
+/**
+* The mode this run is in.
+*
+* Throws on a declaration it does not recognise. A silent fallback here is the
+* failure ADR 0012 exists to prevent: a build that asked for hosted mode,
+* mistyped the flag, and ran local-only would report local-only artefacts into
+* a pipeline that believed otherwise.
+*/
+function resolveRunMode(input) {
+	const declared = input.flags[HOSTED_MODE_FLAG];
+	if (declared === void 0 || declared === false) return "local-only";
+	if (declared === true) throw new Error(`${HOSTED_MODE_FLAG} was given without a value. Use "${HOSTED_MODE_FLAG}=hosted" or omit it.`);
+	if (declared === "local-only" || declared === "hosted") return declared;
+	throw new Error(`${HOSTED_MODE_FLAG}=${String(declared)} is not a run mode. Expected "hosted" or "local-only". Falling back to a default here would let a mistyped flag look like a deliberate choice.`);
+}
+//#endregion
 //#region src/engine/run-identity.ts
 /**
 * Run Identity (product-gap master plan §7, plan 1789009691197 R4c) —
@@ -884,6 +995,7 @@ function buildRunIdentity(input) {
 	if (input.commit !== void 0) verdictInputs.commit = input.commit;
 	if (input.tree !== void 0) verdictInputs.tree = input.tree;
 	if (input.lockfile !== void 0) verdictInputs.lockfile = input.lockfile;
+	if (input.runMode !== void 0) verdictInputs.runMode = input.runMode;
 	if (input.candidate !== void 0) verdictInputs.candidate = {
 		manifestId: input.candidate.manifestId,
 		state: input.candidate.state,
@@ -916,6 +1028,7 @@ function buildRunIdentity(input) {
 		rulesDigest,
 		configFingerprint,
 		engineVersion: input.engineVersion,
+		...input.runMode !== void 0 ? { runMode: input.runMode } : {},
 		boundLinks,
 		...input.trustModelVersion !== void 0 ? { trustModelVersion: input.trustModelVersion } : {},
 		...input.scoringModelVersion !== void 0 ? { scoringModelVersion: input.scoringModelVersion } : {},
@@ -1064,6 +1177,120 @@ function createExecutor(name, concurrency, runOne) {
 	};
 }
 //#endregion
+//#region src/scope/git-resolve.ts
+/**
+* Absolute-path git resolution (audit S1).
+*
+* `execFileSync("git", …)` resolves through PATH — including the CWD on
+* Windows (CreateProcess searches the current directory before PATH for
+* extension-less names depending on NoDefaultCurrentDirectoryInExePath).
+* Scanning an UNTRUSTED repo therefore let a checked-in `git.exe` (or
+* `git.bat`/`git.cmd`) hijack Mjölnir's own git invocations: the attacker
+* controls the diff output, the merge-base decision, and
+* `--scope changed`'s "what is new" answer — the exact data CI gates on.
+*
+* The fix: resolve git ONCE per process to an ABSOLUTE path by walking
+* the PATH directly (never consulting the CWD), verify the candidate is
+* an existing file, and pass that path to execFileSync. Resolution is
+* memoized; a failure to find a real git anywhere on PATH is recorded
+* and callers degrade without invoking a bare name.
+*/
+let resolvedGit = void 0;
+/**
+* The absolute path of the git binary Mjölnir will invoke, or null when
+* PATH carries no executable `git` at all. Callers must degrade without
+* invoking a bare name.
+*/
+function resolveGitPath() {
+	if (resolvedGit !== void 0) return resolvedGit;
+	const candidates = [process.platform === "win32" ? "git.exe" : "git"];
+	if (process.platform === "win32") {
+		const pathExt = process.env["PATHEXT"]?.split(";").filter(Boolean) ?? [];
+		for (const ext of pathExt) candidates.push(`git${ext.toLowerCase()}`);
+	}
+	const pathValue = process.env["PATH"] ?? "";
+	for (const dir of pathValue.split(delimiter)) {
+		if (dir === "") continue;
+		if (!isAbsolute(dir)) continue;
+		for (const candidate of candidates) {
+			const full = join(dir, candidate);
+			try {
+				if (existsSync(full)) {
+					resolvedGit = full;
+					return resolvedGit;
+				}
+			} catch {}
+		}
+	}
+	`${pathValue.length}`;
+	resolvedGit = null;
+	return resolvedGit;
+}
+/**
+* Run git with the S1-resolved absolute binary path. Returns stdout, or
+* null when git is missing or the command fails — the same contract as
+* the previous inline `git()` helpers, with the hijack surface closed.
+*/
+function runGit(root, args) {
+	const exe = resolveGitPath();
+	if (!exe) return null;
+	try {
+		return execFileSync(exe, [
+			"-C",
+			root,
+			...args
+		], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			timeout: 15e3
+		});
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/lib/safe-json.ts
+/**
+* Reusable safe-JSON parse-and-validate helper.
+*
+* Replaces the `JSON.parse(text) as T` pattern with a two-step process:
+*   1. Try/catch around JSON.parse (descriptive error on bad JSON)
+*   2. Runtime validation of the parsed shape (caller-supplied predicate)
+*
+* The `validate` predicate is intentionally lightweight — it checks the
+* expected shape exists rather than exhaustively type-guarding every field.
+* Internal files (cache, hashes) use `isRecord`; user-facing files
+* (config, plugins) use stricter checks that throw descriptive errors.
+*/
+const MAX_JSON_BYTES = 16777216;
+function parseJsonFile(text, source, validate) {
+	if (Buffer.byteLength(text, "utf8") > MAX_JSON_BYTES) throw new Error(`JSON source exceeds the ${MAX_JSON_BYTES}-byte limit: ${source}`);
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch (err) {
+		throw new Error(`invalid JSON in ${source}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+	}
+	if (!validate(parsed)) throw new Error(`unexpected shape in ${source}`, { cause: parsed });
+	return parsed;
+}
+/**
+* Minimal validator: value is a plain object (not null, not array).
+* Sufficient for internal files (cache, hashes) where downstream
+* code already checks individual fields.
+*/
+function isRecord(v) {
+	try {
+		return typeof v === "object" && v !== null && !Array.isArray(v);
+	} catch {
+		return false;
+	}
+}
+//#endregion
 //#region src/engine/candidate-binding.ts
 /**
 * Candidate binding (plan V5-010).
@@ -1084,9 +1311,6 @@ const SHA40 = /^[a-f0-9]{40}$/;
 const SHA256 = /^[a-f0-9]{64}$/;
 const STATES = ["WORKING_CANDIDATE", "RELEASE_CANDIDATE"];
 const AUTHORIZATION = ["NOT_AUTHORIZED", "AUTHORIZED"];
-function isRecord$1(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function sha256File(path) {
 	try {
 		return createHash("sha256").update(readFileSync(path)).digest("hex");
@@ -1094,17 +1318,41 @@ function sha256File(path) {
 		return;
 	}
 }
+/**
+* One git line, or nothing.
+*
+* Audit S1: the binary is the ABSOLUTE path `resolveGitPath()` found by
+* walking PATH itself, never the bare name. `bindRepository()` runs on every
+* scan (`scan-pipeline.ts`), and a bare `execFileSync("git", …)` lets a
+* `git.exe`/`git.bat`/`git.cmd` CHECKED INTO AN UNTRUSTED REPO hijack the
+* call on Windows, where CreateProcess searches the current directory before
+* PATH. The attacker then controls the `commit` and `tree` that land in
+* `runIdentity` and the evidence graph — the provenance a release decision
+* reads. This was the last bare-name exec left in `src/`; the invariant that
+* keeps it that way is `tests/contract/no-bare-process-exec.spec.ts`.
+*
+* The `-C <root>` shape (not `cwd`) matches every other hardened call site.
+* With no git on PATH at all, the answer is nothing — a scan of an unpacked
+* tarball has no commit, and its identity must say so rather than carrying a
+* placeholder that looks like provenance.
+*/
 function gitLine(root, args) {
+	const exe = resolveGitPath();
+	if (!exe) return void 0;
 	try {
-		const trimmed = execFileSync("git", args, {
-			cwd: root,
+		const trimmed = execFileSync(exe, [
+			"-C",
+			root,
+			...args
+		], {
 			encoding: "utf8",
 			stdio: [
 				"ignore",
 				"pipe",
 				"ignore"
 			],
-			windowsHide: true
+			windowsHide: true,
+			timeout: 15e3
 		}).trim();
 		return trimmed.length > 0 ? trimmed : void 0;
 	} catch {
@@ -1135,9 +1383,9 @@ function bindRepository(root) {
 * contradiction the release decision evaluator treats as BLOCKED).
 */
 function parseCandidateBinding(raw) {
-	if (!isRecord$1(raw)) return null;
+	if (!isRecord(raw)) return null;
 	const identity = raw.identity;
-	if (!isRecord$1(identity)) return null;
+	if (!isRecord(identity)) return null;
 	const state = identity.state;
 	const candidateSha = identity.candidateSha;
 	const baseSha = identity.baseSha;
@@ -1183,10 +1431,50 @@ function readCandidateBinding(root, manifestPath = CANDIDATE_MANIFEST_PATH) {
 * version inside scan-pipeline WITHOUT importing cli.ts (a cycle — cli
 * imports the pipeline). The literal follows the same discipline as
 * CLI_VERSION and SARIF's driver.version: kept in sync on release by
-* scripts/sync-sarif-version.cjs and guarded by the version-consistency
+* scripts/archive/sync-sarif-version.cjs (archived; superseded by the release
+* workflow's own version stamping) and guarded by the version-consistency
 * spec. cli.ts re-exports this as CLI_VERSION.
 */
-const ENGINE_VERSION = "4.0.0";
+const ENGINE_VERSION = "6.0.0";
+resolveBuildId();
+/**
+* The decision, with the process boundary already behind `runGit`.
+*
+* Separated so every branch is reachable from a test: a runner that throws and
+* a runner that answers are both things that happen, and both are what this
+* function exists to survive. What it must never do is invent an answer.
+*/
+function buildIdFrom(runGit) {
+	const sha = runGit([
+		"rev-parse",
+		"--short=12",
+		"HEAD"
+	]);
+	if (!sha) return void 0;
+	const status = runGit(["status", "--porcelain"]);
+	if (status === void 0) return `${sha}-dirty`;
+	return status ? `${sha}-dirty` : sha;
+}
+function resolveBuildId() {
+	const git = resolveGitPath();
+	if (!git) return void 0;
+	const runGit = (args) => {
+		try {
+			return execFileSync(git, args, {
+				encoding: "utf8",
+				timeout: 2e3,
+				stdio: [
+					"ignore",
+					"pipe",
+					"ignore"
+				]
+			}).trim();
+		} catch {
+			return;
+		}
+	};
+	return buildIdFrom(runGit);
+}
 //#endregion
 //#region src/engine/contract-versions.ts
 /**
@@ -1198,7 +1486,15 @@ const ENGINE_VERSION = "4.0.0";
 * surface without widening.
 */
 const TRUST_MODEL_VERSION = "1.0.0";
-const SCORING_MODEL_VERSION = "1.0.0";
+/**
+* 2.0.0 (ADR 0014): the core tier carries an evidence FLOOR. A core rule's
+* finding is now stamped to at least E1, which changes `deductionFor` for
+* every core finding from 0 (E0) to `floor(base/2)`. The E0→E1→E2 ladder
+* itself is unchanged; what changed is which rung a core finding is allowed
+* to sit on, and therefore what it costs. Major, per the `semver + ADR
+* required` policy on the entry below.
+*/
+const SCORING_MODEL_VERSION = "2.0.0";
 const FRAMEWORK_SUPPORT_MATRIX_VERSION = "1.0.0";
 //#endregion
 //#region src/discovery/evidence-discovery.ts
@@ -1245,6 +1541,11 @@ const EVIDENCE_CONVENTIONS = [
 		convention: "junit-file",
 		kind: "file",
 		names: ["junit-report.xml", "junit.xml"]
+	},
+	{
+		convention: "dotnet-trx",
+		kind: "dir",
+		names: ["TestResults"]
 	}
 ];
 const SEARCH_DEPTH = 2;
@@ -1315,9 +1616,12 @@ function discoverWorkspace(rootDir) {
 	const root = findProjectRoot(rootDir);
 	if (!root) return null;
 	let pkg = {};
-	try {
-		pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
-	} catch {}
+	const manifestPath = join(root, "package.json");
+	if (existsSync(manifestPath)) try {
+		pkg = JSON.parse(readFileSync(manifestPath, "utf8"));
+	} catch {
+		recordDegradation("workspace-manifest-unreadable");
+	}
 	const rawWorkspaces = pkg["workspaces"];
 	let globs = [];
 	if (Array.isArray(rawWorkspaces)) globs = rawWorkspaces.filter((w) => typeof w === "string");
@@ -1334,40 +1638,6 @@ function basename$1(p) {
 	return parts[parts.length - 1];
 }
 //#endregion
-//#region src/lib/safe-json.ts
-/**
-* Reusable safe-JSON parse-and-validate helper.
-*
-* Replaces the `JSON.parse(text) as T` pattern with a two-step process:
-*   1. Try/catch around JSON.parse (descriptive error on bad JSON)
-*   2. Runtime validation of the parsed shape (caller-supplied predicate)
-*
-* The `validate` predicate is intentionally lightweight — it checks the
-* expected shape exists rather than exhaustively type-guarding every field.
-* Internal files (cache, hashes) use `isRecord`; user-facing files
-* (config, plugins) use stricter checks that throw descriptive errors.
-*/
-const MAX_JSON_BYTES = 16777216;
-function parseJsonFile(text, source, validate) {
-	if (Buffer.byteLength(text, "utf8") > MAX_JSON_BYTES) throw new Error(`JSON source exceeds the ${MAX_JSON_BYTES}-byte limit: ${source}`);
-	let parsed;
-	try {
-		parsed = JSON.parse(text);
-	} catch (err) {
-		throw new Error(`invalid JSON in ${source}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
-	}
-	if (!validate(parsed)) throw new Error(`unexpected shape in ${source}`, { cause: parsed });
-	return parsed;
-}
-/**
-* Minimal validator: value is a plain object (not null, not array).
-* Sufficient for internal files (cache, hashes) where downstream
-* code already checks individual fields.
-*/
-function isRecord(v) {
-	return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-//#endregion
 //#region src/lib/fs-bounded.ts
 function closeQuiet(fd) {
 	try {
@@ -1597,6 +1867,12 @@ function validate(cfg, knownRuleIds) {
 * Expiry is evaluated only from an explicit ISO `expires` date. A missing
 * date remains active and is reported as having no expiry. Config-file mtime
 * is never an expiry anchor.
+*
+* `now` defaults to the current instant so existing callers stay correct, but
+* a verdict function that reads the clock invisibly is a verdict nobody can
+* test at a boundary. `tests/contract/deterministic-clock.spec.ts` audits
+* `src/config/**` for a call site that supplies its own `new Date()` instead
+* of threading one through.
 */
 function isSuppressionActive(ign, now = /* @__PURE__ */ new Date()) {
 	if (!ign.expires) return true;
@@ -1621,6 +1897,108 @@ function applySeverityOverrides(findings, cfg) {
 	}
 }
 //#endregion
+//#region src/lib/compare.ts
+/**
+* Order that does not depend on who is asking.
+*
+* `String.prototype.localeCompare` with no locale argument resolves against
+* the PROCESS's default locale — the ICU collation chosen by `LANG`,
+* `LC_ALL` or the OS. So a sort written as
+* `[...xs].sort((a, b) => a.localeCompare(b))` produces a different order on
+* a developer's `de_DE` machine than on an en-US CI runner. For a display
+* list that is a nuisance; for anything that reaches a hash, a cache key, a
+* digest or a machine contract it is a correctness bug, because the same
+* repository then produces two different fingerprints.
+*
+* Two comparators, one per kind of site:
+*
+*   compareCodePoints — pure UTF-16 code-unit order. Identical everywhere,
+*   independent of ICU version, and already what `Array.prototype.sort`
+*   defaults to. Use for every value that reaches a fingerprint, a digest,
+*   a cache key, or a contract, and for any ordering with no human-facing
+*   reason to be pretty.
+*
+*   compareLocalized(locale) — the same collator, PINNED to a named locale
+*   instead of inheriting the environment, for a surface that genuinely
+*   wants readable order (a table of rule titles, a Mermaid legend). Pinned
+*   rather than removed because a reader-facing list of "Test / Logic /
+*   Mock" should not be ordered by code unit.
+*
+* A bare `localeCompare` with no second argument in `src/` is a defect and
+* `tests/contract/deterministic-ordering.spec.ts` fails the build on it.
+*/
+/** Code-unit order. Locale-free, ICU-free, and the Array.sort default. */
+function compareCodePoints(a, b) {
+	if (a === b) return 0;
+	return a < b ? -1 : 1;
+}
+/**
+* A readable-order comparator pinned to `locale`.
+*
+* The pin is the point: `a.localeCompare(b)` reads the environment, and the
+* environment is a machine setting, not a property of the code. Callers that
+* want stable output ask for a named locale and get the same answer on every
+* machine that ships the same ICU data.
+*/
+function compareLocalized(locale) {
+	return (a, b) => a.localeCompare(b, locale);
+}
+//#endregion
+//#region src/lib/glob.ts
+/**
+* The shared segment compiler: a glob to a regex BODY, with no anchors.
+*
+* Module-private because the anchoring is a caller decision and the DIALECT is
+* not: the repository needs a full-path match and a bare-name-at-any-depth
+* match, and duplicating the segment walk to get the second one is exactly how
+* two compilers came to disagree. Callers pick an anchoring; the dialect is
+* decided here and nowhere else.
+*
+* `?`, `[`, `]`, `!` and every other regex metacharacter in the literal parts
+* are escaped, so nothing a user writes in a config or ledger can reach the
+* regex engine as syntax. `*` is the only metacharacter.
+*/
+function globBody(glob) {
+	const segments = glob.replaceAll("\\", "/").split("/");
+	let re = "";
+	for (const [i, segment] of segments.entries()) {
+		const last = i === segments.length - 1;
+		if (segment === "**") {
+			re += last ? "(?:[^/]+/)*[^/]+" : "(?:[^/]+/)*";
+			continue;
+		}
+		re += segment.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", "[^/]*");
+		if (!last) re += "/";
+	}
+	return re;
+}
+/** A glob as a regex anchored to the WHOLE path. */
+function anchoredGlobRegExp(glob) {
+	return new RegExp(`^${globBody(glob)}$`);
+}
+/**
+* A glob as a regex matching at ANY DEPTH — a bare name.
+*
+* `node_modules` becomes "a file or directory of this name anywhere", which is
+* gitignore semantics: every path inside the directory contains the segment, so
+* a directory match carries to its contents.
+*/
+function anyDepthGlobRegExp(glob) {
+	return new RegExp(`(?:^|/)${globBody(glob)}(?:/|$)`);
+}
+/**
+* Whether `path` matches `glob`, in the dialect documented above.
+*
+* Both sides are normalized to forward slashes first. Finding paths are already
+* normalized by the walker, but a suppression `files` pattern written on
+* Windows ("e2e\\x.spec.ts") compiled to a literal-backslash regex that could
+* never match any finding — the suppression silently never applied, which is
+* the defect that made the whole dialect worth unifying.
+*/
+function pathMatchesGlob(path, glob) {
+	return anchoredGlobRegExp(glob).test(path.replaceAll("\\", "/"));
+}
+//#endregion
 //#region src/discovery/ignores.ts
 /**
 * Ignore resolution (Product-MVP.txt R1 — Tier-1 launch blocker).
@@ -1755,32 +2133,12 @@ function compilePattern(raw) {
 	if (pattern.trim() === "") return null;
 	if (pattern.length > LIMITS$1.maxPatternLength) return null;
 	if ((pattern.match(/[*?]/g) ?? []).length > LIMITS$1.maxPatternWildcards) return null;
-	const re = pattern.includes("/") ? new RegExp(`^${globBody(pattern)}$`) : new RegExp(`(?:^|/)${globBody(pattern)}(?:/|$)`);
+	const re = pattern.includes("/") ? anchoredGlobRegExp(pattern) : anyDepthGlobRegExp(pattern);
 	return {
 		negated,
 		re
 	};
 }
-/** The minimal glob dialect as a regex body without anchors. */
-function globBody(glob) {
-	let re = "";
-	for (let i = 0; i < glob.length; i++) {
-		const c = glob[i];
-		if (c === "*") {
-			if (glob[i + 1] === "*") {
-				if (glob[i + 2] === "/") {
-					re += "(?:[^/]*/)*";
-					i += 2;
-				} else {
-					re += ".*";
-					i += 1;
-				}
-			} else re += "[^/]*";
-		} else if (c === "?") re += "[^/]";
-		else re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-	}
-	return re;
-}
 createMatcherFromPatterns([]);
 /**
 * Check if a directory is a lint-fixture shape (Phase 2 auto-detection).
@@ -1957,16 +2315,29 @@ function detectFrameworks(ws) {
 * Migration discipline (per the plan): rule-by-rule, golden lock must stay
 * byte-identical — a score shift is a regression, not an improvement.
 */
-let project = null;
 /**
-* The shared ts-morph project.
+* One shared Project PER SCAN keeps memory bounded while reusing the compiler's
+* program across files.
 *
-* Exported so an adapter's `dispose()` can evict the file it parsed: ts-morph
-* caches by file path, so without eviction a long scan holds every parsed
-* SourceFile until the process exits (plan V5-021).
-*/
-function getProject() {
-	if (!project) project = new Project({
+* "Per scan" has to mean per scan. The variable lived at module scope, so it
+* was one Project per PROCESS, and two scans running concurrently shared it —
+* `parseTsFile` calls `replaceWithText` on a cached SourceFile, so scan B
+* could overwrite the text scan A was mid-rule on. ts-morph's in-memory file
+* system and language service are not reentrant, and the observable result was
+* three of four concurrent scans reporting `rulesCrashed: 4` with
+* `rules: "partial"` — different machine-contract digests from the same tree,
+* which is the one thing this product claims cannot happen.
+*
+* An AsyncLocalStorage scope is the smallest change that makes the comment
+* true: each scan's async context carries its own Project, memory stays bounded
+* per scan exactly as intended, and the context is collected when the scan's
+* promise chain is. The loose project below remains for callers outside a scan
+* (tests, one-off parses), where there is nothing to collide with.
+*/
+const scanProjects = new AsyncLocalStorage();
+let looseProject = null;
+function createProject() {
+	return new Project({
 		useInMemoryFileSystem: true,
 		skipAddingFilesFromTsConfig: true,
 		compilerOptions: {
@@ -1975,7 +2346,28 @@ function getProject() {
 			noEmit: true
 		}
 	});
-	return project;
+}
+/**
+* Run `fn` with its own ts-morph Project.
+*
+* Async context propagates across `await`, so the Project stays the scan's own
+* for the whole scan without threading an argument through every adapter.
+*/
+function runWithScanProject(fn) {
+	return scanProjects.run(createProject(), fn);
+}
+/**
+* The ts-morph Project for the current scan.
+*
+* Exported so an adapter's `dispose()` can evict the file it parsed: ts-morph
+* caches by file path, so without eviction a long scan holds every parsed
+* SourceFile until the process exits (plan V5-021).
+*/
+function getProject() {
+	const scoped = scanProjects.getStore();
+	if (scoped !== void 0) return scoped;
+	looseProject ??= createProject();
+	return looseProject;
 }
 /**
 * Parse (or fetch from cache) the ts-morph SourceFile for a scanned file.
@@ -1992,6 +2384,7 @@ function parseTsFile(file) {
 		}
 		return p.createSourceFile(file.path, file.text);
 	} catch {
+		recordDegradation("ast-parse-failed");
 		return;
 	}
 }
@@ -2047,6 +2440,7 @@ function commentAndStringRanges(ctx) {
 		}
 		return ranges;
 	} catch {
+		recordDegradation("ast-range-scan-failed");
 		return [];
 	}
 }
@@ -2094,12 +2488,20 @@ function getCodeOnlyText(file) {
 		for (const r of ranges) for (let i = r.start; i < r.end && i < chars.length; i++) if (chars[i] !== "\n" && chars[i] !== "\r") chars[i] = " ";
 		return chars.join("");
 	} catch {
+		recordDegradation("ast-mask-unavailable");
 		return file.text;
 	}
 }
-/** Release the shared ts-morph Project between scans to free memory. */
+/**
+* Release the loose ts-morph Project used outside a scan.
+*
+* Deliberately does NOT call `scanProjects.disable()`. Scan-scoped Projects are
+* released by garbage collection when the scan's async context ends, and
+* `disable()` would tear the store out from under a scan still running — the
+* exact corruption this scoping exists to remove.
+*/
 function resetTsMorphProject() {
-	project = null;
+	looseProject = null;
 }
 //#endregion
 //#region src/engine/code-text.ts
@@ -2478,6 +2880,44 @@ function frameworkFilterApplies(rule, file) {
 	return rule.frameworks.some((f) => tags.includes(f));
 }
 //#endregion
+//#region src/engine/shared-run-rules.ts
+/**
+* Run ONE rule with crash isolation, and return what it produced.
+*
+* This is the block that was copy-pasted into all seven language adapters:
+*
+*   try { for (const f of rule.run(x)) emit(f, rule.id, rule.category); }
+*   catch (error) { onCrash?.(rule.id, error); }
+*
+* Extracting it is worth doing for one reason beyond line count. Crash
+* isolation is the mechanism that lets a third-party or experimental
+* detector fail without ending a scan, and it is the mechanism the whole
+* `rulesCrashed` count depends on. Seven copies means seven chances to
+* write `catch {}` and lose the count, and `tests/contract/
+* no-uncounted-degradation.spec.ts` can only audit what it can see.
+*
+* `null` means the rule CRASHED, which is not the same as an empty array:
+* an empty array is the rule abstaining, and the adapters skip emission for
+* both but the distinction is why the caller must not conflate them.
+*
+* Deliberately NOT extracted: the per-adapter filter chain and the budget
+* check. Those genuinely differ — the TypeScript adapter injects an AST,
+* framework tags, a lazy `codeText` getter, `appliesTo` scoping, config-only
+* gating and `configGateMatches`, and it ABORTS the whole file on budget
+* exhaustion where `runRulesShared` only `continue`s to the next rule.
+* Routing every adapter through `runRulesShared` as written would silently
+* change which rules run and when, which is precisely the unmeasured claim
+* this program exists to delete. This helper takes the part they share.
+*/
+function runRuleIsolated(rule, file, onCrash) {
+	try {
+		return rule.run(file);
+	} catch (error) {
+		onCrash?.(rule.id, error);
+		return null;
+	}
+}
+//#endregion
 //#region src/adapters/typescript.ts
 /**
 * TypeScript/JavaScript adapter (R1).
@@ -2515,10 +2955,18 @@ function frameworkFilterApplies(rule, file) {
 * four lines below: PW_CONFIG_RE already accepted `cts`. The config regex knew
 * about the Node-native extensions; the test-file regex did not.
 *
-* `discovery/scan-adapters.ts:isUnrecognizedSourceCandidate` already counted
-* these paths as uncovered surface, so the scope accounting had been reporting
-* the hole the whole time — it was being read as a known limitation rather than
-* as a defect.
+* `discovery/scan-adapters.ts:isUnrecognizedSourceCandidate` counts these
+* paths as uncovered surface, so the scope accounting reports a hole if one
+* exists.
+*
+* CORRECTION: the comment this replaced said the scope accounting "had been
+* reporting the hole the whole time". It had not — that checker's regex
+* already matched `mts`/`cts`, and only `extensions` was unread. What WAS
+* true, and is what this entry now fixes, is that a field every adapter
+* declares and no code consulted is a claim the interface makes to anyone who
+* reads it. `isUnrecognizedSourceCandidate` now builds its extension set from
+* this list rather than from a second hard-coded one, which is what makes the
+* two halves of the same fact stop being able to drift.
 */
 const TEST_FILE_RE = /\.(?:test|spec)\.(?:js|jsx|ts|tsx|mjs|cjs|mts|cts)$|\.cy\.(?:js|jsx|ts|tsx)$/;
 /**
@@ -2590,7 +3038,9 @@ const typescriptAdapter = {
 		".js",
 		".jsx",
 		".mjs",
-		".cjs"
+		".cjs",
+		".mts",
+		".cts"
 	],
 	testFileGlobs: [
 		"*.test.{js,jsx,ts,tsx,mjs,cjs}",
@@ -2687,11 +3137,9 @@ const typescriptAdapter = {
 				budget.onExceeded();
 				return;
 			}
-			try {
-				for (const f of rule.run(enriched)) emit(f, rule.id, rule.category);
-			} catch (error) {
-				onCrash?.(rule.id, error);
-			}
+			const produced = runRuleIsolated(rule, enriched, onCrash);
+			if (produced === null) continue;
+			for (const f of produced) emit(f, rule.id, rule.category);
 		}
 	}
 };
@@ -2719,6 +3167,7 @@ function loadWorkspaceShim(root) {
 			workspaceGlobs: []
 		};
 	} catch {
+		recordDegradation("workspace-manifest-unreadable");
 		return null;
 	}
 }
@@ -2802,7 +3251,11 @@ async function withParseSlot(fn) {
 }
 function grammarPath(fileName) {
 	const here = dirname(fileURLToPath(import.meta.url));
-	const candidates = [join(here, "..", "..", "node_modules", "tree-sitter-wasms", "out", fileName), join(here, "..", "node_modules", "tree-sitter-wasms", "out", fileName)];
+	const candidates = [
+		join(here, "..", "..", "node_modules", "tree-sitter-wasms", "out", fileName),
+		join(here, "..", "node_modules", "tree-sitter-wasms", "out", fileName),
+		join(here, "..", "..", "..", "node_modules", "tree-sitter-wasms", "out", fileName)
+	];
 	return candidates.find((p) => existsSync(p)) ?? candidates[0];
 }
 async function ensureParserInitialized() {
@@ -2882,6 +3335,7 @@ async function parseJavaAst(text) {
 			return (await getJavaParser()).parse(text) ?? void 0;
 		});
 	} catch {
+		recordDegradation("ast-grammar-unavailable");
 		return;
 	}
 }
@@ -2895,6 +3349,7 @@ async function parseCSharpAst(text) {
 			return (await getCSharpParser()).parse(text) ?? void 0;
 		});
 	} catch {
+		recordDegradation("ast-grammar-unavailable");
 		return;
 	}
 }
@@ -2910,6 +3365,7 @@ async function parsePythonAst(text) {
 			return (await getPythonParser()).parse(text) ?? void 0;
 		});
 	} catch {
+		recordDegradation("ast-grammar-unavailable");
 		return;
 	}
 }
@@ -3008,7 +3464,9 @@ const pythonAdapter = {
 		if (existsSync(pyproject)) try {
 			const text = readText$2(pyproject);
 			if (/\[tool\.pytest/i.test(text)) frameworks.add("pytest");
-		} catch {}
+		} catch {
+			recordDegradation("python-manifest-unreadable");
+		}
 		for (const reqFile of [
 			"requirements.txt",
 			"requirements-dev.txt",
@@ -3020,7 +3478,9 @@ const pythonAdapter = {
 				const text = readText$2(p);
 				if (/^selenium\b/im.test(text)) frameworks.add("selenium");
 				if (/^playwright\b/im.test(text)) frameworks.add("playwright");
-			} catch {}
+			} catch {
+				recordDegradation("python-manifest-unreadable");
+			}
 		}
 		if (frameworks.size === 0) return {
 			frameworks: [],
@@ -3073,11 +3533,9 @@ const pythonAdapter = {
 				budget.onExceeded();
 				return;
 			}
-			try {
-				for (const f of rule.run(enriched)) emit(f, rule.id, rule.category);
-			} catch (error) {
-				onCrash?.(rule.id, error);
-			}
+			const produced = runRuleIsolated(rule, enriched, onCrash);
+			if (produced === null) continue;
+			for (const f of produced) emit(f, rule.id, rule.category);
 		}
 	},
 	async parseAst(file) {
@@ -3230,11 +3688,9 @@ const javaAdapter = {
 				budget.onExceeded();
 				return;
 			}
-			try {
-				for (const f of rule.run(enriched)) emit(f, rule.id, rule.category);
-			} catch (error) {
-				onCrash?.(rule.id, error);
-			}
+			const produced = runRuleIsolated(rule, enriched, onCrash);
+			if (produced === null) continue;
+			for (const f of produced) emit(f, rule.id, rule.category);
 		}
 	}
 };
@@ -3388,11 +3844,9 @@ const csharpAdapter = {
 				budget.onExceeded();
 				return;
 			}
-			try {
-				for (const f of rule.run(enriched)) emit(f, rule.id, rule.category);
-			} catch (error) {
-				onCrash?.(rule.id, error);
-			}
+			const produced = runRuleIsolated(rule, enriched, onCrash);
+			if (produced === null) continue;
+			for (const f of produced) emit(f, rule.id, rule.category);
 		}
 	}
 };
@@ -3570,6 +4024,7 @@ const githubActionsAdapter = {
 		try {
 			entries = readdirSync(wfDir);
 		} catch {
+			recordDegradation("ci-workflow-listing-unreadable");
 			return;
 		}
 		for (const name of entries) {
@@ -3610,15 +4065,13 @@ const githubActionsAdapter = {
 				budget.onExceeded();
 				return;
 			}
-			try {
-				for (const f of rule.run({
-					path: file.path,
-					text: file.text,
-					ast: doc
-				})) emit(f, rule.id, rule.category);
-			} catch (error) {
-				onCrash?.(rule.id, error);
-			}
+			const produced = runRuleIsolated(rule, {
+				path: file.path,
+				text: file.text,
+				ast: doc
+			}, onCrash);
+			if (produced === null) continue;
+			for (const f of produced) emit(f, rule.id, rule.category);
 		}
 	}
 };
@@ -3928,15 +4381,13 @@ const azurePipelinesAdapter = {
 				budget.onExceeded();
 				return;
 			}
-			try {
-				for (const f of rule.run({
-					path: file.path,
-					text: file.text,
-					ast: doc
-				})) emit(f, rule.id, rule.category);
-			} catch (error) {
-				onCrash?.(rule.id, error);
-			}
+			const produced = runRuleIsolated(rule, {
+				path: file.path,
+				text: file.text,
+				ast: doc
+			}, onCrash);
+			if (produced === null) continue;
+			for (const f of produced) emit(f, rule.id, rule.category);
 		}
 	}
 };
@@ -4007,14 +4458,12 @@ const jenkinsAdapter = {
 				budget.onExceeded();
 				return;
 			}
-			try {
-				for (const f of rule.run({
-					path: file.path,
-					text: file.text
-				})) emit(f, rule.id, rule.category);
-			} catch (error) {
-				onCrash?.(rule.id, error);
-			}
+			const produced = runRuleIsolated(rule, {
+				path: file.path,
+				text: file.text
+			}, onCrash);
+			if (produced === null) continue;
+			for (const f of produced) emit(f, rule.id, rule.category);
 		}
 	}
 };
@@ -4113,109 +4562,50 @@ function isScopeRelevantIgnored(path) {
 	if (!/\.(?:[cm]?[jt]sx?|py|java|cs|ya?ml|min\.js)$/i.test(name)) return false;
 	return isKnownTestFile(path);
 }
-function isUnrecognizedSourceCandidate(path) {
-	const normalized = path.replaceAll("\\", "/");
-	const name = normalized.split("/").pop() ?? normalized;
-	if (normalized.includes(".github/workflows/") || name === "azure-pipelines.yml" || name === "Jenkinsfile") return false;
-	const extensionIndex = name.lastIndexOf(".");
-	const stem = extensionIndex > 0 ? name.slice(0, extensionIndex) : name;
-	if (name === "mjolnir.config.json" || name === ".mjolnir.json" || name === "package.json" || name === "package-lock.json" || name === "pnpm-lock.yaml" || name === "yarn.lock" || [
-		"playwright",
-		"vitest",
-		"vite",
-		"eslint",
-		"tsconfig",
-		"jsconfig"
-	].some((prefix) => stem === prefix || stem.startsWith(`${prefix}.`))) return false;
-	const testLike = /(?:^|\/)__tests__\//i.test(normalized) || /\.(?:spec|test)\.[cm]?[jt]sx?$/i.test(name);
-	return /\.(?:[cm]?[jt]sx?|py|java|cs|ya?ml)$/i.test(name) && testLike;
-}
-/** Whether ANY shipped adapter would discover this path as a test file. */
-function isKnownTestFile(path) {
-	return SCAN_ADAPTERS.some((a) => a.isTestFile(path));
-}
-/** True when any path segment (relative to the scan root) is a skip name. */
-function isInsideSkippedDir(root, absPath, skipNames) {
-	if (skipNames.length === 0) return false;
-	return relative(root, absPath).replaceAll("\\", "/").split("/").slice(0, -1).some((seg) => skipNames.includes(seg));
-}
-typescriptAdapter.testFileGlobs, pythonAdapter.testFileGlobs, javaAdapter.testFileGlobs, csharpAdapter.testFileGlobs, githubActionsAdapter.testFileGlobs, azurePipelinesAdapter.testFileGlobs, jenkinsAdapter.testFileGlobs;
-//#endregion
-//#region src/scope/git-resolve.ts
 /**
-* Absolute-path git resolution (audit S1).
+* Every source extension any shipped adapter claims.
 *
-* `execFileSync("git", …)` resolves through PATH — including the CWD on
-* Windows (CreateProcess searches the current directory before PATH for
-* extension-less names depending on NoDefaultCurrentDirectoryInExePath).
-* Scanning an UNTRUSTED repo therefore let a checked-in `git.exe` (or
-* `git.bat`/`git.cmd`) hijack Mjölnir's own git invocations: the attacker
-* controls the diff output, the merge-base decision, and
-* `--scope changed`'s "what is new" answer — the exact data CI gates on.
+* This is where `LanguageAdapter.extensions` is READ. The field was declared by
+* every adapter, listed a set of extensions, and consulted by nothing in
+* `src/` — so a support claim that no code checked was still a claim the
+* interface made to every reader.
 *
-* The fix: resolve git ONCE per process to an ABSOLUTE path by walking
-* the PATH directly (never consulting the CWD), verify the candidate is
-* an existing file, and pass that path to execFileSync. Resolution is
-* memoized; a failure to find a real git anywhere on PATH is recorded
-* and callers degrade without invoking a bare name.
-*/
-let resolvedGit = void 0;
-/**
-* The absolute path of the git binary Mjölnir will invoke, or null when
-* PATH carries no executable `git` at all. Callers must degrade without
-* invoking a bare name.
-*/
-function resolveGitPath() {
-	if (resolvedGit !== void 0) return resolvedGit;
-	const candidates = [process.platform === "win32" ? "git.exe" : "git"];
-	if (process.platform === "win32") {
-		const pathExt = process.env["PATHEXT"]?.split(";").filter(Boolean) ?? [];
-		for (const ext of pathExt) candidates.push(`git${ext.toLowerCase()}`);
-	}
-	const pathValue = process.env["PATH"] ?? "";
-	for (const dir of pathValue.split(delimiter)) {
-		if (dir === "") continue;
-		if (!isAbsolute(dir)) continue;
-		for (const candidate of candidates) {
-			const full = join(dir, candidate);
-			try {
-				if (existsSync(full)) {
-					resolvedGit = full;
-					return resolvedGit;
-				}
-			} catch {}
-		}
-	}
-	`${pathValue.length}`;
-	resolvedGit = null;
-	return resolvedGit;
+* Derived rather than hand-listed so the two halves cannot drift. A test
+* already compared the old hand-written regex against this set and found them
+* equivalent, which is the honest result: the refactor removes a second
+* source of truth rather than fixing a wrong answer. The `.mts`/`.cts` gap
+* was real but lived in `extensions`, not here, and is now closed there.
+*/
+const ADAPTER_CLAIMED_EXTENSIONS = new Set(SCAN_ADAPTERS.flatMap((adapter) => adapter.extensions).map((ext) => ext.replace(/^\./, "").toLowerCase()));
+/** Whether ignoring this file would have removed it from the scanned surface. */
+function isUnrecognizedSourceCandidate(path) {
+	const normalized = path.replaceAll("\\", "/");
+	const name = normalized.split("/").pop() ?? normalized;
+	if (normalized.includes(".github/workflows/") || name === "azure-pipelines.yml" || name === "Jenkinsfile") return false;
+	const extensionIndex = name.lastIndexOf(".");
+	const stem = extensionIndex > 0 ? name.slice(0, extensionIndex) : name;
+	if (name === "mjolnir.config.json" || name === ".mjolnir.json" || name === "package.json" || name === "package-lock.json" || name === "pnpm-lock.yaml" || name === "yarn.lock" || [
+		"playwright",
+		"vitest",
+		"vite",
+		"eslint",
+		"tsconfig",
+		"jsconfig"
+	].some((prefix) => stem === prefix || stem.startsWith(`${prefix}.`))) return false;
+	if (!(/(?:^|\/)__tests__\//i.test(normalized) || /\.(?:spec|test)\.[cm]?[jt]sx?$/i.test(name))) return false;
+	const extension = name.slice(name.lastIndexOf(".") + 1).toLowerCase();
+	return ADAPTER_CLAIMED_EXTENSIONS.has(extension);
 }
-/**
-* Run git with the S1-resolved absolute binary path. Returns stdout, or
-* null when git is missing or the command fails — the same contract as
-* the previous inline `git()` helpers, with the hijack surface closed.
-*/
-function runGit(root, args) {
-	const exe = resolveGitPath();
-	if (!exe) return null;
-	try {
-		return execFileSync(exe, [
-			"-C",
-			root,
-			...args
-		], {
-			encoding: "utf8",
-			stdio: [
-				"ignore",
-				"pipe",
-				"ignore"
-			],
-			timeout: 15e3
-		});
-	} catch {
-		return null;
-	}
+/** Whether ANY shipped adapter would discover this path as a test file. */
+function isKnownTestFile(path) {
+	return SCAN_ADAPTERS.some((a) => a.isTestFile(path));
+}
+/** True when any path segment (relative to the scan root) is a skip name. */
+function isInsideSkippedDir(root, absPath, skipNames) {
+	if (skipNames.length === 0) return false;
+	return relative(root, absPath).replaceAll("\\", "/").split("/").slice(0, -1).some((seg) => skipNames.includes(seg));
 }
+typescriptAdapter.testFileGlobs, pythonAdapter.testFileGlobs, javaAdapter.testFileGlobs, csharpAdapter.testFileGlobs, githubActionsAdapter.testFileGlobs, azurePipelinesAdapter.testFileGlobs, jenkinsAdapter.testFileGlobs;
 //#endregion
 //#region src/scope/changed.ts
 /**
@@ -5394,7 +5784,7 @@ const ASYNC_PW_MATCHERS = /* @__PURE__ */ new Set([
 ]);
 const unawaitedLocatorAssertion = defineRule({
 	id: "QA-PW-002",
-	tier: "core",
+	tier: "extended",
 	category: "QA-PW",
 	title: "Unawaited Playwright assertion",
 	severity: "error",
@@ -5508,7 +5898,7 @@ const committedDebugArtifacts = defineRule({
 		detail: "page.pause() and test.only() are exact Playwright runner tokens; the detector matches the member-call identifiers on the code-only text — closed token set, unique to the defect"
 	},
 	introduced: "0.1.0",
-	tier: "core",
+	tier: "extended",
 	run(ctx) {
 		const text = ctx.codeText ?? ctx.text;
 		const findings = [];
@@ -7334,7 +7724,7 @@ const pyHardSleep = defineRule({
 */
 const pySkippedTest = defineRule({
 	id: "QA-PY-002",
-	tier: "core",
+	tier: "extended",
 	category: "QA-TEST",
 	title: "Skipped test",
 	severity: "warning",
@@ -7470,7 +7860,7 @@ const pyFocusedTest = defineRule({
 		detail: "pytest.skip/xfail/parametrize marks are runner decorators and module-level calls; the detector matches those exact tokens on the code-only text — the semantics are runner skip state"
 	},
 	introduced: "0.3.0",
-	tier: "core",
+	tier: "extended",
 	suiteInvalidating: true,
 	run(ctx) {
 		const text = ctx.text;
@@ -7714,26 +8104,65 @@ function walk(node, visit) {
 	for (const child of node.children) walk(child, visit);
 }
 /**
+* The `pytest.raises` call that is a DIRECT context manager of `withNode`.
+*
+* Scopes the search to the with's own item list — `with_clause` for the
+* plain form, and `parenthesized_with_items` for `with (A, B):` — rather
+* than to the whole subtree. A call found deeper down belongs to an inner
+* `with_statement`, which the walk reaches in its own right and which owns
+* the block that actually gates it.
+*/
+function directRaisesItem(withNode) {
+	let found;
+	const scan = (n) => {
+		if (found) return;
+		if (n.type === "call") {
+			const fn = n.childForFieldName("function");
+			if (fn && /(?:^|\.)raises$/.test(fn.text)) {
+				found = n;
+				return;
+			}
+		}
+		for (const child of n.children) scan(child);
+	};
+	for (const child of withNode.children) if (child.type === "with_clause" || child.type === "parenthesized_with_items") scan(child);
+	return found;
+}
+/**
 * Every `with pytest.raises(...)` (optionally `... as exc`) statement in
 * the tree, with the structural facts the rework needs. Tree-sitter-
 * python grammar: a `with_statement` wraps `with_item`s and a `block`;
 * the raises call is a `call` whose function is an attribute chain
 * ending in `.raises`.
+*
+* 6.0. The raises call is now required to be a DIRECT context manager of the
+* `with_statement` being measured. It used to be found by walking the whole
+* subtree, so a `with pytest.raises(...)` nested inside another `with`
+* handed back the OUTER block's statement count — and `QA-PY-007`'s
+* single-statement gate, which exists precisely to suppress that shape,
+* could never fire for nested code.
+*
+* That is not a rare shape. In the pinned `pytest-dev/pytest` corpus, seven
+* of the eleven adjudicated findings were single-statement raises nested
+* inside `with saved_fd(1):`, and every one of them was counted as
+* multi-statement because the surrounding block has a dozen statements. The
+* rule measured the wrong block, which is why it measured 75% false
+* positives while its own unit fixtures passed.
+*
+* Requiring a direct context manager also fixes the shape by construction:
+* the outer `with` is examined, has no direct raises item, and is skipped;
+* the inner one is examined with its own block.
 */
 function pythonWithRaisesBlocks(tree) {
 	const out = [];
 	const root = tree.rootNode;
 	walk(root, (node) => {
 		if (node.type !== "with_statement") return;
-		let raisesCall;
 		let blockNode;
 		for (const child of node.children) if (child.type === "block") blockNode = child;
-		walk(node, (n) => {
-			if (raisesCall || n.type !== "call") return;
-			const fn = n.childForFieldName("function");
-			if (fn && /(?:^|\.)raises$/.test(fn.text)) raisesCall = n;
-		});
-		if (!raisesCall || !blockNode) return;
+		if (!blockNode) return;
+		const raisesCall = directRaisesItem(node);
+		if (!raisesCall) return;
 		const stmts = blockNode.namedChildren.filter((c) => c.type !== "comment");
 		const exceptionText = (raisesCall.childForFieldName("arguments")?.namedChildren[0])?.text ?? "";
 		const broadException = BROAD_EXC_RE.test(exceptionText);
@@ -7779,7 +8208,7 @@ const pyRaisesWithoutMatch = defineRule({
 	},
 	introduced: "0.3.0",
 	tier: "quarantine",
-	detectorRevision: 4,
+	detectorRevision: 5,
 	run(ctx) {
 		const findings = [];
 		if (!ctx.path.endsWith(".py")) return findings;
@@ -7838,16 +8267,17 @@ function matchParen$1(text, open) {
 	return -1;
 }
 /**
-* AST arm (detectorRevision 4 — P6 rework): candidates come from the
-* parsed `with pytest.raises(...)` statements. Two structural gates
-* suppress the adjudicated FP core:
-*  - the with-block holds a SINGLE statement AND the exception type is
-*    specific → the intended line is the only line; the "unrelated bug
-*    raises first" diagnosis cannot hold;
-*  - the fallback's excinfo-use skip (`as exc` + downstream use) is
-*    mirrored on the raw text.
-* Broad root types (Exception/BaseException/…Group) always fire — the
-* type alone pins nothing.
+* AST arm (detectorRevision 5 — P6 rework, widened on adjudicated evidence):
+* candidates come from the parsed `with pytest.raises(...)` statements, and
+* the raises call must be a DIRECT context manager of the with whose block
+* is measured (see `pythonWithRaisesBlocks` for why).
+*
+* The gate: a block with fewer than two statements is exempt. That covers
+* the adjudicated FP core — pytest-dev/pytest nests its capture tests inside
+* `with saved_fd(1):`, and every one of those was scored as multi-statement
+* until the block resolution was fixed. A broad root type (Exception /
+* BaseException / …Group) still fires on a MULTI-statement block, where an
+* earlier line can raise it before the intended one.
 */
 function astArm(ctx, tree) {
 	const raw = ctx.text;
@@ -7861,7 +8291,7 @@ function astArm(ctx, tree) {
 			const tail = raw.slice(block.callEnd, block.callEnd + 2400);
 			if (new RegExp(`\\b${name}\\b`).test(tail)) continue;
 		}
-		if (block.blockStatements < 2 && !block.broadException) continue;
+		if (block.blockStatements < 2) continue;
 		findings.push({
 			severity: "warning",
 			confidence: "medium",
@@ -7904,7 +8334,7 @@ const pyCommentedOutTest = defineRule({
 	},
 	detectionNotes: "regex heuristic",
 	introduced: "0.3.0",
-	tier: "core",
+	tier: "extended",
 	run(ctx) {
 		const findings = [];
 		if (!ctx.path.endsWith(".py")) return findings;
@@ -7953,13 +8383,18 @@ const pyBareTruthinessAssert = defineRule({
 	},
 	introduced: "0.3.0",
 	tier: "quarantine",
-	detectorRevision: 3,
+	detectorRevision: 4,
 	run(ctx) {
 		const text = ctx.codeText ?? ctx.text;
 		const findings = [];
 		if (!ctx.path.endsWith(".py")) return findings;
 		const re = /^[ \t]*assert\s+([A-Za-z_][\w.]*(?:\([^()]*\))?)[ \t]*$/gm;
-		const predicateRe = /^(?:(?:any|all|isinstance)\s*\(|[\w.]*\.(?:startswith|endswith|exists|isdir|isfile|islink|ismount|check|isdigit|isalpha|isalnum|isnumeric|isdecimal|isspace|islower|isupper|istitle|isidentifier|isprintable|isascii)\s*\(|re\.(?:match|search|fullmatch)\s*\()/;
+		/**
+		* Constants. `assert False` / `assert None` are deliberate mechanisms —
+		* a test that manufactures an exception to assert on its shape — not a
+		* truthiness check whose wrong value would slip through.
+		*/
+		const isConstant = (target) => /^(?:True|False|None|NotImplemented|Ellipsis)$/.test(target) || /^["'\d]/.test(target);
 		const isGuardFollowedByRealUse = (text, matchIndex, target) => {
 			const lineEnd = text.indexOf("\n", matchIndex);
 			if (lineEnd === -1) return false;
@@ -7979,8 +8414,9 @@ const pyBareTruthinessAssert = defineRule({
 		let m;
 		while ((m = re.exec(text)) !== null) {
 			const target = m[1];
+			if (target.includes("(")) continue;
+			if (isConstant(target)) continue;
 			if (/^(?:is|has|can|should|was|were)_/.test(target)) continue;
-			if (predicateRe.test(target)) continue;
 			if (/\.called$/.test(target)) continue;
 			if (isGuardFollowedByRealUse(text, m.index, target)) continue;
 			findings.push({
@@ -8026,7 +8462,7 @@ const pyMutableFixture = defineRule({
 		detail: "pytest fixture mutation is fixture-lifecycle semantics (autouse/scope keys plus mutation calls); the detector matches the runner's fixture decorator tokens plus the mutation shapes"
 	},
 	introduced: "0.3.0",
-	tier: "core",
+	tier: "extended",
 	run(ctx) {
 		const text = ctx.text;
 		const findings = [];
@@ -8060,7 +8496,7 @@ const pyMutableFixture = defineRule({
 */
 const pwWaitForTimeout = defineRule({
 	id: "QA-PW-101",
-	tier: "core",
+	tier: "extended",
 	category: "QA-PW",
 	title: "Hard sleep via waitForTimeout",
 	severity: "error",
@@ -8181,7 +8617,7 @@ const pwDeepFrameLocator = defineRule({
 		detail: "frameLocator chaining depth is an exact Playwright token sequence; the detector matches the frameLocator call chains — the token sequence is closed and unique to the defect"
 	},
 	introduced: "0.3.0",
-	tier: "core",
+	tier: "extended",
 	run(ctx) {
 		const text = ctx.codeText ?? ctx.text;
 		const findings = [];
@@ -8290,7 +8726,7 @@ const pwConfigRetryAbuse = defineRule({
 	},
 	detectionNotes: "regex heuristic",
 	introduced: "0.3.0",
-	tier: "core",
+	tier: "extended",
 	run(ctx) {
 		const text = ctx.codeText ?? ctx.text;
 		const findings = [];
@@ -8308,7 +8744,7 @@ const pwConfigRetryAbuse = defineRule({
 			column: colAt(text, m.index),
 			message: `retries: ${m[1]} — a flaky test gets ${m[1]} chances to pass by luck.`,
 			why: "High retry counts convert real bugs into intermittent passes and inflate CI minutes; the suite reports green while hiding instability.",
-			fix: "Keep retries <= 2 and route repeat offenders into forensics (`mjolnir triage`)."
+			fix: "Keep retries <= 2 and route repeat offenders into the evidence path (`explain --evidence`)."
 		});
 		const workersRe = /workers\s*:\s*0\b/g;
 		while ((m = workersRe.exec(text)) !== null) findings.push({
@@ -8465,7 +8901,7 @@ const pwTrialMisuse = defineRule({
 		detail: "the trial-click shape is an exact Playwright API token pair; the detector matches the call identifier on the code-only text — the token is closed and unique to the defect"
 	},
 	introduced: "0.3.0",
-	tier: "core",
+	tier: "extended",
 	run(ctx) {
 		const text = ctx.codeText ?? ctx.text;
 		const findings = [];
@@ -8670,7 +9106,7 @@ const qaPw140 = defineRule({
 		detail: "the detector matches a closed, exact runner API token on the code-only text; the token identifies the defect uniquely"
 	},
 	introduced: "0.3.0",
-	tier: "core",
+	tier: "extended",
 	run(ctx) {
 		const text = ctx.codeText ?? ctx.text;
 		const findings = [];
@@ -8885,7 +9321,7 @@ const pwRetryMaskingNoForensics = defineRule({
 				column: colAt(text, m.index),
 				message: `retries: ${m[1]} with no visible flake-triage loop.`,
 				why: "Retries convert intermittent failures into silent passes. Without a forensics/triage step consuming retry data, flaky tests pass forever and real regressions hide behind lucky reruns.",
-				fix: "Keep retries <= 2 and feed retry outcomes into `mjolnir forensics`/`triage`, or add a reporter so flaky passes are reviewed."
+				fix: "Keep retries <= 2 and feed retry outcomes into the evidence path (`explain --evidence`), or add a reporter so flaky passes are reviewed."
 			});
 		}
 		return findings;
@@ -9280,7 +9716,7 @@ const pyPwWaitForTimeout = defineRule({
 		detail: "page.waitForTimeout is an exact Playwright token in Python tests; the detector matches the call identifier — closed token, same predicate the AST would encode"
 	},
 	introduced: "0.3.8",
-	tier: "core",
+	tier: "extended",
 	run(ctx) {
 		const text = ctx.codeText ?? ctx.text;
 		const findings = [];
@@ -10165,7 +10601,7 @@ function extractPythonModel(file) {
 */
 const jvWaitForTimeout = defineRule({
 	id: "QA-JV-105",
-	tier: "core",
+	tier: "extended",
 	category: "QA-PW",
 	title: "waitForTimeout hard sleep",
 	severity: "warning",
@@ -10234,7 +10670,7 @@ const jvWaitForTimeout = defineRule({
 */
 const csSkippedTest = defineRule({
 	id: "QA-CS-101",
-	tier: "core",
+	tier: "extended",
 	category: "QA-PW",
 	title: "Skipped test",
 	severity: "warning",
@@ -10429,7 +10865,7 @@ const csNoAssertions = defineRule({
 	detectionStrategy: "AST",
 	detectionNotes: "L2 tree-sitter test-method scoping + structural assertion oracle (Shouldly/Verify/Assert receivers, throwing waits); regex fallback when no parse",
 	introduced: "0.3.8",
-	tier: "core",
+	tier: "extended",
 	detectorRevision: 2,
 	astQuery: cs103AstQuery,
 	run(ctx) {
@@ -11155,7 +11591,7 @@ const hardSleepFamily = definePatternFamily({
 			"mstest",
 			"playwright"
 		],
-		tier: "core",
+		tier: "extended",
 		detectionStrategy: "AST",
 		detectionNotes: "L2 tree-sitter invocation scoping (route/expose/server delegates, infinite blocks, WhenAny races, runner payload fixtures); regex fallback when no parse",
 		detectorRevision: 2,
@@ -11478,7 +11914,7 @@ const retryMaskingFamily = [defineRule({
 		detail: "the retry-masking family's variants (QA-JV-109/QA-CS-109): retry masking is the runner's retry contract; the detector matches the runner's retry tokens on the code-only text"
 	},
 	introduced: "0.4.0",
-	tier: "core",
+	tier: "extended",
 	run(ctx) {
 		const text = ctx.codeText ?? ctx.text;
 		const findings = [];
@@ -11657,6 +12093,117 @@ function getRule(id) {
 	return RULES.find((r) => r.id === id);
 }
 //#endregion
+//#region src/lib/wilson.ts
+/**
+* 95% Wilson score interval on a proportion (plan §20.2).
+*
+* Lives in `src/` rather than `scripts/` because a measurement's interval is
+* now part of the ENGINE's tier decision (`src/rules/measurement.ts`), not
+* only a reporting nicety for the capability matrix. `scripts/lib/wilson.ts`
+* re-exports this module, so the number a gate prints and the number the
+* engine tiers on are the same number computed once. Two implementations
+* would be two sources of truth for the same figure, which is the failure
+* mode this whole release is about.
+*
+* The 4-dp rounding keeps generated artifacts byte-stable (see the capability
+* matrix generator's note on deterministic output).
+*/
+const Z95 = 1.959963984540054;
+/** 95% Wilson score interval on fp/n (fp successes of n trials), 4 dp. */
+function wilsonInterval(fp, n) {
+	if (n <= 0) return {
+		ciLow: 0,
+		ciHigh: 1
+	};
+	const p = fp / n;
+	const z2 = Z95 * Z95;
+	const denom = 1 + z2 / n;
+	const center = (p + z2 / (2 * n)) / denom;
+	const half = Z95 / denom * Math.sqrt(p * (1 - p) / n + z2 / (4 * n * n));
+	const round4 = (x) => Math.round(x * 1e4) / 1e4;
+	return {
+		ciLow: round4(Math.max(0, center - half)),
+		ciHigh: round4(Math.min(1, center + half))
+	};
+}
+/** The rule's declared detector implementation revision (§07). */
+function declaredDetectorRevision(rule) {
+	return rule.detectorRevision ?? 1;
+}
+/**
+* A measurement exists AND was taken against the detector revision the
+* rule declares now. A revision mismatch (stale) does NOT count — §07:
+* stale → provisional → re-measure.
+*/
+function hasValidMeasurement(rule) {
+	const m = MEASURED_FP[rule.id];
+	return m !== void 0 && m.detectorRevision === declaredDetectorRevision(rule);
+}
+/**
+* The confidence interval of a rule's VALID measurement, or undefined when
+* it has none. A stale measurement returns undefined rather than its stale
+* interval: a number derived from an older detector is not evidence about
+* this one, and returning it would let the straddle test pass on stale data.
+*
+* The FP count is ROUNDED, and it is not an optimization. The shipped
+* measurement records a rate and a sample count, not an integer count of false
+* positives, so `fpRate * n` is generally fractional — 10.5% of 19 is 1.995.
+* `wilsonInterval` rounds internally, so passing the raw product gave this
+* function and `scripts/core-readiness.ts` two different `ciHigh` values for
+* the same rule at the same n: the ratchet decided one tier and the
+* readiness table printed another, both derived, neither reconciled. Every
+* caller now reconstructs the count the same way.
+*/
+function measurementInterval(rule) {
+	if (!hasValidMeasurement(rule)) return void 0;
+	const m = MEASURED_FP[rule.id];
+	if (m === void 0) return void 0;
+	return wilsonInterval(Math.round(m.fpRate * m.n), m.n);
+}
+/**
+* The tier the MEASUREMENT alone supports, ignoring any declared tier.
+*
+* This is the interval floor that `effectiveTier` falls back to, extracted so
+* the tightening law can ask the question `effectiveTier` structurally cannot:
+* a declared tier may only ever hold a rule DOWN, never release it.
+*
+* `effectiveTier` cannot answer that, because it short-circuits on
+* `rule.tier` — asking it what a rule's tier "would" be returns the declared
+* value, and a comparison built on it compares the declaration with itself.
+* The first B0 dry-run made exactly that mistake and reported zero
+* mismatches for a comparison that had never run.
+*
+* READ THIS BEFORE USING IT AS A FLOOR. Measured over all 79 live rules, this
+* function returns `extended` for 78 of them and `quarantine` for none: on
+* this corpus the interval rule is very nearly an empty rule, because
+* `ciLow >= 50%` is not reached at n = 10..80. A "declared tier may only
+* tighten" law written against THIS function is decorative — it can only ever
+* catch a rule declaring `core`, which no rule declares. It was written that
+* way first and measured at zero teeth.
+*
+* The floor with teeth is `defensibleTier`, below.
+*/
+function measurementTier(rule) {
+	const interval = measurementInterval(rule);
+	if (interval === void 0) return "extended";
+	if (interval.ciHigh <= .1) return "core";
+	if (interval.ciLow >= .5) return "quarantine";
+	return "extended";
+}
+/**
+* The tier a rule effectively ships as: its declared tier, or — for the
+* omitted-tier case — what its measurement's interval supports (§11.2 Step 2).
+*
+* The declared tier is a floor that may only tighten, and the measurement is
+* what it is measured against. See `rule.ts`'s `tier` doc for the B0
+* measurement behind that, and `defensibleTier` for the floor it is measured
+* against.
+*/
+function effectiveTier(rule) {
+	if (rule.tier !== void 0) return rule.tier;
+	return measurementTier(rule);
+}
+//#endregion
 //#region src/scorer/scorer.ts
 /**
 * Transparent scorer (Product-MVP §8).
@@ -11713,7 +12260,7 @@ function computeDimensions(findings) {
 		deductions.set(f.category, deductions.get(f.category) + deductionFor(f));
 	}
 	for (const dim of byCategory.values()) dim.score = Math.max(0, 100 - deductions.get(dim.category));
-	return [...byCategory.values()].sort((a, b) => a.category.localeCompare(b.category));
+	return [...byCategory.values()].sort((a, b) => compareCodePoints(a.category, b.category));
 }
 /**
 * Deduction-mass ceilings (product-gap-remediation master plan P2,
@@ -11862,26 +12409,105 @@ function asUniversal(rule) {
 }
 //#endregion
 //#region src/engine/tier-policy.ts
+/**
+* Tier policy (audit H-1): the declared tier is authoritative over a
+* rule's severity and evidence claims.
+*
+* Quarantine-tier rules exist because their real-world false-positive
+* rate is unproven or proven bad (docs/FP-AUDIT.md records several at
+* 100% measured FP). A rule known to be wrong every single time it
+* fires must never gate CI or deduct score — regardless of the
+* severity/evidenceLevel its metadata declares. The pipeline therefore
+* caps every quarantine finding to severity=info, evidence=E0, which
+* makes it advisory by construction (isAdvisoryFinding excludes E0).
+*
+* The core tier carries the opposite bound (ADR 0014). A CAP says a tier
+* may not be stronger than this; a FLOOR says it may not be weaker. Core
+* is earned — it means the measurement cleared the false-positive
+* ceiling with enough samples to trust the interval — so a core rule
+* emitting a finding that costs nothing and blocks nothing is claiming a
+* promotion it has not cashed in. Before the floor existed, core and
+* extended were enforced identically, and reaching core changed only the
+* dedup tie-break, the M3 ceiling and the census readout: a consumer
+* could not tell them apart.
+*/
 /** Cap applied to every finding of a quarantine-tier rule (H-1). */
 const QUARANTINE_CAP = {
 	severity: "info",
 	evidenceLevel: "E0"
 };
-/** The cap that applies to a finding from the given tier (undefined tier = core). */
-function capForTier(tier) {
-	return tier === "quarantine" ? QUARANTINE_CAP : null;
-}
+/**
+* Floor applied to every finding of a core-tier rule (ADR 0014).
+*
+* `E1`, not `E2`, and the reason is the difference between the two.
+* `E2` would be a claim that the finding is proven, which is a statement
+* about the code that no tier policy may make — corroboration does that,
+* at runtime, per finding. `E1` is the weaker and sufficient claim: a
+* core rule is measured, so its finding is pattern evidence rather than
+* an observation, and it is worth half the deduction.
+*
+* `E0` is what the floor exists to forbid. `isAdvisoryFinding` is
+* `level === "E0"`, so an E0 finding is simultaneously worth zero points
+* and unable to fail a gate. A rule whose false-positive rate is
+* measured under the 10% ceiling should never be able to produce one.
+*/
+const CORE_FLOOR = { evidenceLevel: "E1" };
+/**
+* The policy for a tier.
+*
+* `undefined` returns an EMPTY policy, and this is a decision, not a
+* convenience. `buildUniversalRules` in `scan-pipeline.ts` populates
+* `tierByRuleId` with `effectiveTier(rule)` for every registry rule — never
+* undefined — and adds a plugin or workspace-local rule only when that rule
+* DECLARES a tier. So an absent entry means "a third-party rule that claimed no
+* tier", and it is the one population that must not inherit a trust bound.
+*
+* It used to read "undefined tier = core" in this docstring, and that sentence
+* was load-bearing in the wrong direction. Before the floor, an absent entry
+* cost nothing, so the claim was inert. With a core floor, treating undefined as
+* core would raise every plugin's E0 finding to E1 and start charging
+* third-party detections for deductions — the exact trust escalation TI-013
+* exists to prevent, introduced by the ADR written to close a trust gap. A
+* plugin that wants the core floor has to declare `tier: "core"` and be
+* reviewed for it.
+*/
+function policyForTier(tier) {
+	if (tier === "quarantine") return { cap: QUARANTINE_CAP };
+	if (tier === "core") return { floor: CORE_FLOOR };
+	return {};
+}
+/**
+* E-ladder order. "E2" > "E1" > "E0" is a claim about how much evidence a
+* finding carries, and the floor is only meaningful if "at least E1" can be
+* stated. Declared as a ladder rather than compared as strings because
+* `"E0" > "E1"` is true in JavaScript and would invert the floor.
+*/
+const EVIDENCE_RANK$1 = {
+	E0: 0,
+	E1: 1,
+	E2: 2
+};
 /**
 * In-place enforcement over a scan's findings. Idempotent; runs AFTER
-* evidence stamping so it wins over rule-declared evidenceLevel.
+* evidence stamping so it wins over rule-declared evidenceLevel — for the
+* cap and the floor alike. A rule's own `evidenceLevel` in `RuleMeta` is a
+* declaration about the rule; the tier is a decision about the rule, and
+* the decision outranks the declaration.
+*
+* Idempotence: cap-then-floor is a fixed point. A finding already at the
+* cap stays at the cap, and one already at or above the floor stays put,
+* so running this twice cannot walk a finding up the ladder.
 */
 function enforceTierPolicy(findings, tierByRuleId) {
 	for (const f of findings) {
-		const cap = capForTier(tierByRuleId.get(f.ruleId));
+		const { cap, floor } = policyForTier(tierByRuleId.get(f.ruleId));
 		if (cap) {
 			f.severity = cap.severity;
 			f.evidenceLevel = cap.evidenceLevel;
 		}
+		if (floor?.evidenceLevel === void 0) continue;
+		const effective = f.evidenceLevel ?? deriveEvidenceLevel(f.findingType, f.confidence);
+		if (EVIDENCE_RANK$1[effective] < EVIDENCE_RANK$1[floor.evidenceLevel]) f.evidenceLevel = floor.evidenceLevel;
 	}
 }
 //#endregion
@@ -12070,8 +12696,8 @@ function isDeclaredByPresent(f, present, metaByRuleId) {
 function ranksBefore(a, b, metaByRuleId) {
 	const ma = metaByRuleId.get(a.ruleId);
 	const mb = metaByRuleId.get(b.ruleId);
-	const tierA = TIER_RANK[ma?.tier ?? "core"];
-	const tierB = TIER_RANK[mb?.tier ?? "core"];
+	const tierA = TIER_RANK[ma?.tier ?? "extended"];
+	const tierB = TIER_RANK[mb?.tier ?? "extended"];
 	if (tierA !== tierB) return tierA < tierB;
 	const sevA = SEVERITY_RANK[a.severity];
 	const sevB = SEVERITY_RANK[b.severity];
@@ -12091,6 +12717,16 @@ function dropOrderBefore(a, b, metaByRuleId) {
 	return (a.column ?? Number.MAX_SAFE_INTEGER) < (b.column ?? Number.MAX_SAFE_INTEGER);
 }
 //#endregion
+//#region src/engine/finding-identity.ts
+/**
+* Correlation identity for before/after comparison: ruleId + file +
+* message, deliberately EXCLUDING line — a source edit that shifts a
+* finding still correlates. Shared by baseline, impact, and resolution.
+*/
+function findingFingerprint(f) {
+	return `${f.ruleId}\u0000${f.file}\u0000${f.message}`;
+}
+//#endregion
 //#region src/engine/correlation-engine.ts
 const EVIDENCE_RANK = {
 	E0: 0,
@@ -12135,13 +12771,31 @@ function groupByFile(findings) {
 	return groups;
 }
 /**
-* Group findings by rootCauseId (or ruleId when rootCauseId is absent)
-* to detect convergent findings pointing at the same root cause.
+* Group findings by root cause, falling back to the FINDING FINGERPRINT.
+*
+* The fallback used to be `ruleId`, and that is the defect this fixes. Nothing
+* in the tree assigns `rootCauseId` — the machine contract reports it `null` on
+* every finding — so `ruleId` was the key for every group, and N independent
+* defects from one rule across N files were reported as
+*
+*   CONVERGENT — N findings share root cause QA-PW-002
+*
+* which is the precise inverse of what convergence means. Convergence is the
+* claim that several findings are ONE thing; the key that produced it said
+* only "these are the same rule". A fingerprint is ruleId + file + message, so
+* two `QA-PW-002` findings in different files are two keys, two groups of one,
+* and neither is reported.
+*
+* This is also why `findingId`/`rootCauseId`/`deduplicationGroup` are not
+* wired instead: they are the same idea, and an unwired field plus a fallback
+* would be two mechanisms for one claim. When a rule declares a real root
+* cause, `rootCauseId` still wins — the field is honoured the moment anything
+* populates it.
 */
 function groupByRootCause(findings) {
 	const groups = /* @__PURE__ */ new Map();
 	for (const f of findings) {
-		const key = f.rootCauseId ?? f.ruleId;
+		const key = f.rootCauseId ?? findingFingerprint(f);
 		const list = groups.get(key) ?? [];
 		list.push(f);
 		groups.set(key, list);
@@ -12149,15 +12803,26 @@ function groupByRootCause(findings) {
 	return groups;
 }
 /**
+* The identity a conclusion lists a finding under.
+*
+* `findingId` when something has populated it, else the fingerprint. Never
+* `ruleId`: the fallback used to collapse every finding from one rule onto one
+* id, so a three-finding CONVERGENT group listed the same id three times and
+* the `alreadyConvergent` set below could not tell the members apart.
+*/
+function conclusionId(f) {
+	return f.findingId ?? findingFingerprint(f);
+}
+/**
 * Correlate findings and produce conclusions WITHOUT modifying them.
 * Deterministic — same input always produces same output.
 */
 function correlateFindings(findings) {
 	const conclusions = [];
 	const rootCauseGroups = groupByRootCause(findings);
-	for (const [rootCause, group] of Array.from(rootCauseGroups.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
+	for (const [rootCause, group] of Array.from(rootCauseGroups.entries()).sort((a, b) => compareLocalized("en")(a[0], b[0]))) {
 		if (group.length < 2) continue;
-		const findingIds = group.map((f) => f.findingId ?? f.ruleId);
+		const findingIds = group.map(conclusionId);
 		conclusions.push({
 			conclusionType: "CONVERGENT",
 			certainty: correlationStrength(group),
@@ -12167,13 +12832,13 @@ function correlateFindings(findings) {
 		});
 	}
 	const fileGroups = groupByFile(findings);
-	for (const [file, group] of Array.from(fileGroups.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
+	for (const [file, group] of Array.from(fileGroups.entries()).sort((a, b) => compareCodePoints(a[0], b[0]))) {
 		if (group.length < 2) continue;
 		const alreadyConvergent = /* @__PURE__ */ new Set();
 		for (const c of conclusions) if (c.conclusionType === "CONVERGENT") for (const id of c.findingIds) alreadyConvergent.add(id);
-		const novel = group.filter((f) => !alreadyConvergent.has(f.findingId ?? f.ruleId));
+		const novel = group.filter((f) => !alreadyConvergent.has(conclusionId(f)));
 		if (novel.length < 2) continue;
-		const findingIds = novel.map((f) => f.findingId ?? f.ruleId);
+		const findingIds = novel.map(conclusionId);
 		conclusions.push({
 			conclusionType: "AMPLIFIED",
 			certainty: correlationStrength(novel),
@@ -12188,7 +12853,7 @@ function correlateFindings(findings) {
 		certainty: "STRONG",
 		corroboration: `${corroborated.length} finding(s) with runtime corroboration`,
 		sourceCount: corroborated.length,
-		findingIds: corroborated.map((f) => f.findingId ?? f.ruleId)
+		findingIds: corroborated.map(conclusionId)
 	});
 	return conclusions;
 }
@@ -12430,7 +13095,25 @@ const BRAND = {
 	auroraGreen: "#5FD6A4",
 	auroraViolet: "#9D8CF5",
 	steel: "#C8CBCF",
-	steelDim: "#8B939D"
+	steelDim: "#8B939D",
+	/** The teal half of the accent rule, and the gradient's near stop. */
+	readingAccent: "#73C4CA",
+	/** The violet half of the accent rule, and the gradient's far stop. */
+	readingAccentAlt: "#A596E5",
+	/** The focus ring. A non-text affordance, held to the same AA floor. */
+	readingFocus: "#8CE3ED",
+	/** Hover state for the mark's monochrome glyph. */
+	readingAccentBright: "#85DBED",
+	/** Hover state for the wordmark's ink. */
+	readingAccentInk: "#E5FCFF",
+	/** UNWORTHY at reading contrast — a softer red than the terminal's. */
+	readingUnworthy: "#FF9790",
+	/** Muted body ink on the reading surfaces. */
+	readingMuted: "#C6CFDB",
+	/** Dimmed ink on the reading surfaces. */
+	readingDim: "#ACB9CA",
+	/** The hero lede: the brightest ink below `TEXT.primary`. */
+	readingLede: "#E0E6EE"
 };
 /**
 * Midnight iron. One ramp, four steps, darkest first.
@@ -12533,7 +13216,7 @@ const TRUST = {
 	l5: "#5CC4E0"
 };
 SURFACE.ink950, SURFACE.ink900, SURFACE.ink850, SURFACE.ink800, BRAND.steel, BRAND.steelDim, BRAND.gold, BRAND.goldBright, BRAND.goldHot, BRAND.aurora, BRAND.auroraBright, BRAND.auroraCyan, BRAND.auroraGreen, BRAND.auroraViolet;
-SCORE.trusted, SCORE.forged, SCORE.warning, SCORE.critical, STATUS.info, TEXT.onGold, STATUS.ok, EVIDENCE.e0, EVIDENCE.e1, EVIDENCE.e2, TRUST.l0, TRUST.l1, TRUST.l2, TRUST.l3, TRUST.l4, TRUST.l5;
+SCORE.trusted, SCORE.forged, SCORE.warning, SCORE.critical, STATUS.info, TEXT.onGold, STATUS.ok, EVIDENCE.e0, EVIDENCE.e1, EVIDENCE.e2, TRUST.l0, TRUST.l1, TRUST.l2, TRUST.l3, TRUST.l4, TRUST.l5, BRAND.readingAccent, BRAND.readingAccentAlt, BRAND.readingFocus, BRAND.readingAccentBright, BRAND.readingAccentInk, BRAND.readingUnworthy, BRAND.readingMuted, BRAND.readingDim, BRAND.readingLede;
 EVIDENCE.e0, EVIDENCE.e1, EVIDENCE.e2;
 const RUNG_MEANINGS = [
 	"observation only",
@@ -12918,9 +13601,10 @@ function hashDir(dir, hash, depth) {
 	try {
 		entries = readdirSync(dir, { withFileTypes: true });
 	} catch {
+		recordDegradation("rules-tree-listing-unreadable");
 		return;
 	}
-	entries.sort((a, b) => a.name.localeCompare(b.name));
+	entries.sort((a, b) => compareCodePoints(a.name, b.name));
 	for (const entry of entries) {
 		if (entry.name === "node_modules" || entry.name === ".git") continue;
 		const full = join(dir, entry.name);
@@ -13422,7 +14106,7 @@ function renderFlakyMd(report) {
 	const lines = [];
 	lines.push("# FLAKY.md");
 	lines.push("");
-	lines.push(`> Generated by mjolnir forensics from ${report.source} run data.`);
+	lines.push(`> Generated by Mjölnir from ${report.source} run data.`);
 	lines.push("> A test that passes only on retry is not a passing test — it is a lucky test.");
 	lines.push("");
 	lines.push(`**${report.totalTests}** tests analyzed · **${report.flakyTests}** true flakes · **${report.retriedTests}** retried · **${report.failed}** failing`);
@@ -13770,19 +14454,19 @@ function parseJestJson(json) {
 }
 //#endregion
 //#region src/forensics/parse-junit.ts
-const MAX_INPUT = 20971520;
-function decodeEntities(s) {
+const MAX_INPUT$1 = 20971520;
+function decodeEntities$1(s) {
 	return s.replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&quot;", "\"").replaceAll("&apos;", "'").replaceAll("&#39;", "'").replaceAll("&amp;", "&");
 }
-function attr(tag, name) {
+function attr$1(tag, name) {
 	const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 	const m = new RegExp(`(?:^|\\s)${escaped}\\s*=\\s*"([^"]*)"`, "i").exec(tag);
-	if (m?.[1] !== void 0) return decodeEntities(m[1]);
+	if (m?.[1] !== void 0) return decodeEntities$1(m[1]);
 	const m2 = new RegExp(`(?:^|\\s)${escaped}\\s*=\\s*'([^']*)'`, "i").exec(tag);
-	return m2?.[1] !== void 0 ? decodeEntities(m2[1]) : void 0;
+	return m2?.[1] !== void 0 ? decodeEntities$1(m2[1]) : void 0;
 }
 function parseJunitXml(xml) {
-	if (xml.length > MAX_INPUT) return [];
+	if (xml.length > MAX_INPUT$1) return [];
 	const out = [];
 	const startRe = /<testcase\b/gi;
 	const closeRe = /<\/testcase\s*>/gi;
@@ -13803,9 +14487,9 @@ function parseJunitXml(xml) {
 			inner = xml.slice(gt + 1, close.index);
 			startRe.lastIndex = close.index + close[0].length;
 		}
-		const name = attr(attrs, "name") ?? "(unnamed)";
-		const classname = attr(attrs, "classname") ?? "";
-		const timeRaw = attr(attrs, "time");
+		const name = attr$1(attrs, "name") ?? "(unnamed)";
+		const classname = attr$1(attrs, "classname") ?? "";
+		const timeRaw = attr$1(attrs, "time");
 		const timeSec = timeRaw !== void 0 && Number.isFinite(Number(timeRaw)) ? Number(timeRaw) : 0;
 		const failed = /<(?:failure|error)\b/i.test(inner);
 		const skipped = /<skipped\b/i.test(inner);
@@ -13816,16 +14500,16 @@ function parseJunitXml(xml) {
 			while ((failMatch = failRe.exec(inner)) !== null) {
 				const attrsStr = failMatch[1] ?? "";
 				const msgAttr = /\smessage\s*=\s*"([^"]*)"/i.exec(attrsStr)?.[1];
-				if (msgAttr) errors.push(sanitizeErrorText(decodeEntities(msgAttr)));
+				if (msgAttr) errors.push(sanitizeErrorText(decodeEntities$1(msgAttr)));
 				const body = failMatch[2]?.trim();
-				if (body && body !== msgAttr) errors.push(sanitizeErrorText(decodeEntities(body)));
+				if (body && body !== msgAttr) errors.push(sanitizeErrorText(decodeEntities$1(body)));
 			}
 			const selfCloseRe = /<(?:failure|error)\b([^>]*)\/>/gi;
 			let scMatch;
 			while ((scMatch = selfCloseRe.exec(inner)) !== null) {
 				const scAttrs = scMatch[1] ?? "";
 				const scMsgMatch = /\smessage\s*=\s*"([^"]*)"/i.exec(scAttrs);
-				if (scMsgMatch?.[1]) errors.push(sanitizeErrorText(decodeEntities(scMsgMatch[1])));
+				if (scMsgMatch?.[1]) errors.push(sanitizeErrorText(decodeEntities$1(scMsgMatch[1])));
 			}
 		}
 		const attempt = {
@@ -13843,6 +14527,142 @@ function parseJunitXml(xml) {
 	return out;
 }
 //#endregion
+//#region src/forensics/parse-trx.ts
+const MAX_INPUT = 20971520;
+function decodeEntities(s) {
+	return s.replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&quot;", "\"").replaceAll("&apos;", "'").replaceAll("&#39;", "'").replaceAll("&amp;", "&");
+}
+function attr(tag, name) {
+	const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const m = new RegExp(`(?:^|\\s)${escaped}\\s*=\\s*"([^"]*)"`, "i").exec(tag);
+	if (m?.[1] !== void 0) return decodeEntities(m[1]);
+	const sq = new RegExp(`(?:^|\\s)${escaped}\\s*=\\s*'([^']*)'`, "i").exec(tag);
+	if (sq?.[1] !== void 0) return decodeEntities(sq[1]);
+}
+/**
+* Does this document look like TRX at all?
+*
+* Shape-sniffed rather than trusted from its location, for the same reason the
+* JUnit path sniffs: a `TestResults/` directory is a convention, and a
+* convention can be wrong. A file that is not a `TestRun` must not be parsed as
+* one and produce confident nonsense.
+*/
+function looksLikeTrxXml(text) {
+	return /<TestRun[\s>]/i.test(text.slice(0, 4096));
+}
+/**
+* TRX durations are `HH:MM:SS.fffffff`; absent or `-` means "not timed".
+*
+* Parsed by splitting rather than by one pattern. A single regex for this has
+* to be `^(\d+):(\d{2}):(\d{2})(?:\.(\d+))?$`, and the nested quantifiers there
+* are what `security/detect-unsafe-regex` flags — correctly in general, since
+* this shape is the usual ReDoS source. Splitting removes the question rather
+* than asserting the pattern is safe today.
+*/
+function parseDuration(raw) {
+	if (raw === void 0) return 0;
+	const text = raw.trim();
+	const dot = text.indexOf(".");
+	const clock = dot === -1 ? text : text.slice(0, dot);
+	const fraction = dot === -1 ? "" : text.slice(dot + 1);
+	const parts = clock.split(":");
+	if (parts.length !== 3) return 0;
+	const [h, m, s] = parts;
+	if (h === void 0 || m === void 0 || s === void 0) return 0;
+	if (!/^\d+$/.test(h) || !/^\d{1,2}$/.test(m) || !/^\d{1,2}$/.test(s)) return 0;
+	const millis = fraction.length === 0 ? 0 : Number(fraction.slice(0, 3).padEnd(3, "0"));
+	return Number(h) * 36e5 + Number(m) * 6e4 + Number(s) * 1e3 + millis;
+}
+/**
+* TRX `outcome` to a run status.
+*
+* The mapping is stated rather than inferred from a default, because the
+* dangerous direction here is a silent default: an outcome this engine has
+* never seen must not read as `passed`. Every unrecognised value maps to
+* `skipped`, which is the non-claiming direction — a skipped test contributes
+* nothing to "the suite passed" — rather than to a status that would let it.
+*
+* TRX also has outcomes that are not verdicts at all (`Warning`, `Pending`,
+* `Expired`). They are treated the same way, deliberately.
+*/
+function mapTrxOutcome(outcome) {
+	switch ((outcome ?? "").toLowerCase()) {
+		case "passed":
+		case "completed": return "passed";
+		case "failed":
+		case "error": return "failed";
+		case "timeout": return "timedOut";
+		case "aborted":
+		case "interrupted": return "interrupted";
+		case "notexecuted":
+		case "skipped":
+		case "inconclusive":
+		case "notrunnable":
+		case "pending": return "skipped";
+		default: return "skipped";
+	}
+}
+function tagOf(xml, name) {
+	const out = [];
+	const re = new RegExp(`<${name}\\b[^>]*>`, "gi");
+	let m;
+	while ((m = re.exec(xml)) !== null) {
+		if (m[0] !== void 0) out.push(m[0]);
+		if (out.length > 2e5) break;
+	}
+	return out;
+}
+/** The text of a `<Message>` child, used as the failure's error text. */
+function messageOf(text, near) {
+	const window = text.slice(near, near + 2e3);
+	const m = /<Message[^>]*>([\s\S]{0,1500}?)<\/Message>/i.exec(window);
+	if (m?.[1] === void 0) return void 0;
+	const cleaned = sanitizeErrorText(decodeEntities(m[1].replace(/<[^>]*>/g, " ")).trim());
+	return cleaned.length === 0 ? void 0 : cleaned;
+}
+/**
+* Parse a TRX document into test records.
+*
+* Returns an empty array for a document that is not TRX rather than throwing:
+* discovery sniffs before parsing, and a caller that hands us a non-TRX file
+* should get "no evidence here", not an exception that aborts a whole run
+* report.
+*/
+function parseTrxXml(xml) {
+	if (xml.length > MAX_INPUT) return [];
+	if (!looksLikeTrxXml(xml)) return [];
+	const byTestId = /* @__PURE__ */ new Map();
+	for (const tag of tagOf(xml, "UnitTest")) {
+		const id = attr(tag, "id");
+		const name = attr(tag, "name");
+		if (id !== void 0 && name !== void 0) byTestId.set(id, name);
+	}
+	const records = [];
+	const resultRe = /<UnitTestResult\b([^>]*)>([\s\S]{0,4000}?)(?=<UnitTestResult\b|<\/Results>)/gi;
+	let m;
+	while ((m = resultRe.exec(xml)) !== null) {
+		const attrs = m[1] ?? "";
+		const inner = m[2] ?? "";
+		const testName = attr(attrs, "testName") ?? attr(attrs, "testId");
+		if (testName === void 0) continue;
+		const attempt = {
+			index: 1,
+			status: mapTrxOutcome(attr(attrs, "outcome")),
+			durationMs: parseDuration(attr(attrs, "duration"))
+		};
+		const error = messageOf(inner, 0);
+		records.push({
+			file: "unknown",
+			title: testName,
+			attempts: [attempt],
+			evidenceKind: "test",
+			...error === void 0 ? {} : { errors: [error] }
+		});
+		if (records.length > 2e5) break;
+	}
+	return records;
+}
+//#endregion
 //#region src/forensics/parse-playwright-json.ts
 const MAX_DEPTH = 32;
 function toStatus$1(raw) {
@@ -14052,7 +14872,9 @@ function parseHarJsonDetailed(json) {
 //#endregion
 //#region src/forensics/run.ts
 /**
-* `mjolnir forensics <dir-or-file>` — runtime evidence entry point (R4).
+* Runtime evidence entry point (R4) — the library behind `explain
+* --evidence`. The `forensics` verb is retired in the v6 carve; this module
+* is what reads the run data.
 *
 * Accepts either a single report file or a directory. In a directory it
 * looks for, in priority order:
@@ -14252,6 +15074,13 @@ function traceArtifactName(fullPath) {
 	return base;
 }
 function parseFile(path, text) {
+	if (/\.trx$/i.test(path) || looksLikeTrxXml(text)) {
+		const records = parseTrxXml(text);
+		if (records.length > 0) return {
+			records,
+			source: "dotnet-trx"
+		};
+	}
 	if (/\.xml$/i.test(path) || /^\s*<\?xml|<testsuite\b/i.test(text.slice(0, 200))) return {
 		records: parseJunitXml(text),
 		source: "junit-xml"
@@ -14319,11 +15148,11 @@ function listFiles(dir) {
 	return out.map((p) => p);
 }
 plainContext();
-function loadSuppressions(root) {
+function loadSuppressions(root, now = /* @__PURE__ */ new Date()) {
 	const { config } = loadConfig(root);
 	const entries = (config.ignore ?? []).map((ign) => ({
 		...ign,
-		status: isSuppressionActive(ign, /* @__PURE__ */ new Date()) ? "active" : "expired"
+		status: isSuppressionActive(ign, now) ? "active" : "expired"
 	}));
 	return {
 		total: entries.length,
@@ -14503,7 +15332,7 @@ function loadPlugins(root, gateOpen = false) {
 *   - Load failures degrade honestly: warning entries, never a crash;
 *     exit codes stay frozen.
 *
-* Drift-check: the `mjolnir rules --md` catalog is generated from the
+* Drift-check: the `mjolnir explain --list --md` catalog is generated from the
 * LOADED rules (core + external), so the catalog can never drift from
 * what actually ships — an edit to a local rule file changes the very
 * next catalog render (locked by tests/local-rules.spec.ts).
@@ -14849,7 +15678,7 @@ const KNOWN_RULE_IDS = new Set(RULES.map((r) => r.id));
 const OVERLAP_META_BY_RULE_ID = new Map(RULES.map((r, order) => {
 	const meta = {
 		...r.overlapWith ? { overlapWith: r.overlapWith } : {},
-		...r.tier ? { tier: r.tier } : {},
+		tier: effectiveTier(r),
 		order
 	};
 	return [r.id, meta];
@@ -14877,11 +15706,14 @@ async function buildUniversalRules(root, strict, opts = {}) {
 		rules: local.rules
 	}].flatMap((p) => p.rules.map(asUniversal));
 	const tierByRuleId = /* @__PURE__ */ new Map();
-	for (const r of RULES) if (r.tier) tierByRuleId.set(r.id, r.tier);
+	for (const r of RULES) tierByRuleId.set(r.id, effectiveTier(r));
 	for (const p of plugins) for (const r of p.rules) if (r.tier) tierByRuleId.set(r.id, r.tier);
 	for (const r of local.rules) if (r.tier) tierByRuleId.set(r.id, r.tier);
 	let rules = [...UNIVERSAL_RULES, ...externalRules];
+	const withheldRuleIds = rules.filter((r) => tierByRuleId.get(r.id) === "quarantine").map((r) => r.id).sort();
 	if (!strict) rules = rules.filter((r) => tierByRuleId.get(r.id) !== "quarantine");
+	const rulesWithheld = strict ? 0 : withheldRuleIds.length;
+	const rulesApplied = rules.length;
 	const pluginMeta = [...plugins.map((p) => ({
 		name: p.name,
 		rules: p.rules.length
@@ -14894,7 +15726,10 @@ async function buildUniversalRules(root, strict, opts = {}) {
 		pluginErrors: allErrors,
 		tierByRuleId,
 		pluginMeta,
-		externalRules: local.rules
+		externalRules: local.rules,
+		rulesApplied,
+		rulesWithheld,
+		withheldRuleIds
 	};
 }
 /** Rule-declared evidence-level overrides (Honesty Core). */
@@ -14919,35 +15754,6 @@ function fallbackWorkspace(targetAbs) {
 	};
 }
 /**
-* Minimal glob match for suppression `files` patterns, with gitignore
-* `**` semantics (bug-audit M5). Supports:
-*   "tests/**"             — everything inside tests/
-*   "tests" + "/**\/*.spec.ts" — any depth UNDER tests/ (including none) ending in .spec.ts
-*   "**" + "/*.spec.ts"    — any depth including root-level files
-*   "tests/foo.spec.ts"    — exact path
-*   "*" within a segment never crosses "/".
-*
-* Forward slashes only (findings always use normalized paths). `?`,
-* character classes and `!` negation are not metacharacters here — same
-* as before this rewrite.
-*/
-function pathMatchesGlob(path, glob) {
-	const p = path.replaceAll("\\", "/");
-	const segments = glob.replaceAll("\\", "/").split("/");
-	let re = "^";
-	for (const [i, segment] of segments.entries()) {
-		const last = i === segments.length - 1;
-		if (segment === "**") {
-			if (last) re += "(?:[^/]+/)*[^/]+";
-			else re += "(?:[^/]+/)*";
-			continue;
-		}
-		re += segment.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", "[^/]*");
-		if (!last) re += "/";
-	}
-	return new RegExp(`${re}$`).test(p);
-}
-/**
 * Plan §16 + WI-11: locate a runtime run report next to the scan
 * target, using the exact conventions the forensics ingestion already
 * accepts. Zero-config search over conventional artifact names at
@@ -15056,6 +15862,7 @@ async function runFileAnalysisPhase(findings, testFiles, workspace, activeRules,
 	let rulesPartial = false;
 	let parseFailed = 0;
 	let parseFallbacks = 0;
+	let astFallbackFiles = 0;
 	let scanned = 0;
 	let analyzed = 0;
 	for (const path of testFiles) {
@@ -15099,6 +15906,10 @@ async function runFileAnalysisPhase(findings, testFiles, workspace, activeRules,
 			});
 		}
 		const wantsAst = adapter.parseAst !== void 0 && Date.now() <= deadline;
+		if (adapter.parseAst !== void 0 && !wantsAst) {
+			truncationReasons.add("ast-budget-fallback");
+			astFallbackFiles++;
+		}
 		const identity = (mode) => ({
 			relPath,
 			adapterId: adapter.id,
@@ -15216,7 +16027,8 @@ async function runFileAnalysisPhase(findings, testFiles, workspace, activeRules,
 		parseFailed,
 		parseFallbacks,
 		scanned,
-		analyzed
+		analyzed,
+		astFallbackFiles
 	};
 }
 /**
@@ -15444,6 +16256,11 @@ function assembleScanResult(o) {
 		scopeUnrecognized: o.scopeUnrecognized,
 		parseFailed: o.parseFailed,
 		parseFallbacks: o.parseFallbacks ?? 0,
+		...o.astFallbackFiles !== void 0 ? { astFallbackFiles: o.astFallbackFiles } : {},
+		...o.degradations !== void 0 ? { degradations: o.degradations } : {},
+		...o.rulesWithheld !== void 0 ? { rulesWithheld: o.rulesWithheld } : {},
+		...o.withheldRuleIds !== void 0 ? { withheldRuleIds: o.withheldRuleIds } : {},
+		...o.rulesApplied !== void 0 ? { rulesApplied: o.rulesApplied } : {},
 		...o.scopeInfo.degraded !== void 0 ? { scopeDegraded: o.scopeInfo.degraded } : {},
 		...o.runtimeIncomplete !== void 0 ? { runtimeIncomplete: o.runtimeIncomplete } : {},
 		identityIncomplete
@@ -15458,11 +16275,15 @@ function assembleScanResult(o) {
 		})),
 		config: o.config ?? null,
 		engineVersion: ENGINE_VERSION,
+		runMode: resolveRunMode({
+			env: {},
+			flags: {}
+		}),
 		reportDigest,
 		trustModelVersion: TRUST_MODEL_VERSION,
 		scoringModelVersion: SCORING_MODEL_VERSION,
 		frameworkSupportMatrixVersion: FRAMEWORK_SUPPORT_MATRIX_VERSION,
-		evidenceSchemaVersions: [1],
+		evidenceSchemaVersions: [2],
 		...repository,
 		...candidate !== null ? { candidate } : {}
 	});
@@ -15475,7 +16296,10 @@ function assembleScanResult(o) {
 	});
 	const hasTests = o.testFileCount > 0 && o.testDeclarationCount > 0;
 	const suiteInvalidatedBy = [...new Set(o.findings.filter((f) => SUITE_INVALIDATING_RULE_IDS.has(f.ruleId)).map((f) => f.ruleId))].sort();
-	const finalScore = hasTests ? completion.partial && scopeAdjustedTotal >= 100 ? 99 : scopeAdjustedTotal : null;
+	const scopeClamped = scopeReasons.length > 0 && total >= 100;
+	const partialClamped = completion.partial && scopeAdjustedTotal >= 100;
+	const scoreClampReason = scopeClamped ? "scope-degraded" : partialClamped ? "partial-scan" : null;
+	const finalScore = hasTests ? partialClamped ? 99 : scopeAdjustedTotal : null;
 	const result = {
 		schemaVersion: 1,
 		partial: completion.partial,
@@ -15514,9 +16338,11 @@ function assembleScanResult(o) {
 		} } : {},
 		analysisStatus: {
 			...completion.analysisStatus,
+			coverageState: completion.coverageState,
 			durationMs: elapsed
 		},
-		scoringModelVersion: SCORING_MODEL_VERSION
+		scoringModelVersion: SCORING_MODEL_VERSION,
+		...scoreClampReason !== null ? { scoreClampReason } : {}
 	};
 	result.trustSummary = buildTrustSummary(result, o.declarationsByFile);
 	if (o.findings.length > 0) result.correlationConclusions = correlateFindings(o.findings);
@@ -15560,15 +16386,33 @@ function assembleScanResult(o) {
 * inherently async); `runRules` and every rule stay synchronous and
 * consume `ParsedFile.ast`. Callers await the returned promise.
 */
+/**
+* Run one scan inside its own ts-morph Project scope.
+*
+* The wrapper is the whole fix. ts-morph's Project caches SourceFiles by path
+* and `parseTsFile` calls `replaceWithText` on them, so a Project shared between
+* two concurrent scans lets one rewrite the file the other is mid-rule on —
+* which surfaced as three of four concurrent scans reporting
+* `rulesCrashed: 4` and `rules: "partial"`, and therefore as two different
+* machine-contract digests from one tree. See `src/engine/ts-ast.ts`.
+*
+* Async context propagates across `await`, so the scope covers the whole scan
+* without threading a Project through every adapter.
+*/
 async function runScan(args, hooks = {}) {
+	return runWithScanProject(() => runScanInProject(args, hooks));
+}
+async function runScanInProject(args, hooks = {}) {
 	const started = Date.now();
+	const degradationWindow = beginDegradationWindow();
 	const requestedDuration = Number.isFinite(args.maxDurationMs) ? args.maxDurationMs : DEFAULT_MAX_DURATION_MS$1;
 	const deadline = started + Math.min(Math.max(1, requestedDuration), MAX_DURATION_MS$1);
 	const discovered = discoverWorkspace(args.target);
 	const targetAbs = resolve(args.target);
 	const scanRoot = discovered && discovered.root !== targetAbs && targetAbs.startsWith(discovered.root + sep) ? {
 		...discovered,
-		root: targetAbs
+		root: targetAbs,
+		packageJson: {}
 	} : discovered ?? fallbackWorkspace(targetAbs);
 	const workspace = scanRoot;
 	if (args.verbose) hooks.onConfigWarning?.(`verbose: scan root (config/ignore anchor): ${workspace.root}`);
@@ -15585,7 +16429,7 @@ async function runScan(args, hooks = {}) {
 	let scopeUnrecognized = 0;
 	let parseFailed = 0;
 	const fileProvenance = [];
-	const { rules: activeRules, pluginErrors, tierByRuleId: tiers, pluginMeta } = await buildUniversalRules(workspace.root, args.strict, {
+	const { rules: activeRules, pluginErrors, tierByRuleId: tiers, pluginMeta, rulesApplied, rulesWithheld, withheldRuleIds } = await buildUniversalRules(workspace.root, args.strict, {
 		...args.enablePlugins !== void 0 ? { enablePlugins: args.enablePlugins } : {},
 		onGateNotice: (notice) => hooks.onGateNotice ? hooks.onGateNotice(notice) : console.error(notice)
 	});
@@ -15653,6 +16497,7 @@ async function runScan(args, hooks = {}) {
 	rulesPartial = analysis.rulesPartial;
 	parseFailed = analysis.parseFailed;
 	const parseFallbacks = analysis.parseFallbacks;
+	const astFallbackFiles = analysis.astFallbackFiles;
 	const scanned = analysis.scanned;
 	const analyzed = analysis.analyzed;
 	const postScan = applyPostScanProcessing(findings, workspace, args, hooks, scanRoot, declarationsByFile, testDeclarationCount, tierByRuleId, REVISION_BY_RULE_ID);
@@ -15671,6 +16516,11 @@ async function runScan(args, hooks = {}) {
 		scopeUnrecognized,
 		parseFailed,
 		parseFallbacks,
+		astFallbackFiles,
+		degradations: summarizeDegradations(degradationsSince(degradationWindow)),
+		rulesApplied,
+		rulesWithheld,
+		...withheldRuleIds.length > 0 ? { withheldRuleIds } : {},
 		scanned,
 		analyzed,
 		testFiles,
@@ -15697,6 +16547,39 @@ async function runScan(args, hooks = {}) {
 	resetTsMorphProject();
 	return result;
 }
+//#endregion
+//#region src/cli-io.ts
+/**
+* The ONE error-to-message derivation in `src/`.
+*
+* This tree carried four near-copies: two `errorMessage` (byte-identical) and
+* two `errorText`. The two `errorText` copies were not identical, which is the
+* part that mattered — `String(someObject)` renders `[object Object]`, so the
+* copy that lost the payload turned a hostile non-Error throw into a message
+* that names nothing. The richer arms are kept here, so every call site gets
+* the informative one and the difference stops being a per-file accident.
+*
+* The arms, in order:
+*   Error            -> `.message`. The 99% case, and the only one that
+*                       carries a stack the caller may still want.
+*   string           -> itself. A thrown string is already the message.
+*   plain object     -> `JSON.stringify`. A non-Error throw of `{ code:
+*                       "EISDIR" }` is a REAL failure shape in Node, and
+*                       `[object Object]` hides the only field that says
+*                       what went wrong.
+*   anything else    -> `String(err)`. Symbols and undefined included, so
+*                       nothing vanishes.
+*
+* The call this replaces was `err instanceof Error ? err.message : String(err)`
+* in `src/mcp/server.ts` and `src/commands/doctor.ts`; `tests/cli/summary.spec.ts`
+* already pins the object arm.
+*/
+function errorMessage(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	if (typeof err === "object" && err !== null) return JSON.stringify(err);
+	return String(err);
+}
 /**
 * Fields that participate in the verification digest: identity (ruleId,
 * detectorRevision, file, line, column) + evidence (severity,
@@ -15742,6 +16625,10 @@ function canonicalScanJson(result) {
 			skippedFiles: result.analysisStatus.skippedFiles,
 			rulesCrashed: result.analysisStatus.rulesCrashed ?? 0,
 			parseFallbacks: result.analysisStatus.parseFallbacks ?? 0,
+			coverageState: result.analysisStatus.coverageState ?? "COMPLETE",
+			rulesApplied: result.analysisStatus.rulesApplied ?? null,
+			rulesWithheld: result.analysisStatus.rulesWithheld ?? 0,
+			degradations: result.analysisStatus.degradations ?? [],
 			truncationReasons: result.analysisStatus.truncationReasons ?? [],
 			reasons: result.analysisStatus.reasons ?? []
 		},
@@ -15785,7 +16672,7 @@ function buildMachineContract(result) {
 		};
 	});
 	return {
-		contractVersion: 1,
+		contractVersion: 2,
 		summary: {
 			digest: `sha256:${digest}`,
 			findings: result.findings.length,
@@ -15806,6 +16693,10 @@ function buildMachineContract(result) {
 			...result.analysisStatus.parseFallbacks !== void 0 ? { parseFallbacks: result.analysisStatus.parseFallbacks } : {},
 			truncationReasons: result.analysisStatus.truncationReasons ?? [],
 			...result.analysisStatus.reasons !== void 0 ? { reasons: result.analysisStatus.reasons } : {},
+			...result.analysisStatus.degradations !== void 0 ? { degradations: result.analysisStatus.degradations } : {},
+			...result.analysisStatus.coverageState !== void 0 ? { coverageState: result.analysisStatus.coverageState } : {},
+			...result.analysisStatus.rulesApplied !== void 0 ? { rulesApplied: result.analysisStatus.rulesApplied } : {},
+			...result.analysisStatus.rulesWithheld !== void 0 ? { rulesWithheld: result.analysisStatus.rulesWithheld } : {},
 			frameworkDetectionUnknown: result.frameworkDetectionUnknown,
 			durationMs: result.analysisStatus.durationMs,
 			...result.scopeIntegrity !== void 0 ? { scopeIntegrity: result.scopeIntegrity } : {},
@@ -15847,7 +16738,12 @@ function explainRule(ruleId, fixturesRoot) {
 	const rule = getRule(ruleId);
 	if (!rule) return {
 		ok: false,
-		error: `Unknown rule ID "${ruleId}". Run \`mjolnir rules\` for the full catalog.`
+		error: `Unknown rule ID "${ruleId}". Run \`mjolnir explain --list\` for the full catalog.`
+	};
+	const window = beginDegradationWindow();
+	const degraded = () => {
+		const counts = summarizeDegradations(degradationsSince(window));
+		return counts.length > 0 ? { exampleDegraded: counts } : {};
 	};
 	const fixturePath = firstFixtureFile(join(fixturesRoot, ruleId, "must-fire"));
 	if (!fixturePath) return {
@@ -15858,9 +16754,11 @@ function explainRule(ruleId, fixturesRoot) {
 	try {
 		text = readFileSync(fixturePath, "utf8").replace(/\r\n/g, "\n");
 	} catch {
+		recordDegradation("explain-fixture-unreadable");
 		return {
 			ok: true,
-			rule
+			rule,
+			...degraded()
 		};
 	}
 	const normalizedPath = fixturePath.replaceAll("\\", "/");
@@ -15870,9 +16768,11 @@ function explainRule(ruleId, fixturesRoot) {
 		else try {
 			ast = isAzurePipelineFixture(normalizedPath) ? parseAzurePipeline(text) : parseWorkflow(text);
 		} catch {
+			recordDegradation("explain-workflow-parse-failed");
 			return {
 				ok: true,
-				rule
+				rule,
+				...degraded()
 			};
 		}
 	}
@@ -15889,9 +16789,11 @@ function explainRule(ruleId, fixturesRoot) {
 			codeText
 		});
 	} catch {
+		recordDegradation("explain-rule-crash");
 		return {
 			ok: true,
-			rule
+			rule,
+			...degraded()
 		};
 	}
 	const example = findings[0];
@@ -15908,16 +16810,6 @@ function explainRule(ruleId, fixturesRoot) {
 	};
 }
 //#endregion
-//#region src/engine/finding-identity.ts
-/**
-* Correlation identity for before/after comparison: ruleId + file +
-* message, deliberately EXCLUDING line — a source edit that shifts a
-* finding still correlates. Shared by baseline, impact, and resolution.
-*/
-function findingFingerprint(f) {
-	return `${f.ruleId}\u0000${f.file}\u0000${f.message}`;
-}
-//#endregion
 //#region src/engine/resolution.ts
 /** Correlation identity (v1-compatible): ruleId\0file\0message. */
 const fingerprint$1 = findingFingerprint;
@@ -15938,6 +16830,11 @@ function resolve$1(input) {
 		cause: "crash",
 		comparedAgainst
 	};
+	if (current.analysisStatus.withheldRuleIds?.includes(entry.ruleId) === true) return {
+		status: "INCONCLUSIVE",
+		cause: "rule-withheld",
+		comparedAgainst
+	};
 	if (input.skippedFiles?.has(entry.file)) return {
 		status: "INCONCLUSIVE",
 		cause: "skipped",
@@ -16067,13 +16964,13 @@ function diffAgainstBaseline(result, baseline) {
 //#endregion
 //#region src/commands/verify.ts
 /**
-* `mjolnir verify` — the agent-loop digest (product-gap-remediation
+* `mjolnir ci verify` — the agent-loop digest (product-gap-remediation
 * master plan P7, plan 1788853205786 — flag agent, decision 6).
 *
-* An agent fixes findings, then runs `mjolnir verify` against the
-* committed baseline (established once with `mjolnir baseline`). The
+* An agent fixes findings, then runs `mjolnir ci verify` against the
+* committed baseline (established once from a `mjolnir scan --json` run). The
 * digest answers exactly the loop's questions, derived from the SAME
-* §15 comparison machinery as `mjolnir diff` (no second truth):
+* §15 comparison machinery as `mjolnir scan --scope changed` (no second truth):
 *
 *   - RESOLVED — baseline findings no longer present, each with its
 *     lifecycle resolution (only VERIFIED-RESOLVED is a fix claim);
@@ -16349,7 +17246,7 @@ const MCP_TOOLS = [
 	},
 	{
 		name: "verify",
-		description: "Agent-loop digest (1:1 with `mjolnir verify`): scan the target and diff against the committed baseline. Returns resolved (per §15 lifecycle), new, unchanged (grouped by ruleId + location), and the score delta. Read-only; the same transport guardrails as every other tool.",
+		description: "Agent-loop digest (1:1 with `mjolnir ci verify`): scan the target and diff against the committed baseline. Returns resolved (per §15 lifecycle), new, unchanged (grouped by ruleId + location), and the score delta. Read-only; the same transport guardrails as every other tool.",
 		inputSchema: {
 			type: "object",
 			properties: { path: {
@@ -16361,7 +17258,7 @@ const MCP_TOOLS = [
 	},
 	{
 		name: "forensics",
-		description: "Runtime-evidence report (1:1 with the forensics engine behind `mjolnir pw-report`): ingest a run report (Playwright JSON, JUnit XML, Jest/Vitest JSON, or a Playwright trace artifact) and return the ForensicsReport — per-test verdicts, retries, TRUE-FLAKE, durations. Hostile reports degrade to zero records (never a fabricated clean run). Read-only.",
+		description: "Runtime-evidence report (1:1 with the forensics engine behind `mjolnir explain --playwright`): ingest a run report (Playwright JSON, JUnit XML, Jest/Vitest JSON, or a Playwright trace artifact) and return the ForensicsReport — per-test verdicts, retries, TRUE-FLAKE, durations. Hostile reports degrade to zero records (never a fabricated clean run). Read-only.",
 		inputSchema: {
 			type: "object",
 			properties: { path: {
@@ -16385,7 +17282,7 @@ const MCP_TOOLS = [
 	},
 	{
 		name: "pw-report",
-		description: "Playwright run summary (1:1 with `mjolnir pw-report`): ingest a run report and return both the ForensicsReport and the rendered run summary. Read-only.",
+		description: "Playwright run summary (1:1 with `mjolnir explain --playwright`): ingest a run report and return both the ForensicsReport and the rendered run summary. Read-only.",
 		inputSchema: {
 			type: "object",
 			properties: { path: {
@@ -16578,7 +17475,7 @@ async function handleToolCall(call) {
 				id: call.id,
 				result: {
 					hasBaseline: false,
-					note: "no committed baseline at .mjolnir/baseline.json — establish the before-state with `mjolnir baseline` first"
+					note: "no committed baseline at .mjolnir/baseline.json — establish the before-state with `mjolnir <target> --save-baseline`, then re-run this tool (or `mjolnir ci verify`) after the fix"
 				}
 			};
 			const result = await serializeScan(() => runScan({
@@ -16652,15 +17549,11 @@ async function handleToolCall(call) {
 			id: call.id,
 			error: {
 				code: MCP_ERRORS.INTERNAL,
-				message: errorMessage$1(err)
+				message: errorMessage(err)
 			}
 		};
 	}
 }
-/** Normalize any thrown value to a string (unit-tested both arms). */
-function errorMessage$1(err) {
-	return err instanceof Error ? err.message : String(err);
-}
 /** JSON-RPC request shape validation (strict — §21). */
 function validateRequest(msg) {
 	if (typeof msg !== "object" || msg === null) return {
@@ -16763,14 +17656,6 @@ async function handleMcpMessage(msg) {
 	};
 }
 //#endregion
-//#region src/cli-io.ts
-/**
-* The single error-to-message derivation shared by every catch site:
-* Error instances render their message; anything else is stringified
-* honestly (a hostile non-Error throw must surface, not vanish).
-*/
-const errorMessage = (err) => err instanceof Error ? err.message : String(err);
-//#endregion
 //#region src/mcp/transport.ts
 /**
 * MCP stdio transport loop (blueprint §21 — the framing around the