mjolnir-qa 1.0.1 → 1.0.3

package/dist/cli.mjs

@@ -119,12 +119,13 @@ const DEDUCTIONS = {
 */
 const EVIDENCE_CORE_VERSION = "evidence-core@1";
 /** Deterministic canonical order: file → line (absent last) → title → source. */
-function compareRecords(a, b) {
+function compareEvidenceRecords(a, b) {
 	if (a.file !== b.file) return a.file < b.file ? -1 : 1;
 	const la = a.line ?? Number.POSITIVE_INFINITY;
 	const lb = b.line ?? Number.POSITIVE_INFINITY;
 	if (la !== lb) return la - lb;
 	if (a.title !== b.title) return a.title < b.title ? -1 : 1;
+	if (a.source !== b.source) return a.source < b.source ? -1 : 1;
 	return 0;
 }
 function normalizeOne(report, artifact, v) {
@@ -159,7 +160,7 @@ function normalizeOne(report, artifact, v) {
 * record list — report verdict order never leaks into the output.
 */
 function buildEvidenceRecords(report, artifact) {
-	return report.verdicts.map((v) => normalizeOne(report, artifact, v)).sort(compareRecords);
+	return report.verdicts.map((v) => normalizeOne(report, artifact, v)).sort(compareEvidenceRecords);
 }
 /**
 * The test whose declaration span contains `line` — the exact matching
@@ -179,8 +180,8 @@ function findTestAt(records, file, line) {
 	for (const r of inFile) if (r.line === void 0) return void 0;
 	let match;
 	for (const r of inFile) {
-		const rLine = r.line;
-		if (rLine <= line && (match === void 0 || match.line <= rLine)) match = r;
+		const l = r.line;
+		if (l <= line && (match === void 0 || match.line <= l)) match = r;
 	}
 	return match;
 }
@@ -3321,6 +3322,10 @@ const focusedTestCommitted = defineRule({
 	falsePositiveRisk: "low",
 	autofix: true,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: ".only/focus is runner skip-scheduling state; the detector matches the runner's own member-call tokens (.only/.fit/fdescribe) on the code-only text — lexical precision equals the AST call-shape here, and the §13.2 fallback keeps parity"
+	},
 	introduced: "0.1.0",
 	tier: "quarantine",
 	suiteInvalidating: true,
@@ -3381,6 +3386,10 @@ const skippedTest = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "skip/xfail/ignore are runner skip-state annotations whose forms are runner API tokens (it.skip, xit, t.skip, @unittest.skip); the detector matches those exact tokens on the code-only text"
+	},
 	introduced: "0.1.0",
 	tier: "quarantine",
 	run(ctx) {
@@ -3498,6 +3507,10 @@ const noAssertions = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "assertion-less test bodies are runner-outcome semantics (the runner reports a pass that proves nothing); the detector matches the test-def plus body shapes on the code-only text"
+	},
 	introduced: "0.1.0",
 	tier: "quarantine",
 	run(ctx) {
@@ -3572,6 +3585,10 @@ const hardSleep = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "hard-sleep is behavioral wait-shape matching (the wait call plus its interaction context), not a single node; the detector's pattern+wait-shape oracle is the recorded design (§12.1), and the hard-sleep family's structural path carries the depth where available"
+	},
 	detectionNotes: "regex pattern + behavioral wait-shape matching",
 	introduced: "0.1.0",
 	tier: "extended",
@@ -3637,6 +3654,10 @@ const retryAbuse = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "retry abuse is the runner's retry contract (jest.retries, vitest retry, playwright retries); the detector matches the runner's retry API tokens across runners — each an exact key"
+	},
 	introduced: "0.1.0",
 	tier: "quarantine",
 	run(ctx) {
@@ -3698,6 +3719,10 @@ const emptyTestBody = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "empty test bodies are runner-outcome semantics; the detector matches the test-def plus empty-body shapes on the code-only text — the AST body-shape is the same predicate"
+	},
 	introduced: "0.1.0",
 	tier: "quarantine",
 	overlapWith: ["QA-TEST-003"],
@@ -3749,6 +3774,10 @@ const tautologicalAssertion = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "tautological assertions (x === x, expect(true)) are assertion-semantics on the code-only text; the detector matches the tautology shapes after comment stripping — the AST call-shape is the same predicate"
+	},
 	detectionNotes: "AST-stripped text pattern",
 	introduced: "0.1.0",
 	tier: "quarantine",
@@ -3828,6 +3857,10 @@ const unawaitedPromiseAssertion = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "un-awaited promise assertions are runner async semantics; the detector matches the assertion-call shapes inside promise chains on the code-only text — the async contract is runner behavior"
+	},
 	introduced: "0.2.0",
 	tier: "quarantine",
 	run(ctx) {
@@ -3927,6 +3960,10 @@ const commentedOutTest = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "lexical-artifact",
+		detail: "commented-out assertions are lexical artifacts — the comment-wrapped assertion text is the finding itself; the detector matches the shapes on the raw text"
+	},
 	detectionNotes: "regex heuristic",
 	introduced: "0.2.0",
 	tier: "extended",
@@ -4172,6 +4209,10 @@ const committedDebugArtifacts = defineRule({
 	falsePositiveRisk: "low",
 	autofix: true,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "exact-key-match",
+		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",
 	run(ctx) {
@@ -4224,6 +4265,10 @@ const brittleSelectors = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "string-content-defect",
+		detail: "brittle selectors ARE string arguments (css=/xpath=/nth-child shapes) — the code-text masking that protects other rules deliberately excludes string content here; the detector reads the string shapes directly (inside-string oracle)"
+	},
 	detectionNotes: "regex pattern + inside-string oracle",
 	introduced: "0.1.0",
 	tier: "quarantine",
@@ -4521,6 +4566,10 @@ const swallowedExitCode = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "shell-string-in-config",
+		detail: "exit-code swallowing lives inside workflow run: strings (shell scripts embedded in YAML); the YAML statement IS a string literal — a shell syntax tree of a YAML value adds parsing without adding classification power"
+	},
 	introduced: "0.1.0",
 	tier: "extended",
 	detectorRevision: 2,
@@ -4573,6 +4622,10 @@ const retryMasking = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "retry masking is defined by the runner's retry semantics, which no language syntax tree represents; the detector matches the runner's own retry keys in workflow YAML where statements are shell strings"
+	},
 	introduced: "0.1.0",
 	tier: "extended",
 	detectorRevision: 2,
@@ -4756,6 +4809,10 @@ const reportNeverGenerated = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "report generation is a runner side effect of the workflow step sequence, not a syntax tree property; the detector reads the workflow step graph, whose statements are already literal text"
+	},
 	introduced: "0.1.0",
 	tier: "quarantine",
 	detectorRevision: 2,
@@ -4856,6 +4913,10 @@ const alwaysSuccessStep = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "always()-success is a workflow-step outcome contract, not a code construct; the detector matches the step's run/if keys, which are string fields of the YAML config surface"
+	},
 	introduced: "0.1.0",
 	tier: "quarantine",
 	detectorRevision: 2,
@@ -5102,6 +5163,10 @@ const pyNoAssertions = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "assertion-less pytest bodies are runner-outcome semantics (the runner reports a pass that proves nothing); the detector matches the test-def plus body shapes on the code-only text — pytest's pass contract is runner behavior"
+	},
 	introduced: "0.3.0",
 	tier: "quarantine",
 	detectorRevision: 3,
@@ -5185,6 +5250,10 @@ const pyHardSleep = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "exact-key-match",
+		detail: "time.sleep(n) is an exact stdlib token with a numeric argument; the detector matches the call identifier on the code-only text — closed token, unique to the defect"
+	},
 	introduced: "0.3.0",
 	tier: "extended",
 	overlapWith: ["QA-PY-102"],
@@ -5230,6 +5299,10 @@ const pySkippedTest = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "pytest.mark.skip/xfail are runner marker decorators — exact runner tokens; a syntax tree re-derives the same call shape with no added classification power"
+	},
 	introduced: "0.3.0",
 	run(ctx) {
 		const text = ctx.codeText ?? ctx.text;
@@ -5286,6 +5359,10 @@ const pyTautological = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "tautological assertions in Python (assert x == x) are assertion-semantics on the code-only text; the detector matches the tautology shapes — the AST re-derives the same comparison"
+	},
 	introduced: "0.3.0",
 	tier: "quarantine",
 	run(ctx) {
@@ -5340,6 +5417,10 @@ const pyFocusedTest = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		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",
 	suiteInvalidating: true,
@@ -5392,6 +5473,10 @@ const pyRaisesWithoutMatch = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "pytest.raises without match is a runner exception-contract semantic; the detector matches the raises-call plus its argumentless form — the runner's exception contract, not a syntax property"
+	},
 	introduced: "0.3.0",
 	tier: "quarantine",
 	detectorRevision: 3,
@@ -5471,6 +5556,10 @@ const pyCommentedOutTest = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "lexical-artifact",
+		detail: "commented-out test code is a lexical artifact by definition — the text IS the finding (comment-wrapped test bodies); the detector matches the commented shapes on the raw text, which is where the artifact lives"
+	},
 	detectionNotes: "regex heuristic",
 	introduced: "0.3.0",
 	tier: "core",
@@ -5516,6 +5605,10 @@ const pyBareTruthinessAssert = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "bare truthiness asserts (assert obj) are assertion-semantics on the code-only text; the detector matches the bare-assert shapes — the AST re-derives the same call"
+	},
 	introduced: "0.3.0",
 	tier: "quarantine",
 	detectorRevision: 3,
@@ -5584,6 +5677,10 @@ const pyMutableFixture = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		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",
 	run(ctx) {
@@ -5632,6 +5729,10 @@ const pwWaitForTimeout = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "family-fallback-lockstep",
+		detail: "the hard-sleep family's §13.2 structural path (AST hook) carries the depth where a tree is available; this lexical path is the mandatory deterministic fallback kept in lockstep — the family's depth is real, the regex is its degraded mode"
+	},
 	introduced: "0.3.0",
 	overlapWith: ["QA-TEST-004"],
 	run(ctx) {
@@ -5675,6 +5776,10 @@ const pwWaitForLoadEvent = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "exact-key-match",
+		detail: "waitForLoadState('load') is an exact Playwright token plus a closed argument enum; the detector matches the call plus its argument — the AST re-derives the same call shape"
+	},
 	introduced: "0.3.0",
 	tier: "quarantine",
 	detectorRevision: 2,
@@ -5727,6 +5832,10 @@ const pwDeepFrameLocator = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "exact-key-match",
+		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",
 	run(ctx) {
@@ -5774,6 +5883,10 @@ const pwSerialNoJustification = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "fullyParallel/serial are runner scheduling keys on the config and describe blocks; the detector matches the runner's exact API tokens — the semantics are scheduling, not syntax"
+	},
 	introduced: "0.3.0",
 	tier: "core",
 	run(ctx) {
@@ -5827,6 +5940,10 @@ const pwConfigRetryAbuse = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "retries in playwright.config.* is a runner top-level option, not a syntax node; the detector reads the config surface whose statements are object-literal keys — exact-key precision"
+	},
 	detectionNotes: "regex heuristic",
 	introduced: "0.3.0",
 	tier: "core",
@@ -5888,6 +6005,10 @@ const pwNoTraceOnRetry = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "trace/reporter capture is runner lifecycle state set in the config file; the detector reads the config surface's keys and enum values, which are exact matches — a syntax tree adds no semantic the config text lacks"
+	},
 	detectionNotes: "regex heuristic",
 	introduced: "0.3.0",
 	tier: "extended",
@@ -5941,6 +6062,10 @@ const pwNoProjectSplit = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "project split is a runner config concept (projects array arrangement); the detector reads playwright.config.* keys (adapter-gated), whose object-literal shape is exact-match text"
+	},
 	detectionNotes: "regex heuristic over playwright.config.* (adapter-gated)",
 	introduced: "0.3.0",
 	detectorRevision: 2,
@@ -5991,6 +6116,10 @@ const pwTrialMisuse = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "exact-key-match",
+		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",
 	run(ctx) {
@@ -6035,6 +6164,10 @@ const pwStorageStateNoExpiry = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "exact-key-match",
+		detail: "storageState is an exact Playwright config/use option token; the detector matches the option key and its value shapes — closed config surface"
+	},
 	introduced: "0.3.0",
 	run(ctx) {
 		const text = ctx.text;
@@ -6079,6 +6212,10 @@ const pwGlobalSetupSharedState = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "globalSetup/globalTeardown are runner lifecycle hooks declared in the config file; the detector matches those exact keys — the defect is the runner's execution order, not a code shape"
+	},
 	detectionNotes: "regex heuristic",
 	introduced: "0.3.0",
 	run(ctx) {
@@ -6131,6 +6268,10 @@ const pwSharedPage = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "page reuse across tests is runner fixture-lifecycle semantics; the detector matches the page-consumption shapes against the test boundaries — the lifecycle is runner behavior"
+	},
 	introduced: "0.3.0",
 	tier: "quarantine",
 	run(ctx) {
@@ -6178,6 +6319,10 @@ const qaPw140 = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "exact-key-match",
+		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",
 	run(ctx) {
@@ -6245,6 +6390,10 @@ const hardcodedBaseUrl = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "string-content-defect",
+		detail: "hardcoded environment URLs are string literals (http(s):// shapes); the detector reads the string-content shapes the code-text mask preserves for exactly this defect class"
+	},
 	introduced: "0.3.0",
 	tier: "quarantine",
 	run(ctx) {
@@ -6295,6 +6444,10 @@ const envCoupling = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "absence-aggregate",
+		detail: "environment-guard absence over the suite is an aggregate property; the detector aggregates the suite's guard shapes — the defect is what the suite lacks, not a node it has"
+	},
 	detectionNotes: "regex heuristic",
 	introduced: "0.2.0",
 	tier: "quarantine",
@@ -6369,6 +6522,10 @@ const pwRetryMaskingNoForensics = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "retry triage is the runner's retry loop interacting with the reporter config; the detector reads both config keys and the triage call shape — the semantics live in runner behavior"
+	},
 	detectionNotes: "regex heuristic",
 	introduced: "0.3.8",
 	tier: "extended",
@@ -6421,6 +6578,10 @@ const pwBlanketRouteMock = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "absence-aggregate",
+		detail: "blanket route interception is an aggregate of route calls across the suite; the detector aggregates the route-call shapes — the finding is the pattern's breadth, not one call"
+	},
 	detectionNotes: "regex heuristic",
 	introduced: "0.3.8",
 	tier: "extended",
@@ -6474,6 +6635,10 @@ const pwNoFailureArtifacts = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "absence-aggregate",
+		detail: "artifact-capture absence (no trace/video/screenshot anywhere in the suite) is a directory-level aggregate; the detector aggregates over the suite's shapes — absence, not presence"
+	},
 	detectionNotes: "regex heuristic",
 	introduced: "0.3.8",
 	tier: "extended",
@@ -6524,6 +6689,10 @@ const pwSingleBrowserMatrix = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "absence-aggregate",
+		detail: "single-browser coverage absence is a config/projects aggregate property; the detector reads the projects arrangement across the config — no single node constitutes the finding"
+	},
 	detectionNotes: "regex heuristic",
 	introduced: "0.3.8",
 	tier: "extended",
@@ -6607,6 +6776,10 @@ const pwLocatorNormalize = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "string-content-defect",
+		detail: "CSS/XPath string selectors are string-argument shapes (css=/xpath= engines, bare id/class/attr CSS, nth-child); the detector classifies the string shapes directly"
+	},
 	detectionNotes: "string-selector shapes (css=/xpath= engines, bare id/class/attr CSS, nth-child) inside .locator()/waitForSelector()/page.$ APIs, on the RAW text view (the selector text lives inside string literals, which the code-only view blanks)",
 	introduced: "0.6.0",
 	tier: "quarantine",
@@ -6666,6 +6839,10 @@ const pwCodegenArtifact = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "lexical-artifact",
+		detail: "the codegen recorder's default title ('test', 'test 1', …) committed is a recording artifact — the default-title string is the finding; the detector matches the recorder's exact title shapes"
+	},
 	detectionNotes: "the codegen recorder's default test title ('test', 'test 1', 'test 2', …) committed verbatim, on the RAW text view (the title is a string literal)",
 	introduced: "0.6.0",
 	tier: "quarantine",
@@ -6712,6 +6889,10 @@ const pyPwSyncAsyncMix = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "family-fallback-lockstep",
+		detail: "the hard-sleep family's Python sync/async variant: the family's structural path carries the depth; this variant's lexical path is the lockstep fallback (async-mix shapes across the sync/async boundary)"
+	},
 	detectionNotes: "regex heuristic",
 	introduced: "0.3.8",
 	run(ctx) {
@@ -6757,6 +6938,10 @@ const pyPwWaitForTimeout = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "exact-key-match",
+		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",
 	run(ctx) {
@@ -6802,6 +6987,10 @@ const pyPwNoAssertions = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "Playwright test bodies without assertions are runner-outcome semantics; the detector matches the test-def plus body shapes on the code-only text"
+	},
 	detectionNotes: "regex heuristic",
 	introduced: "0.3.8",
 	tier: "quarantine",
@@ -6878,6 +7067,10 @@ const jvDisabledTest = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "exact-key-match",
+		detail: "@Disabled/@Ignore are exact JUnit/TestNG annotation tokens; the detector matches the annotation identifier — annotation shapes are closed token sets where lexical and structural match coincide"
+	},
 	introduced: "0.3.8",
 	tier: "core",
 	run(ctx) {
@@ -7937,6 +8130,10 @@ const csSkippedTest = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "exact-key-match",
+		detail: "[Ignore]/[Fact(Skip=…)] are exact xUnit/NUnit/MSTest attribute tokens; the detector matches the attribute identifiers — closed token sets where lexical precision equals structural"
+	},
 	introduced: "0.3.8",
 	run(ctx) {
 		const text = ctx.codeText ?? ctx.text;
@@ -8290,6 +8487,10 @@ const cypCyWait = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "cy.wait(numeric) is a Cypress runner wait contract; the detector matches the member-call token with a numeric-literal argument on the code-only text — alias waits (cy.wait('@…')) are structurally distinct and excluded by the argument shape"
+	},
 	detectionNotes: "cy.wait with a numeric-literal argument only — alias waits (cy.wait('@…')) are the legitimate routed-request form and never fire",
 	introduced: "0.6.0",
 	tier: "extended",
@@ -8362,6 +8563,10 @@ const cypFocusedTest = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "Cypress .only is the runner's focus token; the detector matches the it/describe/context .only member-call shape on the code-only text — exact-key precision"
+	},
 	detectionNotes: "it/describe/context .only member-call shape on the code-only text view",
 	introduced: "0.6.0",
 	tier: "quarantine",
@@ -8428,6 +8633,10 @@ const cypConfigSecurity = defineRule({
 	falsePositiveRisk: "low",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "exact-key-match",
+		detail: "chromeWebSecurity:false is an exact config key/value pair inside cypress.config.*; the detector matches the key and value literally — the config surface's statements are the finding"
+	},
 	detectionNotes: "positive match on chromeWebSecurity:false inside cypress.config.* (the config is the artifact — no heuristic)",
 	introduced: "0.6.0",
 	tier: "quarantine",
@@ -8535,6 +8744,10 @@ const seJavaSleepLookup = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "the Selenium family's variants (QA-SE-001/002/003): the defect is the SEQUENCE sleep-then-interact — runner timing semantics, not a single node; the detector matches the sleep token followed by a lookup within the recorded window"
+	},
 	detectionNotes: "sequence shape: Thread.sleep followed by a findElement/interaction call within 3 lines (code-only view)",
 	introduced: "0.6.0",
 	tier: "quarantine",
@@ -8560,6 +8773,10 @@ const seCSharpSleepLookup = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "the Selenium family's variants (QA-SE-001/002/003): the defect is the SEQUENCE sleep-then-interact — runner timing semantics, not a single node; the detector matches the sleep token followed by a lookup within the recorded window"
+	},
 	detectionNotes: "sequence shape: Thread.Sleep/Task.Delay followed by a FindElement/interaction call within 3 lines (code-only view)",
 	introduced: "0.6.0",
 	tier: "quarantine",
@@ -8585,6 +8802,10 @@ const sePythonSleepLookup = defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "the Selenium family's variants (QA-SE-001/002/003): the defect is the SEQUENCE sleep-then-interact — runner timing semantics, not a single node; the detector matches the sleep token followed by a lookup within the recorded window"
+	},
 	detectionNotes: "sequence shape: time.sleep followed by a find_element/interaction call within 3 lines (code-only view)",
 	introduced: "0.6.0",
 	tier: "quarantine",
@@ -8623,6 +8844,7 @@ function definePatternFamily(opts) {
 		falsePositiveRisk: v.falsePositiveRisk ?? opts.falsePositiveRisk,
 		autofix: opts.autofix ?? false,
 		detectionStrategy: v.detectionStrategy ?? opts.detectionStrategy ?? "LEXICAL",
+		...v.strategyJustification ?? opts.strategyJustification ? { strategyJustification: v.strategyJustification ?? opts.strategyJustification } : {},
 		...v.detectionNotes !== void 0 ? { detectionNotes: v.detectionNotes } : { ...opts.detectionNotes !== void 0 ? { detectionNotes: opts.detectionNotes } : {} },
 		...opts.introduced ? { introduced: opts.introduced } : {},
 		...v.tier !== void 0 ? { tier: v.tier } : { ...opts.tier !== void 0 ? { tier: opts.tier } : {} },
@@ -8775,6 +8997,10 @@ const hardSleepFamily = definePatternFamily({
 	why: WHY,
 	falsePositiveRisk: "low",
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "family-fallback-lockstep",
+		detail: "the hard-sleep family's Java variant (QA-JV-102): the family's structural path carries the depth where a tree is available; this lexical path is the mandatory deterministic fallback kept in lockstep (§13.2)"
+	},
 	introduced: "0.3.8",
 	tier: "extended",
 	useCodeText: true,
@@ -8824,6 +9050,10 @@ const networkIdleFamily = definePatternFamily({
 	why: "Analytics, websockets, and polling make network idle never fire or fire randomly — a documented source of Playwright flakes.",
 	falsePositiveRisk: "low",
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "the network-idle family's variants (QA-JV-107/QA-CS-107/QA-PY-107): networkidle waits are runner timing semantics; the detector matches the runner's wait tokens — exact keys"
+	},
 	introduced: "0.4.0",
 	useCodeText: false,
 	variants: [
@@ -8899,6 +9129,10 @@ const hardcodedUrlFamily = definePatternFamily({
 	why: "Absolute URLs break when environments change and can hit production by accident from a CI runner.",
 	falsePositiveRisk: "low",
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "string-content-defect",
+		detail: "the hardcoded-url family's variants (QA-JV-108/QA-CS-108/QA-PY-108): hardcoded URLs are string literals; the detector matches the http(s):// string shapes — the URL lives in the string, not the syntax tree"
+	},
 	introduced: "0.4.0",
 	useCodeText: false,
 	variants: [{
@@ -8929,6 +9163,10 @@ const sharedPageFamily = definePatternFamily({
 	why: "A shared Page/Browser leaks cookies, localStorage, and navigation state between tests — failures become order-dependent and impossible to reproduce in isolation.",
 	falsePositiveRisk: "medium",
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		detail: "the shared-page family's variants (QA-JV-104/QA-CS-104/QA-PY-106): page/fixture reuse across tests is runner fixture-lifecycle semantics; the detector matches the consumption shapes against test boundaries"
+	},
 	introduced: "0.4.0",
 	useCodeText: true,
 	variants: [
@@ -9004,6 +9242,10 @@ function makeBrittleSelectors(id, appliesTo, ext, languages, frameworks, pattern
 		falsePositiveRisk: "medium",
 		autofix: false,
 		detectionStrategy: "LEXICAL",
+		strategyJustification: {
+			reasonCode: "string-content-defect",
+			detail: "the brittle-selector family's variants (QA-JV-106/QA-CS-106/QA-PY-104): selector defects are string-argument shapes (xpath=/nth-child/absolute-path); the detector classifies the string shapes the code-text mask preserves for this class"
+		},
 		introduced: "0.4.0",
 		tier: "quarantine",
 		detectorRevision: 2,
@@ -9100,6 +9342,10 @@ const retryMaskingFamily = [defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		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",
 	run(ctx) {
@@ -9153,6 +9399,10 @@ const retryMaskingFamily = [defineRule({
 	falsePositiveRisk: "medium",
 	autofix: false,
 	detectionStrategy: "LEXICAL",
+	strategyJustification: {
+		reasonCode: "runner-semantic",
+		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: "extended",
 	run(ctx) {
@@ -9827,6 +10077,237 @@ function createScanCache(root) {
 	};
 }
 //#endregion
+//#region src/brand/tokens.ts
+/**
+* The single source of brand truth.
+*
+* Every colour, typeface and motion constant Mjölnir shows a human —
+* terminal, README SVGs, demo video, website, docs, badges — resolves to
+* a value in this file. Nothing else may define one.
+*
+* WHY THIS EXISTS. Before it, the palette existed in six independent
+* copies: `site/.vitepress/theme/styles/vars.css`, `NORSE` in
+* `src/reporter/theme.ts`, `scripts/readme-svg.ts`,
+* `scripts/video/terminal-page.ts`, `scripts/generate-readme-architecture.ts`
+* and the table in `assets/brand/README.md`. Exactly one pair of those
+* was guarded (site-doctor Check 8, doc ↔ vars.css). The unguarded edges
+* are where the shipped surfaces drifted apart: the terminal and the site
+* disagreed on six semantic roles, the architecture diagram invented its
+* own neutral ramp, and the README badges still carried a palette retired
+* two releases earlier. `scripts/brand-doctor.mjs` now checks every edge
+* against this file.
+*
+* PURITY. Pure data. No I/O, no rendering, no environment access, no
+* imports, no logic. Consumers convert (hex → ANSI triplet, hex → CSS)
+* themselves. Same reason `score-state.ts` is pure: it makes the whole
+* thing golden-testable and safe to ship inside the npm package, where
+* it costs a few hundred bytes and replaces values the package already
+* carried anyway.
+*
+* DERIVATION. The palette is the one derived from the logo in PR #20
+* (brushed steel and forge gold under an aurora, over midnight iron).
+* Where the terminal disagreed with it, the terminal converges — see
+* `PENDING_TERMINAL` below. Full rationale: `assets/brand/README.md`.
+*
+* ACCESSIBILITY. Every foreground token in `BRAND` meets WCAG AA
+* (≥ 4.5:1) against every surface token it is allowed to sit on. That is
+* not a claim, it is `brand-doctor` rule 8, which computes the ratios.
+* The weakest legal pairing is `steelDim` on `ink800` at 5.00:1.
+*/
+/**
+* The two brand hues plus the neutral they sit on.
+*
+* GOLD IS SCARCE. It means forged / certified / earned / decisive — the
+* primary mark, the FORGED state, one call to action. It is not a paint
+* bucket: gold as default text, default border or default heading is a
+* brand-doctor finding, not a style choice.
+*
+* AURORA is verification energy — the secondary, and the hue that marks
+* the runtime half of the trust ladder.
+*/
+const BRAND = {
+	gold: "#C19A34",
+	goldBright: "#E6BD57",
+	goldHot: "#F4DC9C",
+	/** Pressed / deepest gold — the only step dark enough to carry white. */
+	goldDeep: "#A5811C",
+	aurora: "#37ABBD",
+	auroraBright: "#45C1D4",
+	auroraCyan: "#5CBDE0",
+	steel: "#C8CBCF",
+	steelDim: "#8B939D"
+};
+/**
+* Midnight iron. One ramp, four steps, darkest first.
+*
+* `terminal` and `terminalBar` share one tone deliberately: the window's
+* only seam is a hairline ring and an inset shadow, never a second fill.
+* `chromeDot` is the three window dots — see the note on
+* `PENDING_TERMINAL.chromeDots` for why they are no longer red/amber/green.
+*/
+const SURFACE = {
+	ink950: "#0A1119",
+	ink900: "#0C1420",
+	ink850: "#111A29",
+	ink800: "#18243A",
+	/** Raised panel (cards, elevated surfaces). */
+	panel: "#141F33",
+	/** Soft fill (inline code, quiet chips). */
+	soft: "#1A2740",
+	/** Terminal body — the deepest tone, so a terminal reads as recessed. */
+	terminal: "#0A1119",
+	/** Terminal title bar — the same tone; the seam is shadow, not colour. */
+	terminalBar: "#0A1119",
+	/** The three window dots. One neutral, not a traffic light. */
+	chromeDot: "#18243A"
+};
+const TEXT = {
+	primary: "#EAEEF5",
+	secondary: "#ABB6C6",
+	muted: "#8B939D",
+	/** Ink for text set ON gold (buttons, the FORGED chip). 7.17:1 on `gold`. */
+	onGold: "#0A1119"
+};
+/**
+* Non-score status. `ok` is the one green in the system and it is NOT a
+* score colour — it survives only for contexts with no worthiness
+* meaning ("autofix applied", "analysis complete"). A green score would
+* say "your software is fine", which is the exact claim this product
+* refuses to make.
+*/
+const STATUS = {
+	ok: "#4FB477",
+	info: "#5CC4E0",
+	warning: "#E6BD57",
+	error: "#EC6B66"
+};
+/**
+* The four ScoreState bands plus the unmeasured state. Band thresholds
+* and runes live in `src/reporter/score-state.ts`, which stays free of
+* colour — it emits a palette KEY and each surface resolves it here.
+*
+* `unmeasured` is steel-dim on purpose. UNKNOWN is a legitimate answer,
+* not a failure: colouring it red would make "we did not measure this"
+* look like "this is broken", which is precisely the dishonesty the
+* north-star law exists to prevent.
+*/
+const SCORE = {
+	critical: "#EC6B66",
+	warning: "#E6BD57",
+	trusted: "#5CC4E0",
+	forged: "#F4DC9C",
+	unmeasured: "#8B939D"
+};
+/**
+* E0 → E1 → E2 is a certainty ramp, and it is deliberately HUE-FREE.
+*
+* Evidence level says how sure we are, not whether the news is good. A
+* deterministic proof (E2) is a defect we are certain about — painting
+* it gold or green would read as an achievement. So certainty is carried
+* by brightness alone, and the *shape* does the real work:
+*
+*     E0  open ring        observation, no weight
+*     E1  half-filled      pattern evidence, half weight
+*     E2  sealed           deterministic proof, full weight
+*
+* Colour never carries this alone (R11): the geometry is the signal and
+* survives `--ascii`, `NO_COLOR` and monochrome print.
+*/
+const EVIDENCE = {
+	e0: "#8B939D",
+	e1: "#ABB6C6",
+	e2: "#EAEEF5"
+};
+/**
+* L0–L5, and the most important boundary in the product.
+*
+* L0–L2 are STATIC: the neutral steel ramp, brightening to the static
+* ceiling at L2. L3–L5 require a real run, and the hue changes to aurora
+* exactly there. The boundary is a hue break, not a gradient step,
+* because it is a change of kind and not of degree — a static-only
+* finding can never climb past L2, however confident it is.
+*
+* Every surface that draws the ladder must draw that break.
+*/
+const TRUST = {
+	l0: "#8B939D",
+	l1: "#ABB6C6",
+	l2: "#C8CBCF",
+	l3: "#37ABBD",
+	l4: "#45C1D4",
+	l5: "#5CC4E0"
+};
+const TINT = {
+	gold: {
+		fill: "#F6EBCC",
+		stroke: "#7A5F16",
+		text: "#4A3A0E"
+	},
+	aurora: {
+		fill: "#D9F0F4",
+		stroke: "#1F6F7C",
+		text: "#10353C"
+	},
+	error: {
+		fill: "#FADEDD",
+		stroke: "#A83A35",
+		text: "#4E1B19"
+	},
+	/** The unmeasured / unknown state. Neutral, never the error tint. */
+	neutral: {
+		fill: "#E4E7EB",
+		stroke: "#5C646E",
+		text: "#262B31"
+	},
+	ok: {
+		fill: "#DCF0E4",
+		stroke: "#276B45",
+		text: "#163A26"
+	}
+};
+/**
+* The score bands as the badge Mjölnir itself generates renders them.
+*
+* These are DEEPER than the score tokens on purpose, and it is not a
+* style preference: shields.io sets the message text in white and gives
+* you no say in it. `score.forged` (#F4DC9C) under white text measures
+* 1.35:1 — an unreadable badge, shipped to look on-brand. The brand's
+* own deep steps put every band between 4.9 and 6.3:1.
+*
+* What they replace was worse than off-brand, it was wrong:
+*
+*   band        was              rendered as        white-on   now       white-on
+*   ────────────────────────────────────────────────────────────────────────────
+*   0-49        `red`            #dd4343            4.24       #A83A35   6.32
+*   50-79       `yellow`         #d8b800            1.95       #7A5F16   6.04
+*   80-99       `important`      #ea7233  ORANGE    3.02       #1F6F7C   5.80
+*   100         `success`        #44bb00  GREEN     2.51       #8A6D1E   4.90
+*   unmeasured  `lightgrey`      #939393            3.07       #5C646E   5.99
+*
+* Two of those were defects, not preferences. `success` is green, and
+* green is not a score colour here — a 100 badge said "your software is
+* fine", which is the one claim this product refuses to make. And
+* `important` is ORANGE, not the blue-family colour the code's own
+* comment claimed for eight releases: every WORTHY badge ever rendered
+* showed the trusted band in a warning colour. Nobody had resolved a
+* shields name to a value and looked.
+*
+* Values are hex without `#`, the form shields.io's endpoint takes.
+* `A83A35`, `7A5F16`, `1F6F7C` and `5C646E` are the `TINT` strokes —
+* the same deep steps the mermaid diagrams use, for the same reason.
+* `8A6D1E` is the gold the brand document already named as the light
+* FORGED gradient's start.
+*/
+const BADGE_BAND = {
+	critical: "A83A35",
+	warning: "7A5F16",
+	trusted: "1F6F7C",
+	forged: "8A6D1E",
+	unmeasured: "5C646E"
+};
+SURFACE.ink950, SURFACE.ink900, SURFACE.ink850, SURFACE.ink800, BRAND.steel, BRAND.steelDim, BRAND.gold, BRAND.goldBright, BRAND.goldHot, BRAND.aurora, BRAND.auroraBright, BRAND.auroraCyan;
+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;
+//#endregion
 //#region src/reporter/score-state.ts
 const HEADLINES = {
 	critical: "The hammer is cracked — {n} findings break its edge.",
@@ -9903,11 +10384,11 @@ function headlineFor(state, findings) {
 * Respects NO_COLOR and non-TTY via `palette(isTTY)` — every renderer
 * receives a palette and never touches process.env directly.
 *
-* Palette: a cold northern set — frost-steel, aurora teal, Yggdrasil
-* green — with amber for warnings (Mjölnir's lightning) and a
-* rune-red for errors. No magenta/pink. Emitted as 24-bit truecolor
-* SGR (`38;2;r;g;b`), which every modern terminal renders and which
-* `shouldColorize` already gates behind TTY + !NO_COLOR.
+* Palette: resolved from `src/brand/tokens.ts`, the single source of
+* brand truth — this file defines no colour of its own. Emitted as
+* 24-bit truecolor SGR (`38;2;r;g;b`), which every modern terminal
+* renders and which `shouldColorize` already gates behind
+* TTY + !NO_COLOR.
 *
 * Symbols always accompany color (color-blind safe, R11).
 *
@@ -9920,53 +10401,42 @@ function headlineFor(state, findings) {
 * flag so output degrades to plain characters on cmd.exe/legacy
 * consoles that mangle box-drawing glyphs and emoji.
 */
-/** Norse-forge palette, 24-bit truecolor. */
+/**
+* `"#RRGGBB"` → the `[r, g, b]` triplet the SGR truecolor emitter needs.
+* Lives here rather than in `src/brand/tokens.ts`, which is pure data:
+* each surface converts the canonical hex into its own colour space.
+*/
+function fromHex(hex) {
+	const n = Number.parseInt(hex.slice(1), 16);
+	return [
+		n >> 16 & 255,
+		n >> 8 & 255,
+		n & 255
+	];
+}
+/**
+* The terminal palette, 24-bit truecolor, resolved from
+* `src/brand/tokens.ts` — the single source of brand truth. Nothing in
+* this file may name a hex value of its own, and `brand-doctor` rule 2
+* fails if it tries.
+*
+* Every role is now the canonical token. Six of them used to be the
+* terminal's own: a frost-steel blue for headers, a teal for info, an
+* amber for warnings, a rune-red for errors, a bone white for bold and a
+* weathered stone for dim — a second palette for one product. The
+* rune-red also failed WCAG AA at 4.36:1 on this terminal's own
+* background; `STATUS.error` on the canonical ground is 6.20:1.
+*/
 const NORSE = {
-	ok: [
-		79,
-		180,
-		119
-	],
-	info: [
-		63,
-		176,
-		160
-	],
-	accent: [
-		138,
-		180,
-		216
-	],
-	warning: [
-		224,
-		165,
-		38
-	],
-	error: [
-		208,
-		69,
-		59
-	],
-	trusted: [
-		92,
-		196,
-		224
-	],
-	forged: [
-		244,
-		220,
-		156
-	],
-	bold: [
-		237,
-		230,
-		214
-	],
-	dim: [
-		124,
-		133,
-		144
-	]
+	ok: fromHex(STATUS.ok),
+	info: fromHex(BRAND.aurora),
+	accent: fromHex(BRAND.steel),
+	warning: fromHex(STATUS.warning),
+	error: fromHex(STATUS.error),
+	trusted: fromHex(SCORE.trusted),
+	forged: fromHex(SCORE.forged),
+	bold: fromHex(TEXT.primary),
+	dim: fromHex(TEXT.muted)
 };
 const on = {
 	ok: rgb(NORSE.ok),
@@ -12608,16 +13078,47 @@ function countBySeverity(result) {
 	}
 	return counts;
 }
+EVIDENCE.e0, EVIDENCE.e1, EVIDENCE.e2;
+const RUNG_MEANINGS = [
+	"observation only",
+	"heuristic static",
+	"deterministic static",
+	"the finding's file executed",
+	"the finding's test executed",
+	"the run verdict corroborates"
+];
+const RUNG_COLORS = [
+	TRUST.l0,
+	TRUST.l1,
+	TRUST.l2,
+	TRUST.l3,
+	TRUST.l4,
+	TRUST.l5
+];
+const TRUST_RUNGS = RUNG_MEANINGS.map((meaning, i) => ({
+	level: `L${i}`,
+	meaning,
+	runtime: i >= 3,
+	color: RUNG_COLORS[i]
+}));
 //#endregion
 //#region src/reporter/trust-report.ts
-const TRUST_LABELS = {
-	L0: "L0 · observation only",
-	L1: "L1 · heuristic static",
-	L2: "L2 · deterministic static",
-	L3: "L3 · file executed",
-	L4: "L4 · test executed",
-	L5: "L5 · run corroborates defect"
-};
+/**
+* The rung labels, built from `src/brand/symbols.ts` rather than typed
+* again here.
+*
+* They had drifted the moment there were two copies: this file said
+* "file executed" and "run corroborates defect" where the symbol module,
+* the architecture diagram and the website's ladder all said "the
+* finding's file executed" and "the run verdict corroborates". Small
+* enough that nobody would notice, and exactly the kind of divergence
+* that makes a reader wonder whether two surfaces mean the same thing.
+*
+* The runtime marker is not decoration either: L3 and above cannot be
+* reached without a real run report, and the label says so wherever the
+* ladder is not drawn to show it.
+*/
+const TRUST_LABELS = Object.fromEntries(TRUST_RUNGS.map((r) => [r.level, `${r.level} · ${r.meaning}${r.runtime ? " · runtime" : ""}`]));
 function pct$1(v) {
 	return `${Math.round(v * 100)}%`;
 }
@@ -12753,7 +13254,7 @@ function renderSarif(result, repoRootUri) {
 		tool: { driver: {
 			name: "Mjölnir",
 			informationUri: "https://github.com/Sergey-Bar/Mjolnir",
-			version: "1.0.1",
+			version: "1.0.3",
 			rules: [...rules.values()].map((r) => {
 				const meta = RULES.find((x) => x.id === r.id);
 				return {
@@ -12882,6 +13383,22 @@ function renderCodeQuality(result) {
 }
 //#endregion
 //#region src/reporter/mermaid.ts
+/**
+* `--format mermaid` — test-architecture diagram (Sprint 9 Task 38,
+* Master-Stabilization-Plan.md). Ranked first among the delight
+* features because it is genuinely useful to QA leads presenting scan
+* results to stakeholders, not merely decorative — a flowchart of
+* detected frameworks → rule categories → severity buckets, so gaps
+* are visible at a glance in a format that pastes directly into a
+* GitHub/GitLab markdown comment or a slide (Mermaid renders natively
+* in both).
+*
+* Score-neutral (Sprint 9's own DoD line): this is a pure alternate
+* rendering of the exact same ScanResult every other format uses — it
+* changes no scoring, no exit code, no JSON contract field. Output is
+* fully deterministic: every collection is sorted before rendering, so
+* the same ScanResult always produces byte-identical Mermaid source.
+*/
 function sanitizeId(raw) {
 	return raw.replace(/[^a-z0-9]/gi, "_");
 }
@@ -12889,6 +13406,14 @@ function sanitizeId(raw) {
 function escapeLabel(text) {
 	return text.replaceAll("\"", "&quot;").replaceAll("\n", " ");
 }
+/**
+* One Mermaid `classDef` line from one brand tint. Every colour this
+* renderer emits comes from `src/brand/tokens.ts`; it names none of its
+* own, and `brand-doctor` rule 6 fails if it starts to.
+*/
+function classDef(name, tint) {
+	return `  classDef ${name} fill:${tint.fill},stroke:${tint.stroke},color:${tint.text};`;
+}
 function dimensionStyleClass(dim) {
 	if (dim.score >= 80) return "healthy";
 	if (dim.score >= 50) return "warn";
@@ -12907,8 +13432,8 @@ function renderMermaid(result) {
 	if (result.score === null) {
 		lines.push(`  ${rootId} --> NOTESTS["No test files detected"]`);
 		lines.push("");
-		lines.push("  classDef critical fill:#fee2e2,stroke:#b91c1c,color:#7f1d1d;");
-		lines.push("  class NOTESTS critical;");
+		lines.push(classDef("unknown", TINT.neutral));
+		lines.push("  class NOTESTS unknown;");
 		return lines.join("\n");
 	}
 	const frameworks = [...result.frameworks].sort((a, b) => a.localeCompare(b));
@@ -12944,10 +13469,11 @@ function renderMermaid(result) {
 		}
 	}
 	lines.push("");
-	lines.push("  classDef healthy fill:#dcfce7,stroke:#15803d,color:#14532d;");
-	lines.push("  classDef warn fill:#fef9c3,stroke:#a16207,color:#713f12;");
-	lines.push("  classDef critical fill:#fee2e2,stroke:#b91c1c,color:#7f1d1d;");
-	lines.push("  classDef info fill:#dbeafe,stroke:#1d4ed8,color:#1e3a8a;");
+	lines.push(classDef("healthy", TINT.ok));
+	lines.push(classDef("warn", TINT.gold));
+	lines.push(classDef("critical", TINT.error));
+	lines.push(classDef("info", TINT.aurora));
+	lines.push(classDef("unknown", TINT.neutral));
 	for (const { id, cls } of styleAssignments) lines.push(`  class ${id} ${cls};`);
 	return lines.join("\n");
 }
@@ -16219,17 +16745,19 @@ function renderMutationSummary(report) {
 * retarget fixes the historical threshold drift (the badge used
 * ≥90/≥75/≥50 with four bands while the reporter used ≥80/≥50).
 *
-* Shields.io has no cyan or white-gold, so the mapping is documented
-* here: trusted → `important` (blue-family, closest to aurora-cyan),
-* forged → `success` (the strongest positive signal shields offers).
-* The badge is a peripheral surface; ScoreState remains the truth.
+* They are brand values now, from `BADGE_BAND`, not shields.io's named
+* colors. That mapping was documented as "trusted → `important`
+* (blue-family, closest to aurora-cyan)" and was simply untrue:
+* `important` resolves to #ea7233, which is orange. Every WORTHY badge
+* rendered the trusted band in a warning colour, and `success` — the
+* 100 state — rendered green, which is not a score colour here.
+*
+* ScoreState remains the truth; the badge is still a peripheral
+* surface. But peripheral is not the same as unchecked.
 */
 function colorFor(score) {
 	const band = deriveScoreState(score).band;
-	if (band === "unmeasured") return "lightgrey";
-	if (band === "forged") return "success";
-	if (band === "trusted") return "important";
-	return band === "warning" ? "yellow" : "red";
+	return BADGE_BAND[band];
 }
 /** Build the shields.io endpoint payload from a scan result. */
 function buildBadge(result, commit) {
@@ -16240,7 +16768,6 @@ function buildBadge(result, commit) {
 		label: "MJÖLNIR",
 		message: score === null ? "no tests found" : score === 100 && errors === 0 ? "100/100 · forged" : `${score}/100 · ${errors} error${errors === 1 ? "" : "s"}`,
 		color: colorFor(score),
-		namedLogo: "vitest",
 		...commit !== void 0 ? { commit } : {}
 	};
 }
@@ -18417,6 +18944,19 @@ function loadManifest(path) {
 *
 * Exit codes reuse the frozen set: 0 healthy · 1 violations · 20 crash.
 */
+/** The closed reason-code set (master plan P8) — mirrored from
+* src/rules/rule.ts's StrategyReasonCode union via a runtime set so the
+* doctor check validates membership without an extra export cycle. */
+const VALID_REASON_CODES = /* @__PURE__ */ new Set([
+	"shell-string-in-config",
+	"exact-key-match",
+	"lexical-artifact",
+	"runner-semantic",
+	"string-content-defect",
+	"absence-aggregate",
+	"family-fallback-lockstep",
+	"migration-deferred-next-measurement"
+]);
 /** Uniform error rendering for doctor details (Error or thrown-as-string). */
 function errorText(e) {
 	return e instanceof Error ? e.message : String(e);
@@ -18455,7 +18995,8 @@ function checkFixtureFirewall(fixturesRoot) {
 	}
 	return check("fixture-firewall", ok ? "pass" : "fail", details);
 }
-/** Check 2: registry sanity — IDs unique, well-formed, titles distinct. */
+/** Check 2: registry sanity — IDs unique, well-formed, titles distinct,
+* and (P8) every LEXICAL rule carries a valid depth-adjudication record. */
 function checkRegistry(rules = RULES) {
 	const details = [];
 	const ids = /* @__PURE__ */ new Set();
@@ -18470,6 +19011,19 @@ function checkRegistry(rules = RULES) {
 			details.push(`${r.id}: duplicate registration`);
 		}
 		ids.add(r.id);
+		if (r.detectionStrategy === "LEXICAL") {
+			const j = r.strategyJustification;
+			if (!j) {
+				ok = false;
+				details.push(`${r.id}: LEXICAL strategy without strategyJustification — declare the reason the lexical form ships (docs/DEPTH-ADJUDICATION.md)`);
+			} else if (!VALID_REASON_CODES.has(j.reasonCode)) {
+				ok = false;
+				details.push(`${r.id}: strategyJustification.reasonCode "${String(j.reasonCode)}" is outside the closed set (${[...VALID_REASON_CODES].join(", ")})`);
+			} else if (j.detail.trim().length < 20) {
+				ok = false;
+				details.push(`${r.id}: strategyJustification.detail is boilerplate — cite the detector's actual shape`);
+			}
+		}
 		const family = r.id.split("-")[1];
 		for (const other of rules) if (other.id !== r.id && other.title === r.title && other.id.split("-")[1] === family) {
 			ok = false;
@@ -19157,7 +19711,7 @@ const { runScan, buildUniversalRules, fallbackWorkspace, pathMatchesGlob, isVali
 * `scripts/sync-sarif-version.cjs` on release and guarded by
 * `tests/version-consistency.spec.ts` locally.
 */
-const CLI_VERSION = "1.0.1";
+const CLI_VERSION = "1.0.3";
 function parseArgs(argv, onError) {
 	const args = {
 		target: ".",
@@ -19493,8 +20047,9 @@ async function runExplainCommand(argv, io = {
 			return 10;
 		}
 		try {
-			io.out(renderVerdictExplain(explainVerdict(resolve(jsonPath))));
-			return explainVerdict(resolve(jsonPath)).ok ? 0 : 10;
+			const r = explainVerdict(resolve(jsonPath));
+			io.out(renderVerdictExplain(r));
+			return r.ok ? 0 : 10;
 		} catch (err) {
 			internalErrorMessage(err, io.err, argv.includes("--debug"));
 			return 20;