mjolnir-qa 5.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",
@@ -100,17 +118,24 @@ function deriveCompletion(input) {
 	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 || degradations.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()
@@ -375,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,
@@ -494,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,
@@ -584,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,
@@ -885,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) —
@@ -925,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,
@@ -957,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 } : {},
@@ -1359,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 = "5.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
 /**
@@ -1374,7 +1486,15 @@ const ENGINE_VERSION = "5.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
@@ -1421,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;
@@ -1772,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).
@@ -1906,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).
@@ -2108,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: {
@@ -2126,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.
@@ -2251,9 +2492,16 @@ function getCodeOnlyText(file) {
 		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
@@ -2707,10 +2955,18 @@ function runRuleIsolated(rule, file, onCrash) {
 * 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)$/;
 /**
@@ -2782,7 +3038,9 @@ const typescriptAdapter = {
 		".js",
 		".jsx",
 		".mjs",
-		".cjs"
+		".cjs",
+		".mts",
+		".cts"
 	],
 	testFileGlobs: [
 		"*.test.{js,jsx,ts,tsx,mjs,cjs}",
@@ -2993,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() {
@@ -3073,6 +3335,7 @@ async function parseJavaAst(text) {
 			return (await getJavaParser()).parse(text) ?? void 0;
 		});
 	} catch {
+		recordDegradation("ast-grammar-unavailable");
 		return;
 	}
 }
@@ -3086,6 +3349,7 @@ async function parseCSharpAst(text) {
 			return (await getCSharpParser()).parse(text) ?? void 0;
 		});
 	} catch {
+		recordDegradation("ast-grammar-unavailable");
 		return;
 	}
 }
@@ -3101,6 +3365,7 @@ async function parsePythonAst(text) {
 			return (await getPythonParser()).parse(text) ?? void 0;
 		});
 	} catch {
+		recordDegradation("ast-grammar-unavailable");
 		return;
 	}
 }
@@ -3199,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",
@@ -3211,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: [],
@@ -4293,6 +4562,22 @@ function isScopeRelevantIgnored(path) {
 	if (!/\.(?:[cm]?[jt]sx?|py|java|cs|ya?ml|min\.js)$/i.test(name)) return false;
 	return isKnownTestFile(path);
 }
+/**
+* Every source extension any shipped adapter claims.
+*
+* 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.
+*
+* 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;
@@ -4307,8 +4592,9 @@ function isUnrecognizedSourceCandidate(path) {
 		"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;
+	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);
 }
 /** Whether ANY shipped adapter would discover this path as a test file. */
 function isKnownTestFile(path) {
@@ -5498,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",
@@ -5612,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 = [];
@@ -7438,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",
@@ -7574,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;
@@ -7818,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);
@@ -7883,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;
@@ -7942,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;
@@ -7965,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",
@@ -8008,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;
@@ -8057,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;
@@ -8083,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({
@@ -8130,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 = [];
@@ -8164,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",
@@ -8285,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 = [];
@@ -8394,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 = [];
@@ -8412,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({
@@ -8569,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 = [];
@@ -8774,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 = [];
@@ -8989,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;
@@ -9384,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 = [];
@@ -10269,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",
@@ -10338,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",
@@ -10533,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) {
@@ -11259,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,
@@ -11582,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 = [];
@@ -11761,51 +12093,115 @@ function getRule(id) {
 	return RULES.find((r) => r.id === id);
 }
 //#endregion
-//#region src/lib/compare.ts
+//#region src/lib/wilson.ts
 /**
-* Order that does not depend on who is asking.
+* 95% Wilson score interval on a proportion (plan §20.2).
 *
-* `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.
+* 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.
 *
-* Two comparators, one per kind of site:
+* 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.
 *
-*   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.
+* 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.
 *
-*   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.
+* 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.
 *
-* A bare `localeCompare` with no second argument in `src/` is a defect and
-* `tests/contract/deterministic-ordering.spec.ts` fails the build on 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.
 */
-/** 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;
+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";
 }
 /**
-* A readable-order comparator pinned to `locale`.
+* 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 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.
+* 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 compareLocalized(locale) {
-	return (a, b) => a.localeCompare(b, locale);
+function effectiveTier(rule) {
+	if (rule.tier !== void 0) return rule.tier;
+	return measurementTier(rule);
 }
 //#endregion
 //#region src/scorer/scorer.ts
@@ -12013,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
@@ -12221,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];
@@ -12242,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,
@@ -12286,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);
@@ -12300,6 +12803,17 @@ 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.
 */
@@ -12308,7 +12822,7 @@ function correlateFindings(findings) {
 	const rootCauseGroups = groupByRootCause(findings);
 	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),
@@ -12322,9 +12836,9 @@ function correlateFindings(findings) {
 		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),
@@ -12339,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;
 }
@@ -12581,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.
@@ -12684,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",
@@ -13574,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`);
@@ -13922,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;
@@ -13955,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);
@@ -13968,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 = {
@@ -13995,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) {
@@ -14204,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:
@@ -14404,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"
@@ -14655,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).
@@ -15001,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];
@@ -15029,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
@@ -15046,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). */
@@ -15071,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
@@ -15604,6 +16258,9 @@ function assembleScanResult(o) {
 		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
@@ -15618,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 } : {}
 	});
@@ -15635,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,
@@ -15674,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);
@@ -15720,7 +16386,23 @@ 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;
@@ -15747,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)
 	});
@@ -15836,6 +16518,9 @@ async function runScan(args, hooks = {}) {
 		parseFallbacks,
 		astFallbackFiles,
 		degradations: summarizeDegradations(degradationsSince(degradationWindow)),
+		rulesApplied,
+		rulesWithheld,
+		...withheldRuleIds.length > 0 ? { withheldRuleIds } : {},
 		scanned,
 		analyzed,
 		testFiles,
@@ -15940,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 ?? []
 		},
@@ -15983,7 +16672,7 @@ function buildMachineContract(result) {
 		};
 	});
 	return {
-		contractVersion: 1,
+		contractVersion: 2,
 		summary: {
 			digest: `sha256:${digest}`,
 			findings: result.findings.length,
@@ -16004,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 } : {},
@@ -16045,7 +16738,7 @@ 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 = () => {
@@ -16117,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;
@@ -16147,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",
@@ -16276,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);
@@ -16558,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: {
@@ -16570,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: {
@@ -16594,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: {
@@ -16787,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({