mjolnir-qa 5.0.0 → 6.0.1

package/dist/mcp/stdio.mjs

@@ -2,16 +2,17 @@ import { createRequire } from "node:module";
 import { createInterface } from "node:readline";
 import { Buffer as Buffer$1 } from "node:buffer";
 import { createHash, randomBytes } from "node:crypto";
-import { closeSync, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, statSync, unlinkSync, writeSync } from "node:fs";
+import { closeSync, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, realpathSync, 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";
 import { Language, Parser } from "web-tree-sitter";
 import { parse } from "yaml";
 import { inflateRawSync } from "node:zlib";
-//#region src/types.ts
+// src/types.ts
 /** Severity ladder. Order matters for sorting and gating. */
 const SEVERITY_ORDER = [
 	"error",
@@ -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",
@@ -81,8 +99,7 @@ const DEDUCTIONS = {
 	warning: 3,
 	info: 1
 };
-//#endregion
-//#region src/engine/completion.ts
+// 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);
@@ -100,25 +117,31 @@ 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()
 		}
 	};
 }
-//#endregion
-//#region src/engine/degradation-ledger.ts
+// 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
@@ -154,8 +177,7 @@ function summarizeDegradations(window) {
 		count
 	})).sort((a, b) => a.reason < b.reason ? -1 : a.reason > b.reason ? 1 : 0);
 }
-//#endregion
-//#region src/engine/runtime-corroboration.ts
+// src/engine/runtime-corroboration.ts
 /**
 * Stamp runtime corroboration + trust levels onto findings (mutates in
 * place, the same contract as stampEvidenceLevels). Returns the number
@@ -237,8 +259,7 @@ function deriveTrustLevel(finding, corroboration) {
 	if (corroboration.level === "test") return "L4";
 	return "L3";
 }
-//#endregion
-//#region src/rules/measured-fp.generated.ts
+// src/rules/measured-fp.generated.ts
 const MEASURED_FP = {
 	"QA-CI-001": {
 		fpRate: .105,
@@ -375,10 +396,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 +515,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 +605,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,
@@ -759,8 +773,7 @@ const MEASURED_FP = {
 		ciHigh: .4343
 	}
 };
-//#endregion
-//#region src/engine/trust-summary.ts
+// src/engine/trust-summary.ts
 /**
 * Trust level of the summary — the BEST trust level any finding in the
 * scan reached. Static-only findings settle at L2 (deriveTrustLevel's
@@ -884,8 +897,58 @@ function buildTrustSummary(result, declarationsByFile) {
 		ceilingReasons: reasons
 	};
 }
-//#endregion
-//#region src/engine/run-identity.ts
+// 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.`);
+}
+// src/engine/run-identity.ts
 /**
 * Run Identity (product-gap master plan §7, plan 1789009691197 R4c) —
 * the deterministic binding that anchors every trust claim to its
@@ -925,6 +988,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 +1021,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 } : {},
@@ -1012,8 +1077,7 @@ function buildEvidenceGraph(parts) {
 		} } : {}
 	};
 }
-//#endregion
-//#region src/engine/file-executor.ts
+// src/engine/file-executor.ts
 function cacheHitOutcome(job) {
 	return {
 		path: job.path,
@@ -1104,8 +1168,7 @@ function createExecutor(name, concurrency, runOne) {
 		execute: runOne
 	};
 }
-//#endregion
-//#region src/scope/git-resolve.ts
+// src/scope/git-resolve.ts
 /**
 * Absolute-path git resolution (audit S1).
 *
@@ -1180,8 +1243,7 @@ function runGit(root, args) {
 		return null;
 	}
 }
-//#endregion
-//#region src/lib/safe-json.ts
+// src/lib/safe-json.ts
 /**
 * Reusable safe-JSON parse-and-validate helper.
 *
@@ -1218,8 +1280,7 @@ function isRecord(v) {
 		return false;
 	}
 }
-//#endregion
-//#region src/engine/candidate-binding.ts
+// src/engine/candidate-binding.ts
 /**
 * Candidate binding (plan V5-010).
 *
@@ -1352,32 +1413,69 @@ function readCandidateBinding(root, manifestPath = CANDIDATE_MANIFEST_PATH) {
 		return null;
 	}
 }
-//#endregion
-//#region src/engine/version.ts
+// src/engine/version.ts
 /**
 * Engine version, as a leaf module: `runIdentity` (R4c) needs the engine
 * 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
+* `npm run version:surface:sync` (this file is an identity surface) and
+* guarded by the version-consistency
 * spec. cli.ts re-exports this as CLI_VERSION.
 */
-const ENGINE_VERSION = "5.0.0";
-//#endregion
-//#region src/engine/contract-versions.ts
+const ENGINE_VERSION = "6.0.1";
+resolveBuildId();
 /**
-* Versioned contract registry (VERSION-001).
+* The decision, with the process boundary already behind `runGit`.
 *
-* Single source of truth for every version constant the engine exposes
-* to consumers (run identity, evidence graph, machine contract).
-* Constants are `as const` — literal types flow into the identity
-* surface without widening.
-*/
+* 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);
+}
+// src/engine/contract-versions.ts
 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
