mjolnir-qa 1.0.2 → 1.0.3

package/dist/mcp/stdio.mjs

@@ -10076,6 +10076,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.",
@@ -10152,11 +10383,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).
 *
@@ -10169,53 +10400,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),
@@ -12857,16 +13077,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)}%`;
 }
@@ -13002,7 +13253,7 @@ function renderSarif(result, repoRootUri) {
 		tool: { driver: {
 			name: "Mjölnir",
 			informationUri: "https://github.com/Sergey-Bar/Mjolnir",
-			version: "1.0.2",
+			version: "1.0.3",
 			rules: [...rules.values()].map((r) => {
 				const meta = RULES.find((x) => x.id === r.id);
 				return {
@@ -13131,6 +13382,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, "_");
 }
@@ -13138,6 +13405,14 @@ function sanitizeId(raw) {
 function escapeLabel(text) {
 	return text.replaceAll("\"", """).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";
@@ -13156,8 +13431,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));
@@ -13193,10 +13468,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");
 }
@@ -15674,17 +15950,19 @@ function sweepStaleTempFiles(dir) {
 * 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) {
@@ -15695,7 +15973,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 } : {}
 	};
 }
@@ -19009,7 +19286,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.2";
+const CLI_VERSION = "1.0.3";
 function parseArgs(argv, onError) {
 	const args = {
 		target: ".",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mjolnir-qa",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Mjölnir — the Verification Trust Engine for QA. Audits test suites and CI pipelines, reports a worthiness score and prioritized findings.",
   "type": "module",
   "engines": {
@@ -59,7 +59,13 @@
     "prepare": "husky",
     "prepublishOnly": "npm run build",
     "docs:flow": "tsx scripts/generate-readme-flow.ts",
-    "docs:architecture": "tsx scripts/generate-readme-architecture.ts"
+    "docs:architecture": "tsx scripts/generate-readme-architecture.ts",
+    "brand:tokens": "tsx scripts/generate-brand-tokens.ts",
+    "brand:doctor": "node scripts/brand-doctor.mjs",
+    "brand:doctor:selftest": "node scripts/brand-doctor-selftest.mjs",
+    "brand:fonts": "tsx scripts/vendor-fonts.ts",
+    "brand:fonts:check": "tsx scripts/vendor-fonts.ts --check",
+    "brand:marks:update": "node scripts/update-mark-hashes.mjs"
   },
   "keywords": [
     "qa",