+// src/discovery/evidence-discovery.ts
 /**
 * Zero-config evidence discovery (Mega MVP Master Plan v3.1 §26 WI-11).
 *
@@ -1421,6 +1519,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;
@@ -1464,8 +1567,7 @@ function discoverEvidenceCandidates(scanRoot) {
 	}
 	return out.sort((a, b) => a.depth - b.depth || (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
 }
-//#endregion
-//#region src/discovery/workspace.ts
+// src/discovery/workspace.ts
 /**
 * Repository discovery (Sprint-Plan W1-03).
 * Finds project root, parses package.json, detects npm/yarn/pnpm workspaces.
@@ -1512,8 +1614,7 @@ function basename$1(p) {
 	const parts = p.split(/[\\/]/);
 	return parts[parts.length - 1];
 }
-//#endregion
-//#region src/lib/fs-bounded.ts
+// src/lib/fs-bounded.ts
 function closeQuiet(fd) {
 	try {
 		closeSync(fd);
@@ -1565,8 +1666,7 @@ function readFileBounded(path, maxBytes) {
 		if (fd !== void 0) closeQuiet(fd);
 	}
 }
-//#endregion
-//#region src/config/config-schema.ts
+// src/config/config-schema.ts
 const VALID_GATES = /* @__PURE__ */ new Set([
 	"advisory",
 	"error",
@@ -1636,8 +1736,7 @@ function validateConfigSchema(config) {
 		errors
 	};
 }
-//#endregion
-//#region src/config/config.ts
+// src/config/config.ts
 /**
 * Config file support (Sprint-Plan W7, Product-MVP §27 + GAP-F).
 * Zero-config preserved: config presence never changes detection
@@ -1771,8 +1870,107 @@ function applySeverityOverrides(findings, cfg) {
 		if (override && SEVERITY_ORDER.includes(override)) f.severity = override;
 	}
 }
-//#endregion
-//#region src/discovery/ignores.ts
+// 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);
+}
+// 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("\\", "/"));
+}
+// src/discovery/ignores.ts
 /**
 * Ignore resolution (Product-MVP.txt R1 — Tier-1 launch blocker).
 *
@@ -1906,32 +2104,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).
@@ -1948,8 +2126,7 @@ function isLintFixtureDir(absoluteDir) {
 		return false;
 	}
 }
-//#endregion
-//#region src/discovery/shared-walk.ts
+// src/discovery/shared-walk.ts
 /**
 * Shared directory walker (audit P-2).
 *
@@ -2012,8 +2189,7 @@ function sharedWalk(options) {
 	};
 	walk(options.root);
 }
-//#endregion
-//#region src/discovery/frameworks.ts
+// src/discovery/frameworks.ts
 /**
 * Framework detection via config resolution (Sprint-Plan W3-01, R8).
 *
@@ -2096,8 +2272,7 @@ function detectFrameworks(ws) {
 		unknown: false
 	};
 }
-//#endregion
-//#region src/engine/ts-ast.ts
+// src/engine/ts-ast.ts
 /**
 * AST precision layer (Upgrade-Plan-v3 Phase 3).
 *
@@ -2108,16 +2283,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 +2314,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,12 +2460,18 @@ 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
+// src/engine/code-text.ts
 /**
 * Code-only text masking (Phase 1 — Tempering Plan).
 *
@@ -2616,8 +2831,7 @@ function getCodeTextForCounting(text, language) {
 function blankRange(chars, start, end) {
 	for (let i = start; i < end && i < chars.length; i++) if (chars[i] !== "\n" && chars[i] !== "\r") chars[i] = " ";
 }
-//#endregion
-//#region src/engine/adapter.ts
+// src/engine/adapter.ts
 /**
 * The §15.1 framework filter, shared by every language adapter: a rule
 * that declares `frameworks` runs on a file only when the file carries
@@ -2631,8 +2845,7 @@ function frameworkFilterApplies(rule, file) {
 	if (tags === void 0 || tags.length === 0) return true;
 	return rule.frameworks.some((f) => tags.includes(f));
 }
-//#endregion
-//#region src/engine/shared-run-rules.ts
+// src/engine/shared-run-rules.ts
 /**
 * Run ONE rule with crash isolation, and return what it produced.
 *
@@ -2669,8 +2882,7 @@ function runRuleIsolated(rule, file, onCrash) {
 		return null;
 	}
 }
-//#endregion
-//#region src/adapters/typescript.ts
+// src/adapters/typescript.ts
 /**
 * TypeScript/JavaScript adapter (R1).
 * Wraps the proven regex-based engine behind the LanguageAdapter
@@ -2707,10 +2919,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 +3002,9 @@ const typescriptAdapter = {
 		".js",
 		".jsx",
 		".mjs",
-		".cjs"
+		".cjs",
+		".mts",
+		".cts"
 	],
 	testFileGlobs: [
 		"*.test.{js,jsx,ts,tsx,mjs,cjs}",
@@ -2913,8 +3135,7 @@ function loadWorkspaceShim(root) {
 		return null;
 	}
 }
-//#endregion
-//#region src/engine/tree-sitter-ast.ts
+// src/engine/tree-sitter-ast.ts
 /**
 * Tree-sitter WASM AST layer for Java and C# — Sprint 8 Task 36
 * (Master-Stabilization-Plan.md).
@@ -2993,7 +3214,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 +3298,7 @@ async function parseJavaAst(text) {
 			return (await getJavaParser()).parse(text) ?? void 0;
 		});
 	} catch {
+		recordDegradation("ast-grammar-unavailable");
 		return;
 	}
 }
@@ -3086,6 +3312,7 @@ async function parseCSharpAst(text) {
 			return (await getCSharpParser()).parse(text) ?? void 0;
 		});
 	} catch {
+		recordDegradation("ast-grammar-unavailable");
 		return;
 	}
 }
@@ -3101,6 +3328,7 @@ async function parsePythonAst(text) {
 			return (await getPythonParser()).parse(text) ?? void 0;
 		});
 	} catch {
+		recordDegradation("ast-grammar-unavailable");
 		return;
 	}
 }
@@ -3126,8 +3354,7 @@ async function releaseTreeSitterResources() {
 		} catch {}
 	}
 }
-//#endregion
-//#region src/adapters/python.ts
+// src/adapters/python.ts
 /**
 * Python/pytest adapter (Upgrade-Plan-v2 R2).
 *
@@ -3199,7 +3426,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 +3440,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: [],
@@ -3281,8 +3512,7 @@ const pythonAdapter = {
 function readText$2(p) {
 	return readFileSync(p, "utf8");
 }
-//#endregion
-//#region src/adapters/java.ts
+// src/adapters/java.ts
 /**
 * Java/JUnit adapter (Upgrade-Plan-v3 Phase 4).
 *
@@ -3448,8 +3678,7 @@ function javaFileTags(file) {
 function readText$1(path) {
 	return readFileSync(path, "utf8");
 }
-//#endregion
-//#region src/adapters/csharp.ts
+// src/adapters/csharp.ts
 /**
 * C#/.NET adapter (Upgrade-Plan-v3 Phase 5).
 *
@@ -3605,8 +3834,7 @@ function csharpFileTags(file) {
 function readText(path) {
 	return readFileSync(path, "utf8");
 }
-//#endregion
-//#region src/discovery/yaml-guards.ts
+// src/discovery/yaml-guards.ts
 /**
 * Shared hostile-YAML guards (product-gap master plan P3 common law —
 * `azure-pipelines.yml` detection rides the same YAML machinery as the
@@ -3675,8 +3903,7 @@ function enforceDepthCap(value, max, depthMessage = GENERIC_LABELS.depthMessage)
 		});
 	}
 }
-//#endregion
-//#region src/discovery/workflow-parser.ts
+// src/discovery/workflow-parser.ts
 /**
 * Safe GitHub Actions workflow parser (Phase 0.3, W4-03 debt).
 *
@@ -3722,8 +3949,7 @@ function parseWorkflow(text) {
 	}
 	return { jobs };
 }
-//#endregion
-//#region src/adapters/github-actions.ts
+// src/adapters/github-actions.ts
 /**
 * GitHub Actions adapter (R1).
 * Owns workflow discovery and safe-YAML parsing; CI rules consume the
@@ -3808,8 +4034,7 @@ const githubActionsAdapter = {
 };
 var WorkflowParseSkipped = class extends Error {};
 const LIMITS_MAX_BYTES$2 = 1048576;
-//#endregion
-//#region src/discovery/azure-pipeline-parser.ts
+// src/discovery/azure-pipeline-parser.ts
 /**
 * Safe Azure DevOps pipeline parser (product-gap master plan P3b).
 *
@@ -4043,8 +4268,7 @@ function isAzurePipelineFixture(normalizedPath) {
 	const base = normalizedPath.replaceAll("\\", "/").split("/").pop() ?? "";
 	return AZURE_PIPELINE_FILENAMES_SET.has(base);
 }
-//#endregion
-//#region src/adapters/azure-pipelines.ts
+// src/adapters/azure-pipelines.ts
 /**
 * Azure DevOps pipeline adapter (product-gap master plan P3b).
 * Owns `azure-pipelines.yml` discovery (repo root, the platform's
@@ -4124,8 +4348,7 @@ const azurePipelinesAdapter = {
 };
 var AzureParseSkipped = class extends Error {};
 const LIMITS_MAX_BYTES$1 = 1048576;
-//#endregion
-//#region src/adapters/jenkins.ts
+// src/adapters/jenkins.ts
 /**
 * Jenkins adapter (product-gap master plan P3c).
 * The root `Jenkinsfile` is a TEXT-target file kind: declarative and
@@ -4199,8 +4422,7 @@ const jenkinsAdapter = {
 	}
 };
 const LIMITS_MAX_BYTES = 1048576;
-//#endregion
-//#region src/discovery/scan-adapters.ts
+// src/discovery/scan-adapters.ts
 /**
 * The canonical adapter registry (audits H-6/H-9).
 *
@@ -4293,6 +4515,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 +4545,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) {
@@ -4320,8 +4559,7 @@ function isInsideSkippedDir(root, absPath, skipNames) {
 	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
+// src/scope/changed.ts
 /**
 * Changed-scope engine (Sprint-Plan W6, Product-MVP §9 `--scope changed`).
 *
@@ -4564,8 +4802,7 @@ function computeStagedFiles(root) {
 	if (raw === null) return null;
 	return raw.split("\0").filter((s) => s.length > 0);
 }
-//#endregion
-//#region src/rules/rule.ts
+// src/rules/rule.ts
 /**
 * Invoke an `astQuery` hook with the mandatory-fallback contract: no
 * hook or no AST on the context resolves to `undefined` (→ regex
@@ -4578,8 +4815,7 @@ function tryAstQuery(hook, ctx) {
 function defineRule(rule) {
 	return rule;
 }
-//#endregion
-//#region src/rules/shared/positions.ts
+// src/rules/shared/positions.ts
 /**
 * Shared position helpers (Phase 6 — Tempering Plan).
 * One lineAt, one colAt, one matchBrace. The other 79 copies are dead.
@@ -4624,8 +4860,7 @@ function lineAt(text, index) {
 function colAt(text, index) {
 	return index - (index <= 0 ? -1 : text.lastIndexOf("\n", index - 1));
 }
-//#endregion
-//#region src/rules/test/qa-test-001-focused-test.ts
+// src/rules/test/qa-test-001-focused-test.ts
 /**
 * QA-TEST-001 — Focused test committed (`fit`/`fdescribe`/`.only`).
 * Severity: error · Confidence: high · deterministic-defect
@@ -4691,8 +4926,7 @@ const focusedTestCommitted = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/test/qa-test-002-skipped-test.ts
+// src/rules/test/qa-test-002-skipped-test.ts
 /**
 * QA-TEST-002 — Skipped test (`it.skip`, `xit`, `test.skip`, `describe.skip`).
 * Severity: warning · Confidence: high · deterministic-defect
@@ -4748,8 +4982,7 @@ const skippedTest = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/shared/masking.ts
+// src/rules/shared/masking.ts
 /** True when the offset was blanked in codeText (inside a string or comment). */
 function isMasked(ctx, index) {
 	const mask = ctx.codeText;
@@ -4810,8 +5043,7 @@ function isInsideEmbeddedCode(ctx, index) {
 	const hasCallSyntax = /\w\s*\(/.test(inner);
 	return hasNestedQuote && hasCallSyntax;
 }
-//#endregion
-//#region src/rules/test/qa-test-003-no-assertions.ts
+// src/rules/test/qa-test-003-no-assertions.ts
 /**
 * QA-TEST-003 — Test with no assertions.
 * Severity: error · Confidence: high · deterministic-defect
@@ -4889,8 +5121,7 @@ function matchBrace$2(text, open) {
 	}
 	return -1;
 }
-//#endregion
-//#region src/rules/test/qa-test-004-hard-sleep.ts
+// src/rules/test/qa-test-004-hard-sleep.ts
 /**
 * QA-TEST-004 — Hard sleep (`sleep()`, `waitForTimeout()`, `setTimeout` as wait).
 * Severity: warning · Confidence: high · deterministic-defect
@@ -4955,8 +5186,7 @@ const hardSleep = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/test/qa-test-006-retry-abuse.ts
+// src/rules/test/qa-test-006-retry-abuse.ts
 /**
 * QA-TEST-006 — Retry abuse in test config.
 * Severity: warning · Confidence: high · deterministic-defect
@@ -5022,8 +5252,7 @@ const retryAbuse = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/test/qa-test-010-empty-body.ts
+// src/rules/test/qa-test-010-empty-body.ts
 /**
 * QA-TEST-010 — Empty test body.
 * Severity: error · Confidence: high · deterministic-defect
@@ -5078,8 +5307,7 @@ const emptyTestBody = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/quality/qa-tqual-002-tautological.ts
+// src/rules/quality/qa-tqual-002-tautological.ts
 /**
 * QA-TQUAL-002 — Tautological assertion.
 * Severity: error · Confidence: high · deterministic-defect
@@ -5156,8 +5384,7 @@ const tautologicalAssertion = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/quality/qa-tqual-009-promise-assertion.ts
+// src/rules/quality/qa-tqual-009-promise-assertion.ts
 /**
 * QA-TQUAL-009 — Unawaited assertion inside a promise chain.
 * Severity: error · Confidence: high · deterministic-defect
@@ -5327,8 +5554,7 @@ function matchParen$2(text, open) {
 	}
 	return -1;
 }
-//#endregion
-//#region src/rules/quality/qa-tqual-011-commented-out.ts
+// src/rules/quality/qa-tqual-011-commented-out.ts
 /**
 * QA-TQUAL-011 — Commented-out tests.
 * Severity: warning · Confidence: high · deterministic-defect
@@ -5441,8 +5667,7 @@ function commentRanges(ctx) {
 	}
 	return ranges;
 }
-//#endregion
-//#region src/rules/playwright/qa-pw-002-unawaited-assertion.ts
+// src/rules/playwright/qa-pw-002-unawaited-assertion.ts
 /**
 * QA-PW-002 — Missing `await` on a Playwright locator assertion.
 * Severity: error · Confidence: high · deterministic-defect
@@ -5498,7 +5723,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",
@@ -5587,8 +5812,7 @@ function runRegexFallback(text, path) {
 	});
 	return findings;
 }
-//#endregion
-//#region src/rules/playwright/qa-pw-003-debug-artifacts.ts
+// src/rules/playwright/qa-pw-003-debug-artifacts.ts
 /**
 * QA-PW-003 — Committed `page.pause()` or `test.only()` in e2e specs.
 * Severity: error · Confidence: high · deterministic-defect
@@ -5612,7 +5836,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 = [];
@@ -5640,8 +5864,7 @@ const committedDebugArtifacts = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-004-brittle-selectors.ts
+// src/rules/playwright/qa-pw-004-brittle-selectors.ts
 /**
 * QA-PW-004 — Brittle CSS/XPath selectors vs role-based locators.
 * Severity: warning · Confidence: medium · heuristic-risk
@@ -5733,8 +5956,7 @@ function stripComments(ctx) {
 	} catch {}
 	return ctx.text.replace(/\/\/[^\n]*/g, (cm) => " ".repeat(cm.length));
 }
-//#endregion
-//#region src/rules/ci/verification-gate.ts
+// src/rules/ci/verification-gate.ts
 /**
 * Shared "is this shell command a verification gate?" matcher for the QA-CI
 * rules. A gate is a command whose failure MUST fail the job — test runners,
@@ -5774,8 +5996,7 @@ const VERIFICATION_GATE_RE = new RegExp([
 function looksLikeVerificationGate(cmd) {
 	return VERIFICATION_GATE_RE.test(cmd);
 }
-//#endregion
-//#region src/rules/ci/azure-gates.ts
+// src/rules/ci/azure-gates.ts
 /** Discriminator: the Azure parser is the only one emitting `platform`. */
 function isAzurePipelineDoc(ast) {
 	return typeof ast === "object" && ast !== null && ast.platform === "azure-pipelines";
@@ -5859,8 +6080,7 @@ function locateAzureJobKey(text, job, keyName) {
 	if (m) return lineAt(text, m.index);
 	return 1;
 }
-//#endregion
-//#region src/rules/ci/qa-ci-001-continue-on-error.ts
+// src/rules/ci/qa-ci-001-continue-on-error.ts
 /**
 * QA-CI-001 — `continue-on-error: true` masks a failing job.
 * Severity: error · Confidence: high · deterministic-defect
@@ -6088,8 +6308,7 @@ function describeAzureStep(step) {
 	if (step.task) return step.task;
 	return "step";
 }
-//#endregion
-//#region src/rules/ci/qa-ci-002-swallowed-exit.ts
+// src/rules/ci/qa-ci-002-swallowed-exit.ts
 /**
 * QA-CI-002 — `|| true` swallows a command's exit code.
 * Severity: error · Confidence: high · deterministic-defect
@@ -6144,8 +6363,7 @@ const swallowedExitCode = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/ci/qa-ci-007-retry-masking.ts
+// src/rules/ci/qa-ci-007-retry-masking.ts
 /**
 * QA-CI-007 — Retry masking test failures.
 * Severity: warning · Confidence: high · deterministic-defect
@@ -6296,8 +6514,7 @@ function azureArm$1(ctx, doc, findings) {
 		});
 	}
 }
-//#endregion
-//#region src/rules/ci/qa-ci-005-report-never-generated.ts
+// src/rules/ci/qa-ci-005-report-never-generated.ts
 /**
 * QA-CI-005 — Report consumed but never generated.
 * Severity: error · Confidence: high · deterministic-defect
@@ -6455,8 +6672,7 @@ function findJobConsumerLine(text, jobName, consumerRe) {
 	const anywhere = new RegExp(consumerRe.source, "i").exec(text);
 	return anywhere ? lineAt(text, anywhere.index) : 1;
 }
-//#endregion
-//#region src/rules/ci/jenkins-gates.ts
+// src/rules/ci/jenkins-gates.ts
 /**
 * Jenkinsfile block scanner for the QA-CI Jenkins arms (product-gap
 * master plan P3c). Jenkinsfiles are Groovy text — "no new language
@@ -6702,8 +6918,7 @@ function textIsVerificationGate(text) {
 function lineOfOffset(text, offset) {
 	return lineAt(text, offset);
 }
-//#endregion
-//#region src/rules/ci/qa-ci-008-always-success.ts
+// src/rules/ci/qa-ci-008-always-success.ts
 /**
 * QA-CI-008 — Always-success step at the end of a job.
 * Severity: error · Confidence: high · deterministic-defect
@@ -6877,8 +7092,7 @@ function jenkinsArm$1(ctx, findings) {
 		});
 	}
 }
-//#endregion
-//#region src/rules/ci/qa-ci-009-exit-code.ts
+// src/rules/ci/qa-ci-009-exit-code.ts
 /**
 * QA-CI-009 — Test command does not propagate exit code.
 * Severity: error · Confidence: high · deterministic-defect
@@ -7013,8 +7227,7 @@ function jenkinsArm(ctx, findings) {
 		});
 	}
 }
-//#endregion
-//#region src/rules/ci/qa-ci-010-non-blocking.ts
+// src/rules/ci/qa-ci-010-non-blocking.ts
 /**
 * QA-CI-010 — Required test job is non-blocking for branch protection.
 * Severity: error · Confidence: medium · deterministic-defect
@@ -7097,8 +7310,7 @@ function findLine(text, re) {
 function escapeRe(s) {
 	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-//#endregion
-//#region src/rules/ci/qa-ci-013-can-never-fail.ts
+// src/rules/ci/qa-ci-013-can-never-fail.ts
 /**
 * QA-CI-013 — Verification stage/job conditioned so it can never fail the
 * pipeline (product-gap master plan P3b).
@@ -7202,8 +7414,7 @@ const canNeverFailGate = defineRule({
 function jobHasGate(job) {
 	return (job.steps ?? []).some((s) => s !== void 0 && stepIsVerificationGate$1(s));
 }
-//#endregion
-//#region src/rules/ci/qa-ci-014-swallowed-verification.ts
+// src/rules/ci/qa-ci-014-swallowed-verification.ts
 /**
 * QA-CI-014 — try/catch swallowing a verification-stage failure without
 * rethrow or failure-marking (product-gap master plan P3c).
@@ -7260,8 +7471,7 @@ const swallowedVerificationFailure = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/python/qa-py-003-no-assertions.ts
+// src/rules/python/qa-py-003-no-assertions.ts
 /**
 * QA-PY-003 — Test function with no assertions.
 * Severity: error · Confidence: high · deterministic-defect
@@ -7382,8 +7592,7 @@ function extractBlock$1(text, afterColon) {
 	const lineEnd = rest.indexOf("\n", firstIdx);
 	return lineEnd === -1 ? rest : rest.slice(0, lineEnd);
 }
-//#endregion
-//#region src/rules/python/qa-py-005-hard-sleep.ts
+// src/rules/python/qa-py-005-hard-sleep.ts
 /**
 * QA-PY-005 — time.sleep() in tests.
 * Severity: warning · Confidence: high · deterministic-defect
@@ -7430,15 +7639,14 @@ const pyHardSleep = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/python/qa-py-002-skipped-test.ts
+// src/rules/python/qa-py-002-skipped-test.ts
 /**
 * QA-PY-002 — Skipped test (`@pytest.mark.skip`, `xfail` non-strict).
 * Severity: warning · Confidence: high · deterministic-defect
 */
 const pySkippedTest = defineRule({
 	id: "QA-PY-002",
-	tier: "core",
+	tier: "extended",
 	category: "QA-TEST",
 	title: "Skipped test",
 	severity: "warning",
@@ -7491,8 +7699,7 @@ const pySkippedTest = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/python/qa-py-012-tautological.ts
+// src/rules/python/qa-py-012-tautological.ts
 /**
 * QA-PY-012 — Tautological assertion (`assert True`, `assert x == x`).
 * Severity: error · Confidence: high · deterministic-defect
@@ -7547,8 +7754,7 @@ const pyTautological = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/python/qa-py-001-focused-test.ts
+// src/rules/python/qa-py-001-focused-test.ts
 /**
 * QA-PY-001 — Focused test committed.
 * Severity: error · Confidence: high · deterministic-defect
@@ -7574,7 +7780,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;
@@ -7602,8 +7808,7 @@ const pyFocusedTest = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/engine/jv-cs-ast.ts
+// src/engine/jv-cs-ast.ts
 /** Narrow the loose `ast` seam back to a tree-sitter Tree. */
 function getTreeSitterTree(ast) {
 	if (!(ast instanceof Object) || !("rootNode" in ast)) return void 0;
@@ -7807,8 +8012,7 @@ function isHelperIdiom(name) {
 	}
 	return false;
 }
-//#endregion
-//#region src/engine/python-ast.ts
+// src/engine/python-ast.ts
 function getPythonTree(ast) {
 	return getTreeSitterTree(ast);
 }
@@ -7818,26 +8022,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);
@@ -7854,8 +8097,7 @@ function pythonWithRaisesBlocks(tree) {
 	});
 	return out;
 }
-//#endregion
-//#region src/rules/python/qa-py-007-raises-without-match.ts
+// src/rules/python/qa-py-007-raises-without-match.ts
 /**
 * QA-PY-007 — pytest.raises without match.
 * Severity: warning · Confidence: medium · heuristic-risk
@@ -7883,7 +8125,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 +8184,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 +8208,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",
@@ -7981,8 +8224,7 @@ function astArm(ctx, tree) {
 	}
 	return findings;
 }
-//#endregion
-//#region src/rules/python/qa-py-009-commented-out.ts
+// src/rules/python/qa-py-009-commented-out.ts
 /**
 * QA-PY-009 — Commented-out tests.
 * Severity: warning · Confidence: high · deterministic-defect
@@ -8008,7 +8250,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;
@@ -8029,8 +8271,7 @@ const pyCommentedOutTest = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/python/qa-py-004-bare-truthiness.ts
+// src/rules/python/qa-py-004-bare-truthiness.ts
 /**
 * QA-PY-004 — Bare truthiness assert on complex object.
 * Severity: warning · Confidence: medium · heuristic-risk
@@ -8057,13 +8298,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 +8329,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({
@@ -8103,8 +8350,7 @@ const pyBareTruthinessAssert = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/python/qa-py-011-mutable-fixture.ts
+// src/rules/python/qa-py-011-mutable-fixture.ts
 /**
 * QA-PY-011 — Mutable fixture shared across tests.
 * Severity: warning · Confidence: medium · heuristic-risk
@@ -8130,7 +8376,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 = [];
@@ -8155,8 +8401,7 @@ const pyMutableFixture = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-101-wait-for-timeout.ts
+// src/rules/playwright/qa-pw-101-wait-for-timeout.ts
 /**
 * QA-PW-101 — waitForTimeout() anywhere.
 * Severity: error · Confidence: high · deterministic-defect
@@ -8164,7 +8409,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",
@@ -8203,8 +8448,7 @@ const pwWaitForTimeout = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-102-wait-load.ts
+// src/rules/playwright/qa-pw-102-wait-load.ts
 /**
 * QA-PW-102 — waitForEvent('load') / waitForLoadState('load') instead of
 * web-first assertions.
@@ -8258,8 +8502,7 @@ const pwWaitForLoadEvent = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-113-deep-frames.ts
+// src/rules/playwright/qa-pw-113-deep-frames.ts
 /**
 * QA-PW-113 — frameLocator chains > 2 deep.
 * Severity: warning · Confidence: medium · heuristic-risk
@@ -8285,7 +8528,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 = [];
@@ -8309,8 +8552,7 @@ const pwDeepFrameLocator = defineRule({
 function count(fragment) {
 	return fragment.match(/frameLocator\s*\(/g).length;
 }
-//#endregion
-//#region src/rules/playwright/qa-pw-117-serial.ts
+// src/rules/playwright/qa-pw-117-serial.ts
 /**
 * QA-PW-117 — test.describe.serial without justification comment.
 * Severity: warning · Confidence: high · deterministic-defect
@@ -8364,8 +8606,7 @@ const pwSerialNoJustification = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-121-config-retries.ts
+// src/rules/playwright/qa-pw-121-config-retries.ts
 /**
 * QA-PW-121 — playwright.config: retries >= 3 or workers = 0.
 * Severity: warning · Confidence: high · deterministic-defect
@@ -8394,7 +8635,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 +8653,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({
@@ -8430,8 +8671,7 @@ const pwConfigRetryAbuse = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-122-no-trace.ts
+// src/rules/playwright/qa-pw-122-no-trace.ts
 /**
 * QA-PW-122 — No trace capture on retry in playwright.config.
 * Severity: warning · Confidence: high · deterministic-defect
@@ -8480,8 +8720,7 @@ const pwNoTraceOnRetry = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-124-project-split.ts
+// src/rules/playwright/qa-pw-124-project-split.ts
 /**
 * QA-PW-124 — Projects defined but no smoke/regression split.
 * Severity: info · Confidence: high · deterministic-defect
@@ -8543,8 +8782,7 @@ const pwNoProjectSplit = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-104-trial-click.ts
+// src/rules/playwright/qa-pw-104-trial-click.ts
 /**
 * QA-PW-104 — `{ trial: true }` misuse — check-then-act race.
 * Severity: warning · Confidence: medium · heuristic-risk
@@ -8569,7 +8807,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 = [];
@@ -8590,8 +8828,7 @@ const pwTrialMisuse = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-116-storage-state.ts
+// src/rules/playwright/qa-pw-116-storage-state.ts
 /**
 * QA-PW-116 — storageState reuse without expiry strategy.
 * Severity: warning · Confidence: medium · heuristic-risk
@@ -8637,8 +8874,7 @@ const pwStorageStateNoExpiry = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-125-global-setup.ts
+// src/rules/playwright/qa-pw-125-global-setup.ts
 /**
 * QA-PW-125 — globalSetup mutating shared external state.
 * Severity: warning · Confidence: medium · heuristic-risk
@@ -8696,8 +8932,7 @@ const pwGlobalSetupSharedState = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-115-shared-page.ts
+// src/rules/playwright/qa-pw-115-shared-page.ts
 /**
 * QA-PW-115 — Shared `page` across parallel tests without isolation.
 * Severity: warning · Confidence: medium · heuristic-risk
@@ -8745,8 +8980,7 @@ const pwSharedPage = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-140.ts
+// src/rules/playwright/qa-pw-140.ts
 /**
 * QA-PW-140 — Screenshot without maxDiffPixelRatio.
 *
@@ -8774,7 +9008,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 = [];
@@ -8820,8 +9054,7 @@ function matchParen(text, open) {
 	}
 	return -1;
 }
-//#endregion
-//#region src/rules/playwright/qa-pw-123-hardcoded-url.ts
+// src/rules/playwright/qa-pw-123-hardcoded-url.ts
 /**
 * QA-PW-123 — Hardcoded baseURL in specs.
 * Severity: warning · Confidence: high · deterministic-defect
@@ -8869,8 +9102,7 @@ const hardcodedBaseUrl = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/quality/qa-env-001-env-coupling.ts
+// src/rules/quality/qa-env-001-env-coupling.ts
 /**
 * QA-ENV-001 — "Works On My Machine" detector core (Tier 5 #24).
 * Environment coupling in test files: fixed ports, OS paths,
@@ -8937,8 +9169,7 @@ const envCoupling = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-141-retry-no-triage.ts
+// src/rules/playwright/qa-pw-141-retry-no-triage.ts
 /**
 * QA-PW-141 — playwright.config retries set high enough to mask flakes.
 * Severity: warning · Confidence: high · deterministic-defect
@@ -8989,14 +9220,13 @@ 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;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-142-blanket-route.ts
+// src/rules/playwright/qa-pw-142-blanket-route.ts
 /**
 * QA-PW-142 — page.route() blanket-mocking instead of scoped intercepts.
 * Severity: warning · Confidence: medium · heuristic-risk
@@ -9051,8 +9281,7 @@ const pwBlanketRouteMock = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-143-no-artifacts.ts
+// src/rules/playwright/qa-pw-143-no-artifacts.ts
 /**
 * QA-PW-143 — No screenshot/video artifact capture on failure.
 * Severity: info · Confidence: high · deterministic-defect
@@ -9105,8 +9334,7 @@ const pwNoFailureArtifacts = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-144-single-browser.ts
+// src/rules/playwright/qa-pw-144-single-browser.ts
 /**
 * QA-PW-144 — Single-browser project matrix (no cross-browser coverage).
 * Severity: info · Confidence: high · deterministic-defect
@@ -9168,8 +9396,7 @@ const pwSingleBrowserMatrix = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-146-css-locator.ts
+// src/rules/playwright/qa-pw-146-css-locator.ts
 /**
 * QA-PW-146 — CSS/XPath string selector where Playwright's locator
 * standard expects a normalized locator (plan §17.3).
@@ -9248,8 +9475,7 @@ const pwLocatorNormalize = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/playwright/qa-pw-147-codegen-artifact.ts
+// src/rules/playwright/qa-pw-147-codegen-artifact.ts
 /**
 * QA-PW-147 — Playwright codegen artifact left unedited (plan §17.1).
 * Severity: info · Confidence: medium · observation
@@ -9308,8 +9534,7 @@ const pwCodegenArtifact = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/python/qa-py-101-sync-async-mix.ts
+// src/rules/python/qa-py-101-sync-async-mix.ts
 /**
 * QA-PY-101 — Playwright-Python: sync API in async test (or vice versa).
 * Severity: warning · Confidence: high · deterministic-defect
@@ -9358,8 +9583,7 @@ const pyPwSyncAsyncMix = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/python/qa-py-103-wait-for-timeout.ts
+// src/rules/python/qa-py-103-wait-for-timeout.ts
 /**
 * QA-PY-103 — Playwright-Python: wait_for_timeout() as synchronization.
 * Severity: warning · Confidence: high · deterministic-defect
@@ -9384,7 +9608,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 = [];
@@ -9406,8 +9630,7 @@ const pyPwWaitForTimeout = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/python/qa-py-105-pw-no-assertions.ts
+// src/rules/python/qa-py-105-pw-no-assertions.ts
 /**
 * QA-PY-105 — Playwright-Python: no assertion in Playwright test.
 * Severity: error · Confidence: high · deterministic-defect
@@ -9487,8 +9710,7 @@ function extractBlock(text, afterColon) {
 	const lineEnd = rest.indexOf("\n", firstContent.index);
 	return lineEnd === -1 ? rest : rest.slice(0, lineEnd);
 }
-//#endregion
-//#region src/rules/java/qa-jv-101-disabled-test.ts
+// src/rules/java/qa-jv-101-disabled-test.ts
 /**
 * QA-JV-101 — @Disabled test without justification.
 * Severity: warning · Confidence: high · deterministic-defect
@@ -9542,8 +9764,7 @@ const jvDisabledTest = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/java/qa-jv-103-no-assertions.ts
+// src/rules/java/qa-jv-103-no-assertions.ts
 /**
 * QA-JV-103 — Test method without assertions.
 * Severity: error · Confidence: high · deterministic-defect
@@ -9700,8 +9921,7 @@ function matchBrace$1(text, open) {
 	}
 	return -1;
 }
-//#endregion
-//#region src/engine/qa-model.ts
+// src/engine/qa-model.ts
 /**
 * Extract the semantic model for one parsed file. Resolves undefined
 * when the language has no extractor or the parse stage produced no
@@ -10244,8 +10464,7 @@ function extractPythonModel(file) {
 		nodes
 	};
 }
-//#endregion
-//#region src/rules/java/qa-jv-105-wait-for-timeout.ts
+// src/rules/java/qa-jv-105-wait-for-timeout.ts
 /**
 * QA-JV-105 — waitForTimeout / hardcoded navigation waits.
 * Severity: warning · Confidence: high · deterministic-defect
@@ -10269,7 +10488,7 @@ function extractPythonModel(file) {
 */
 const jvWaitForTimeout = defineRule({
 	id: "QA-JV-105",
-	tier: "core",
+	tier: "extended",
 	category: "QA-PW",
 	title: "waitForTimeout hard sleep",
 	severity: "warning",
@@ -10330,15 +10549,14 @@ const jvWaitForTimeout = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/csharp/qa-cs-101-skipped-test.ts
+// src/rules/csharp/qa-cs-101-skipped-test.ts
 /**
 * QA-CS-101 — [Ignore]/[Skip] test without justification.
 * Severity: warning · Confidence: high · deterministic-defect
 */
 const csSkippedTest = defineRule({
 	id: "QA-CS-101",
-	tier: "core",
+	tier: "extended",
 	category: "QA-PW",
 	title: "Skipped test",
 	severity: "warning",
@@ -10395,8 +10613,7 @@ const csSkippedTest = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/csharp/qa-cs-103-no-assertions.ts
+// src/rules/csharp/qa-cs-103-no-assertions.ts
 /**
 * QA-CS-103 — Test method without assertions.
 * Severity: error · Confidence: high · deterministic-defect
@@ -10430,7 +10647,6 @@ const csSkippedTest = defineRule({
 * Deep-diffing those requires symbol semantics Mjölnir deliberately does
 * not promise for C# (plan §13.4).
 */
-/** Helper/verification idiom: verify/check/assert-prefixed names. */
 const WHY$5 = "Without an assertion the test can only fail by throwing — it cannot detect behavioral regressions.";
 const FIX$4 = "Add an assertion on the expected outcome, or remove the test.";
 function makeFinding(path, position, name) {
@@ -10533,7 +10749,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) {
@@ -10594,8 +10810,7 @@ function matchBrace(text, open) {
 	}
 	return -1;
 }
-//#endregion
-//#region src/rules/csharp/qa-cs-105-wait-for-timeout.ts
+// src/rules/csharp/qa-cs-105-wait-for-timeout.ts
 /**
 * QA-CS-105 — Playwright-.NET: WaitForTimeoutAsync hard sleep.
 * Severity: warning · Confidence: high · deterministic-defect
@@ -10683,8 +10898,7 @@ const csWaitForTimeout = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/cypress/qa-cyp-001-cy-wait.ts
+// src/rules/cypress/qa-cyp-001-cy-wait.ts
 /**
 * QA-CYP-001 — Fixed `cy.wait(n)` (hard-coded wait).
 * Severity: warning · Confidence: high · deterministic-defect
@@ -10763,8 +10977,7 @@ function isCypressFile(ctx) {
 	if (/\.cy\.[jt]sx?$/.test(ctx.path)) return true;
 	return /\bcy\s*\./.test(ctx.codeText ?? ctx.text);
 }
-//#endregion
-//#region src/rules/cypress/qa-cyp-002-focused-test.ts
+// src/rules/cypress/qa-cyp-002-focused-test.ts
 /**
 * QA-CYP-002 — Focused test (`.only`).
 * Severity: error · Confidence: high · deterministic-defect
@@ -10827,8 +11040,7 @@ const cypFocusedTest = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/cypress/qa-cyp-003-config-security.ts
+// src/rules/cypress/qa-cyp-003-config-security.ts
 /**
 * QA-CYP-003 — Cypress config disables `chromeWebSecurity`.
 * Severity: error · Confidence: high · deterministic-defect
@@ -10898,8 +11110,7 @@ const cypConfigSecurity = defineRule({
 		return findings;
 	}
 });
-//#endregion
-//#region src/rules/selenium/qa-se-sleep-lookup.ts
+// src/rules/selenium/qa-se-sleep-lookup.ts
 /**
 * Selenium sleep-then-interact rules (Verification Trust Evolution Plan
 * §15.3 — "Selenium implicit-wait abuse / missing WebDriverWait",
@@ -11050,8 +11261,7 @@ const sePythonSleepLookup = defineRule({
 		return sleepBeforeLookup(ctx, PY_SLEEP_RE, PY_LOOKUP_RE, "QA-SE-003");
 	}
 });
-//#endregion
-//#region src/rules/shared/family.ts
+// src/rules/shared/family.ts
 /**
 * Cross-language pattern rule family generator (Phase 6 — Tempering Plan).
 *
@@ -11117,8 +11327,7 @@ function definePatternFamily(opts) {
 		}
 	}));
 }
-//#endregion
-//#region src/rules/families/hard-sleep.ts
+// src/rules/families/hard-sleep.ts
 /**
 * Hard-sleep family (Phase 6 — Tempering Plan).
 * Java: Thread.sleep(), C#: Thread.Sleep() / Task.Delay()
@@ -11259,7 +11468,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,
@@ -11269,8 +11478,7 @@ const hardSleepFamily = definePatternFamily({
 		fix: "Use `await Assertions.Expect(locator).ToBeVisibleAsync()` or locator.WaitForAsync()."
 	}]
 });
-//#endregion
-//#region src/rules/families/network-idle.ts
+// src/rules/families/network-idle.ts
 /**
 * Network-idle family (Phase 6 — Tempering Plan).
 * All three language variants of waitForLoadState(networkidle).
@@ -11331,8 +11539,7 @@ const networkIdleFamily = definePatternFamily({
 		}
 	]
 });
-//#endregion
-//#region src/rules/families/hardcoded-url.ts
+// src/rules/families/hardcoded-url.ts
 /**
 * Hardcoded-URL family (Phase 6 — Tempering Plan).
 * Detects absolute URLs in navigation/request calls across languages.
@@ -11382,8 +11589,7 @@ const hardcodedUrlFamily = definePatternFamily({
 		fix: "Use `--base-url` / `base_url` fixture, or `os.environ[...]`."
 	}]
 });
-//#endregion
-//#region src/rules/families/shared-page.ts
+// src/rules/families/shared-page.ts
 /**
 * Shared-page family (Phase 6 — Tempering Plan).
 * Detects static/module-level Page/Browser instances shared across tests.
@@ -11444,8 +11650,7 @@ const sharedPageFamily = definePatternFamily({
 		}
 	]
 });
-//#endregion
-//#region src/rules/families/brittle-selectors.ts
+// src/rules/families/brittle-selectors.ts
 /**
 * Brittle-selectors family (Phase 6 — Tempering Plan).
 * Detects XPath/structural CSS selectors across Java, C#, Python.
@@ -11557,8 +11762,7 @@ const brittleSelectorsFamily = [
 		}
 	], "Prefer role-based locators (`get_by_role(...)`) or data-testid attributes.")
 ];
-//#endregion
-//#region src/rules/families/retry-masking.ts
+// src/rules/families/retry-masking.ts
 /**
 * Retry-masking family (Phase 6 — Tempering Plan).
 * Detects retry annotations/attributes that mask flaky tests.
@@ -11582,7 +11786,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 = [];
@@ -11678,8 +11882,7 @@ const retryMaskingFamily = [defineRule({
 		return findings;
 	}
 })];
-//#endregion
-//#region src/rules/index.ts
+// src/rules/index.ts
 const RULES = [
 	focusedTestCommitted,
 	skippedTest,
@@ -11760,55 +11963,117 @@ const RULES = [
 function getRule(id) {
 	return RULES.find((r) => r.id === id);
 }
-//#endregion
-//#region src/lib/compare.ts
+// 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
+// src/scorer/scorer.ts
 /**
 * Transparent scorer (Product-MVP §8).
 * score = 100 − Σ(severity deductions), floor 0.
@@ -11960,9 +12225,9 @@ function countTestDeclarations(text, codeText) {
 	const source = codeText ?? text;
 	const patterns = [
 		/\b(?:it|test)(?:\.\w+)*\s*(?:\(|`)/g,
-		/^\s*(?:async\s+)?def\s+test_\w*/gm,
-		/^\s*@Test\b/gm,
-		/^\s*\[(?:Test|Fact|Theory|TestMethod)\b/gm
+		/^[ \t]*(?:async[ \t]+)?def[ \t]+test_\w*/gm,
+		/^[ \t]*@Test\b/gm,
+		/^[ \t]*\[(?:Test|Fact|Theory|TestMethod)\b/gm
 	];
 	let count = 0;
 	for (const re of patterns) {
@@ -11971,8 +12236,7 @@ function countTestDeclarations(text, codeText) {
 	}
 	return count;
 }
-//#endregion
-//#region src/engine/rule-runner.ts
+// src/engine/rule-runner.ts
 /**
 * Legacy appliesTo → adapter id mapping.
 *
@@ -12011,32 +12275,109 @@ function asUniversal(rule) {
 		}
 	};
 }
-//#endregion
-//#region src/engine/tier-policy.ts
+// 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
-//#region src/engine/evidence-core.ts
+// src/engine/evidence-core.ts
 /**
 * The core's own version — stamped into every record's provenance so a
 * consumer can tell which normalization contract produced a record.
@@ -12103,8 +12444,7 @@ function countEvidence(records) {
 	}
 	return counts;
 }
-//#endregion
-//#region src/engine/provenance.ts
+// src/engine/provenance.ts
 const GENERATED_HEADER_RE = /^\s*(?:\/\/|#|\/\*)\s*(?:auto[- ]?generated|generated by|do not edit)/i;
 /**
 * Codegen fingerprint: the recorder names its first test exactly
@@ -12145,8 +12485,7 @@ function computeAgenticProfile(files, findings) {
 		note: "Static provenance markers only (generated-file headers, Playwright codegen default titles). Absence of a marker does not prove human authorship; healed and MCP-edited files without markers are indistinguishable from hand-written ones. Provenance never changes scoring or evidence — authorship is metadata, not trust."
 	};
 }
-//#endregion
-//#region src/engine/overlap-dedup.ts
+// src/engine/overlap-dedup.ts
 const TIER_RANK = {
 	core: 0,
 	extended: 1,
@@ -12221,8 +12560,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];
@@ -12241,8 +12580,16 @@ function dropOrderBefore(a, b, metaByRuleId) {
 	if (ranksBefore(b, a, metaByRuleId)) return true;
 	return (a.column ?? Number.MAX_SAFE_INTEGER) < (b.column ?? Number.MAX_SAFE_INTEGER);
 }
-//#endregion
-//#region src/engine/correlation-engine.ts
+// 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}`;
+}
+// src/engine/correlation-engine.ts
 const EVIDENCE_RANK = {
 	E0: 0,
 	E1: 1,
@@ -12286,13 +12633,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 +12665,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 +12684,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 +12698,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,12 +12715,11 @@ 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;
 }
-//#endregion
-//#region src/engine/dependency-graph.ts
+// src/engine/dependency-graph.ts
 /**
 * Dependency Graph (ECO-005).
 *
@@ -12481,8 +12856,7 @@ function parseManifest(filePath) {
 	if (filePath.endsWith("pyproject.toml")) return parsePyprojectToml(filePath);
 	if (filePath.endsWith("pom.xml")) return parsePomXml(filePath);
 }
-//#endregion
-//#region src/engine/incremental-analysis.ts
+// src/engine/incremental-analysis.ts
 /**
 * Semantic inputs that affect the full scan beyond individual file content.
 * If any of these changed, an incremental run is NOT safe — a full scan
@@ -12518,8 +12892,7 @@ function isIncrementalSafe(changedFiles) {
 		reasons
 	};
 }
-//#endregion
-//#region src/brand/tokens.ts
+// src/brand/tokens.ts
 /**
 * The single source of brand truth.
 *
@@ -12581,7 +12954,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 +13075,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",
@@ -12787,8 +13178,7 @@ function deriveScoreState(score) {
 		rune: RUNES.critical
 	};
 }
-//#endregion
-//#region src/engine/monorepo-analysis.ts
+// src/engine/monorepo-analysis.ts
 /**
 * Package verdict, derived from the one ScoreState band model (BW-104).
 * These two constants used to be a private copy of the band boundaries;
@@ -12895,8 +13285,7 @@ function configurableAggregation(results, config) {
 		strategy: config.weightingStrategy
 	};
 }
-//#endregion
-//#region src/lib/fs-atomic.ts
+// src/lib/fs-atomic.ts
 /**
 * Atomic file writes (audit S9).
 *
@@ -12979,8 +13368,7 @@ function renameWithWindowsRetry(from, to) {
 		throw err;
 	}
 }
-//#endregion
-//#region src/engine/scan-cache.ts
+// src/engine/scan-cache.ts
 /**
 * Local incremental scan cache (Beta-to-Stable 1.0 plan, M5.2 / A-2).
 *
@@ -13190,8 +13578,7 @@ function createScanCache(root) {
 		}
 	};
 }
-//#endregion
-//#region src/reporter/theme.ts
+// src/reporter/theme.ts
 /**
 * Norse-forge theme system. Pure string-in → string-out helpers.
 * Respects NO_COLOR and non-TTY via `palette(isTTY)` — every renderer
@@ -13291,8 +13678,7 @@ function rgb([r, g, b]) {
 function palette(enabled) {
 	return enabled ? on : off;
 }
-//#endregion
-//#region src/reporter/ui.ts
+// src/reporter/ui.ts
 /**
 * Neutral context for direct calls (tests, library use) and as the
 * safe default when a command runner is invoked without wiring: no
@@ -13317,8 +13703,7 @@ function sectionHeader(title, ui) {
 	const glyph = ui.ascii ? "=" : "▍";
 	return `  ${ui.p.accent(`${glyph} ${title}`)}`;
 }
-//#endregion
-//#region src/forensics/classify.ts
+// src/forensics/classify.ts
 /**
 * Strong-signal marker tables. Kept deliberately narrow: a marker here
 * is a named family fact, not a vibe. Unknown text yields no signal —
@@ -13438,8 +13823,7 @@ function classifyForensicVerdict(signals) {
 		signals: signalCounts
 	};
 }
-//#endregion
-//#region src/forensics/analyze.ts
+// src/forensics/analyze.ts
 const ui$5 = plainContext();
 const MAX_RECORDS = 1e5;
 function analyze(records, source) {
@@ -13574,7 +13958,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`);
@@ -13602,8 +13986,7 @@ function renderFlakyMd(report) {
 	lines.push("");
 	return lines.join("\n");
 }
-//#endregion
-//#region src/forensics/evidence-hygiene.ts
+// src/forensics/evidence-hygiene.ts
 /**
 * Evidence hygiene — secret redaction + control-char sanitization
 * (ENGINE-012).
@@ -13665,8 +14048,7 @@ function sanitizeErrorText(text, options) {
 	if (result.length > maxLength) result = result.slice(0, maxLength) + `[truncated at ${maxLength} chars]`;
 	return result;
 }
-//#endregion
-//#region src/forensics/trace.ts
+// src/forensics/trace.ts
 /**
 * Playwright trace ingester (product-gap master plan §9 R5 / WI-17).
 *
@@ -13859,8 +14241,7 @@ function parseTraceArtifact(bytes, artifactName) {
 	const { actions } = parseTraceNdjson(text);
 	return traceActionsToRecord(actions, artifactName);
 }
-//#endregion
-//#region src/forensics/parse-jest-json.ts
+// src/forensics/parse-jest-json.ts
 function toStatus$2(raw) {
 	switch (raw) {
 		case "passed": return "passed";
@@ -13920,21 +14301,20 @@ function parseJestJson(json) {
 	}
 	return out;
 }
-//#endregion
-//#region src/forensics/parse-junit.ts
-const MAX_INPUT = 20971520;
-function decodeEntities(s) {
+// src/forensics/parse-junit.ts
+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,29 +14335,40 @@ 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);
 		const errors = [];
 		if (failed) {
-			const failRe = /<(?:failure|error)\b([^>]*)>([\s\S]*?)<\/(?:failure|error)\s*>/gi;
-			let failMatch;
-			while ((failMatch = failRe.exec(inner)) !== null) {
-				const attrsStr = failMatch[1] ?? "";
+			const openRe = /<(?:failure|error)\b/gi;
+			const endRe = /<\/(?:failure|error)\s*>/gi;
+			let open;
+			while ((open = openRe.exec(inner)) !== null) {
+				const gt = inner.indexOf(">", open.index);
+				if (gt === -1) break;
+				const attrsStr = inner.slice(open.index, gt);
+				if (attrsStr.endsWith("/")) {
+					openRe.lastIndex = gt + 1;
+					continue;
+				}
+				endRe.lastIndex = gt + 1;
+				const end = endRe.exec(inner);
+				if (end === null) break;
 				const msgAttr = /\smessage\s*=\s*"([^"]*)"/i.exec(attrsStr)?.[1];
-				if (msgAttr) errors.push(sanitizeErrorText(decodeEntities(msgAttr)));
-				const body = failMatch[2]?.trim();
-				if (body && body !== msgAttr) errors.push(sanitizeErrorText(decodeEntities(body)));
+				if (msgAttr) errors.push(sanitizeErrorText(decodeEntities$1(msgAttr)));
+				const body = inner.slice(gt + 1, end.index).trim();
+				if (body && body !== msgAttr) errors.push(sanitizeErrorText(decodeEntities$1(body)));
+				openRe.lastIndex = end.index + end[0].length;
 			}
 			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 = {
@@ -13994,8 +14385,156 @@ function parseJunitXml(xml) {
 	}
 	return out;
 }
-//#endregion
-//#region src/forensics/parse-playwright-json.ts
+// 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 startRe = /<UnitTestResult\b/gi;
+	const starts = [];
+	let s;
+	while ((s = startRe.exec(xml)) !== null) {
+		starts.push(s.index);
+		if (starts.length > 2e5) break;
+	}
+	const resultsEnd = xml.search(/<\/Results>/i);
+	for (let i = 0; i < starts.length; i++) {
+		const start = starts[i];
+		const tagEnd = xml.indexOf(">", start);
+		if (tagEnd === -1) break;
+		const selfClosing = xml[tagEnd - 1] === "/";
+		const attrs = xml.slice(start + 15, selfClosing ? tagEnd - 1 : tagEnd);
+		const next = starts[i + 1] ?? -1;
+		let bodyEnd = next === -1 ? xml.length : next;
+		if (resultsEnd > tagEnd && resultsEnd < bodyEnd) bodyEnd = resultsEnd;
+		const inner = selfClosing ? "" : xml.slice(tagEnd + 1, bodyEnd);
+		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 messageAt = inner.search(/<Message\b/i);
+		const error = messageAt === -1 ? void 0 : messageOf(inner, messageAt);
+		records.push({
+			file: "unknown",
+			title: testName,
+			attempts: [attempt],
+			evidenceKind: "test",
+			...error === void 0 ? {} : { errors: [error] }
+		});
+		if (records.length > 2e5) break;
+	}
+	return records;
+}
+// src/forensics/parse-playwright-json.ts
 const MAX_DEPTH = 32;
 function toStatus$1(raw) {
 	switch (raw) {
@@ -14060,8 +14599,7 @@ function parsePlaywrightJson(json) {
 	walk(root, 0);
 	return out;
 }
-//#endregion
-//#region src/forensics/parse-vitest-json.ts
+// src/forensics/parse-vitest-json.ts
 function toStatus(raw) {
 	switch (raw) {
 		case "passed": return "passed";
@@ -14115,8 +14653,7 @@ function parseVitestJson(json) {
 	}
 	return out;
 }
-//#endregion
-//#region src/forensics/parse-har.ts
+// src/forensics/parse-har.ts
 const MAX_ENTRIES = 2e4;
 function sanitizeTitleUrl(url) {
 	try {
@@ -14201,10 +14738,11 @@ function parseHarJsonDetailed(json) {
 		truncated
 	};
 }
-//#endregion
-//#region src/forensics/run.ts
+// 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 +14942,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"
@@ -14484,8 +15029,7 @@ function loadSuppressions(root, now = /* @__PURE__ */ new Date()) {
 		entries
 	};
 }
-//#endregion
-//#region src/plugins/reserved-prefixes.ts
+// src/plugins/reserved-prefixes.ts
 /**
 * Core-owned rule-ID prefixes that external rule sources (npm plugins,
 * JS modules, JSON manifests) may never claim — one shared law.
@@ -14515,8 +15059,7 @@ function isReservedPrefix(ruleId) {
 	const upper = ruleId.toUpperCase();
 	return RESERVED_PREFIXES.some((p) => upper.startsWith(p));
 }
-//#endregion
-//#region src/plugins/load.ts
+// src/plugins/load.ts
 /**
 * Plugin API (Upgrade-Plan-v3 Phase 6, tier-2 item #1).
 *
@@ -14622,8 +15165,7 @@ function loadPlugins(root, gateOpen = false) {
 	}
 	return result;
 }
-//#endregion
-//#region src/plugins/local-rules.ts
+// src/plugins/local-rules.ts
 /**
 * Local plugin/rule contract (Verification Trust Evolution Plan §18 —
 * Local Extensibility).
@@ -14655,7 +15197,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).
@@ -14935,8 +15477,7 @@ async function loadModuleRules(path, result) {
 		result.rules.push(rule);
 	}
 }
-//#endregion
-//#region src/plugins/trust-gate.ts
+// src/plugins/trust-gate.ts
 /**
 * Plugin trust gate (audit-remediation-master-plan.md, locked decision C2).
 *
@@ -14972,8 +15513,7 @@ function renderGateNotice(skipped) {
 	lines.push("To run them, re-run with --enable-plugins (or set MJOLNIR_ENABLE_PLUGINS=1).", "Declarative JSON rule manifests (mjolnir-rules/*.json) are unaffected — they execute no code.");
 	return lines.join("\n");
 }
-//#endregion
-//#region src/engine/scan-pipeline.ts
+// src/engine/scan-pipeline.ts
 /**
 * Canonical scan pipeline (M6 — blueprint §9.2).
 *
@@ -15001,7 +15541,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 +15569,15 @@ 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 quarantined = rules.filter((r) => tierByRuleId.get(r.id) === "quarantine").map((r) => r.id).sort();
+	const withheldRuleIds = strict ? [] : quarantined;
 	if (!strict) rules = rules.filter((r) => tierByRuleId.get(r.id) !== "quarantine");
+	const rulesWithheld = withheldRuleIds.length;
+	const rulesApplied = rules.length;
 	const pluginMeta = [...plugins.map((p) => ({
 		name: p.name,
 		rules: p.rules.length
@@ -15046,7 +15590,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 +15618,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
@@ -15455,12 +15973,28 @@ function applyPostScanProcessing(findings, workspace, args, hooks, scanRoot, dec
 	const runtimeIncomplete = discoveredReport !== void 0 && discoveredReport.report.analysisComplete !== true;
 	let forensicVerdicts;
 	let evidenceRecords = [];
-	if (discoveredReport && discoveredReport.report.analysisComplete === true) try {
-		evidenceRecords = buildEvidenceRecords(discoveredReport.report, discoveredReport.path);
-		stampRuntimeCorroboration(findings, discoveredReport.report, workspace.root);
-		forensicVerdicts = summarizeForensicVerdicts(discoveredReport.report);
-	} catch {
-		evidenceRecords = [];
+	if (discoveredReport && discoveredReport.report.analysisComplete === true) {
+		const before = findings.map((f) => ({
+			runtimeCorroboration: f.runtimeCorroboration,
+			trustLevel: f.trustLevel
+		}));
+		try {
+			const records = buildEvidenceRecords(discoveredReport.report, discoveredReport.path);
+			stampRuntimeCorroboration(findings, discoveredReport.report, workspace.root);
+			forensicVerdicts = summarizeForensicVerdicts(discoveredReport.report);
+			evidenceRecords = records;
+		} catch {
+			findings.forEach((f, i) => {
+				const prev = before[i];
+				if (prev?.runtimeCorroboration === void 0) delete f.runtimeCorroboration;
+				else f.runtimeCorroboration = prev.runtimeCorroboration;
+				if (prev?.trustLevel === void 0) delete f.trustLevel;
+				else f.trustLevel = prev.trustLevel;
+			});
+			forensicVerdicts = void 0;
+			evidenceRecords = [];
+			recordDegradation("runtime-corroboration-failed");
+		}
 	}
 	return {
 		evidenceRecords,
@@ -15604,6 +16138,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 +16155,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 +16176,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 +16218,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 +16266,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 +16309,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 +16398,9 @@ async function runScan(args, hooks = {}) {
 		parseFallbacks,
 		astFallbackFiles,
 		degradations: summarizeDegradations(degradationsSince(degradationWindow)),
+		rulesApplied,
+		rulesWithheld,
+		...withheldRuleIds.length > 0 ? { withheldRuleIds } : {},
 		scanned,
 		analyzed,
 		testFiles,
@@ -15862,8 +16427,7 @@ async function runScan(args, hooks = {}) {
 	resetTsMorphProject();
 	return result;
 }
-//#endregion
-//#region src/cli-io.ts
+// src/cli-io.ts
 /**
 * The ONE error-to-message derivation in `src/`.
 *
@@ -15940,6 +16504,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 +16551,7 @@ function buildMachineContract(result) {
 		};
 	});
 	return {
-		contractVersion: 1,
+		contractVersion: 2,
 		summary: {
 			digest: `sha256:${digest}`,
 			findings: result.findings.length,
@@ -16004,6 +16572,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 } : {},
@@ -16014,8 +16586,7 @@ function buildMachineContract(result) {
 		...result.forensicVerdicts !== void 0 ? { forensicVerdicts: result.forensicVerdicts } : {}
 	};
 }
-//#endregion
-//#region src/commands/fixture-example.ts
+// src/commands/fixture-example.ts
 /**
 * Shared example-fixture selection for `mjolnir explain` (explain.ts)
 * and the generated rule docs (rule-docs.ts) — one chooser so both
@@ -16045,7 +16616,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 = () => {
@@ -16116,18 +16687,7 @@ function explainRule(ruleId, fixturesRoot) {
 		exampleFixtureRelPath: relative(fixturesRoot, fixturePath).replaceAll("\\", "/")
 	};
 }
-//#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
+// src/engine/resolution.ts
 /** Correlation identity (v1-compatible): ruleId\0file\0message. */
 const fingerprint$1 = findingFingerprint;
 /**
@@ -16147,6 +16707,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",
@@ -16273,16 +16838,15 @@ function diffAgainstBaseline(result, baseline) {
 		unchangedCount
 	};
 }
-//#endregion
-//#region src/commands/verify.ts
+// 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);
@@ -16421,8 +16985,7 @@ function renderTriageWorkflowJson(report) {
 		rows: workflowRows(report)
 	}, null, 2) + "\n";
 }
-//#endregion
-//#region src/commands/pw-report.ts
+// src/commands/pw-report.ts
 const ui = plainContext();
 function summarizePwRun(report) {
 	const slowest = [...report.verdicts].sort((a, b) => b.totalDurationMs - a.totalDurationMs).slice(0, 5).map((v) => ({
@@ -16456,8 +17019,7 @@ function renderPwRunSummary(s) {
 	}
 	return lines.join("\n");
 }
-//#endregion
-//#region src/mcp/server.ts
+// src/mcp/server.ts
 /**
 * MCP stdio transport (blueprint §21 — Phase 4, PURE TRANSPORT).
 *
@@ -16475,7 +17037,10 @@ function renderPwRunSummary(s) {
 * - parameter size caps; ONE scan in flight (serialized queue) reusing
 *   the pipeline's own budgets; zero network (no fetches anywhere); no
 *   shell execution beyond Mjölnir's own verbs.
-* - filesystem boundary = scan target + `.mjolnir/` (same as CLI).
+* - filesystem boundary: the tools are read-only, and with no further
+*   configuration they accept any path the parent process passes (the
+*   parent is the trust boundary). `MJOLNIR_WORKSPACE_ROOT` confines every
+*   path argument to that directory, symlinks resolved.
 * - the plugin trust gate applies unchanged (--enable-plugins is NOT
 *   exposed over MCP: tools run with the gate CLOSED unless the server
 *   was started with MJOLNIR_ENABLE_PLUGINS=1 in its own environment).
@@ -16485,12 +17050,27 @@ const MAX_PARAM_BYTES = 65536;
 const MAX_DURATION_MS = 36e5;
 const DEFAULT_MAX_DURATION_MS = 6e5;
 const PROTOCOL_VERSION = "2025-06-18";
-const CONFIGURED_ROOT = process.env.MJOLNIR_WORKSPACE_ROOT ? resolve(process.env.MJOLNIR_WORKSPACE_ROOT) : null;
+/** The real path of `p`, or its lexical resolution when it does not exist. */
+function realOrResolved(p) {
+	try {
+		return realpathSync.native(resolve(p));
+	} catch {
+		return resolve(p);
+	}
+}
+/**
+* The optional workspace root. When set, every path argument must resolve
+* INSIDE it after symlinks are followed.
+*
+* Unset is open by design and is documented that way in the header: the MCP
+* tools are read-only and the stdio parent is the trust boundary. Setting
+* `MJOLNIR_WORKSPACE_ROOT` is how a host confines them.
+*/
+const CONFIGURED_ROOT = process.env.MJOLNIR_WORKSPACE_ROOT ? realOrResolved(process.env.MJOLNIR_WORKSPACE_ROOT) : null;
 function isPathAllowed(path) {
 	if (!CONFIGURED_ROOT) return true;
-	const candidate = resolve(path);
-	const rel = relative(CONFIGURED_ROOT, candidate);
-	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+	const rel = relative(CONFIGURED_ROOT, realOrResolved(path));
+	return rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
 }
 /** JSON-RPC error codes (subset used here). */
 const MCP_ERRORS = {
@@ -16558,7 +17138,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 +17150,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 +17174,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 +17367,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({
@@ -16967,8 +17547,7 @@ async function handleMcpMessage(msg) {
 		}
 	};
 }
-//#endregion
-//#region src/mcp/transport.ts
+// src/mcp/transport.ts
 /**
 * MCP stdio transport loop (blueprint §21 — the framing around the
 * pure-transport server).
@@ -17065,8 +17644,7 @@ async function handleStdioLine(line, write) {
 	}
 	write(`${JSON.stringify(response)}\n`);
 }
-//#endregion
-//#region src/integrations/sentry.ts
+// src/integrations/sentry.ts
 /**
 * Sentry crash reporting — opt-in, and inert unless a DSN is configured.
 *
@@ -17192,8 +17770,7 @@ async function flushSentry(timeoutMs = FLUSH_TIMEOUT_MS) {
 		return false;
 	}
 }
-//#endregion
-//#region src/mcp/stdio.ts
+// src/mcp/stdio.ts
 /**
 * The standalone MCP stdio binary (blueprint §21), built to
 * `dist/mcp/stdio.mjs` and run by `npm run mcp`.
@@ -17218,7 +17795,6 @@ runStdioTransport(process.stdin, process.stdout).then(() => process.exit(0)).cat
 	process.stderr.write(`mjolnir mcp fatal: ${err instanceof Error ? err.message : err}\n`);
 	process.exitCode = 20;
 });
-//#endregion
 export {};
 
 //# sourceMappingURL=stdio.mjs.map