@nurix/etna 0.19.2 → 0.19.4

package/data/harnesses/code/skills/design/scripts/scaffold.mjs

@@ -1,9 +1,16 @@
-// skills/design/scripts/scaffold.mjs — generates the non-creative app substrate (routes, nav, per-surface state shells) from docs/design/structure.md
+// skills/design/scripts/scaffold.mjs — generates the non-creative app substrate (routes, nav, per-surface state shells, the theme + chart-colors lib helpers) from docs/design/structure.md
 import { mkdirSync, writeFileSync, readFileSync, existsSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { BUDGETS, BUDGET_STAMPS, stampFor, THEME_ATTR, THEME_VALUES, resolveThemeDefault, MOTION_LIFT_CLASS, MOTION_STAGGER_CLASS, STAGGER_CHILD_CAP } from "./lib/vocabulary.mjs";
 
 const ARCHETYPES = ["list-detail", "dashboard", "entity-detail", "create-edit", "log-stream", "command-center"];
 const LANDING = new Set(["list-detail", "dashboard", "log-stream", "command-center"]);
+// Archetypes whose composition substrate is a row table (rows consume motion-lift) vs a card grid
+// (the grid consumes motion-stagger — brand-forward surfaces only: baseline skips arrival cascades, mot-08).
+const TABLE_ARCHETYPES = new Set(["list-detail", "log-stream", "command-center"]);
+const CARD_GRID_ARCHETYPES = new Set(["dashboard"]);
+// Archetypes whose surfaces typically carry charts — their composition region names the token wiring.
+const CHART_ARCHETYPES = new Set(["dashboard", "command-center"]);
 
 // Print the refusal (problem + exact fix) to stderr and exit non-zero.
 function refuse(problem, fix) {
@@ -197,6 +204,13 @@ function entityNames(name) {
   };
 }
 
+// Normalize a surface's declared delight budget to a legal enum value, defaulting to the safe floor
+// `baseline` when the map omits it or carries an unknown value (references/structure.md, the delight budget).
+function normalizeBudget(v) {
+  const b = String(v ?? "").trim().toLowerCase();
+  return BUDGETS.includes(b) ? b : "baseline";
+}
+
 // Normalize a surface's declared states to the canonical loading/empty/error/degraded set.
 function normalizeStates(arr) {
   const alias = { partial: "degraded", degraded: "degraded", loading: "loading", empty: "empty", error: "error" };
@@ -254,6 +268,7 @@ function loadStructure(path, { requireSurfaces }) {
       route: String(s.route).trim(),
       entity: String(s.entity).trim(),
       densityModifier: mod,
+      budget: normalizeBudget(s.budget),
       states: normalizeStates(s.states),
     };
   });
@@ -280,18 +295,38 @@ function emit(root, rel, content, written) {
   written.push(rel);
 }
 
-// Render index.html carrying placeholder <html data-*> personality attributes (derive-personality --emit resolves them).
-function indexHtml() {
+// Read the emitted default theme from the artifact payload (payload.theme-default, else derived from
+// look.theme via both → light), returning light when the artifact is absent, unreadable, or silent.
+function readThemeDefault(out) {
+  const artifactPath = join(out, "design.tokens.json");
+  if (!existsSync(artifactPath)) return "light";
+  let tokens;
+  try {
+    tokens = JSON.parse(readFileSync(artifactPath, "utf8"));
+  } catch {
+    return "light";
+  }
+  const payload = tokens && tokens.$extensions && tokens.$extensions["com.nurix.design"];
+  if (!payload || typeof payload !== "object") return "light";
+  if (THEME_VALUES.includes(payload["theme-default"])) return payload["theme-default"];
+  if (payload.look && typeof payload.look === "object") return resolveThemeDefault(payload.look.theme);
+  return "light";
+}
+
+// Render index.html. data-theme is written from the artifact's resolved theme-default; the other
+// <html data-*> personality attributes are placeholders derive-personality.mjs --emit resolves.
+function indexHtml(themeDefault) {
   return `<!doctype html>
 <!-- Generated by scaffold.mjs. Personality state lives in these <html data-*> attributes (code is the cache).
-     The values below are placeholders; derive-personality.mjs --emit resolves them from the project's design-tokens artifact (design.tokens.json). -->
+     data-theme is written from the project artifact's theme-default; the remaining values are placeholders
+     derive-personality.mjs --emit resolves from the design-tokens artifact (design.tokens.json). -->
 <html
   lang="en"
   data-style="app"
   data-density="standard"
   data-verbosity="default"
   data-feedback="subtle"
-  data-theme="light"
+  data-theme="${themeDefault}"
 >
   <head>
     <meta charset="UTF-8" />
@@ -306,14 +341,18 @@ function indexHtml() {
 `;
 }
 
-// Render src/main.tsx: mount the router app and load the emitted global stylesheet.
+// Render src/main.tsx: apply the persisted theme, mount the router app, load the emitted stylesheet.
 function mainTsx() {
-  return `// src/main.tsx — Vite entry: mounts the router app and loads the emitted global stylesheet (generated by scaffold.mjs; do not hand-edit).
+  return `// src/main.tsx — Vite entry: applies the persisted theme, mounts the router app, and loads the emitted global stylesheet (generated by scaffold.mjs; do not hand-edit).
 import { StrictMode } from "react";
 import { createRoot } from "react-dom/client";
 import App from "./App";
+import { initTheme } from "./lib/theme";
 import "./styles/globals.css";
 
+// A stored theme preference overrides the boot attribute before first paint.
+initTheme();
+
 const rootElement = document.getElementById("root");
 if (!rootElement) {
   throw new Error("Root element #root not found in index.html");
@@ -327,6 +366,88 @@ createRoot(rootElement).render(
 `;
 }
 
+// Render src/lib/theme.ts: the data-theme toggle + persistence helper — one attribute convention,
+// four writers (personality.css armor, scaffold's <html>, @custom-variant dark, this helper).
+function themeTs() {
+  const themeUnion = THEME_VALUES.map((v) => `"${v}"`).join(" | ");
+  return `// src/lib/theme.ts — ${THEME_ATTR} toggle + persistence (generated by scaffold.mjs; do not hand-edit).
+// Code is the cache: <html ${THEME_ATTR}> is the single runtime theme state — the same attribute
+// personality.css armors (:root[${THEME_ATTR}="dark"]) and globals.css's @custom-variant dark follows.
+// index.html carries the artifact's theme-default as the boot value; a stored preference overrides it.
+
+export type Theme = ${themeUnion};
+
+const THEME_ATTRIBUTE = "${THEME_ATTR}";
+const THEME_STORAGE_KEY = "theme";
+const THEMES: Theme[] = [${THEME_VALUES.map((v) => `"${v}"`).join(", ")}];
+
+// The active theme, read from the attribute (the cache), defaulting to light.
+export function getTheme(): Theme {
+  const value = document.documentElement.getAttribute(THEME_ATTRIBUTE);
+  return THEMES.includes(value as Theme) ? (value as Theme) : "light";
+}
+
+// Set the theme: write the attribute (the cascade flips) and persist the preference.
+export function setTheme(theme: Theme): void {
+  document.documentElement.setAttribute(THEME_ATTRIBUTE, theme);
+  try {
+    localStorage.setItem(THEME_STORAGE_KEY, theme);
+  } catch {
+    // storage unavailable (private mode) — the attribute still flips for this session
+  }
+}
+
+// Flip between light and dark, returning the new theme.
+export function toggleTheme(): Theme {
+  const next: Theme = getTheme() === "dark" ? "light" : "dark";
+  setTheme(next);
+  return next;
+}
+
+// Apply a stored preference over the boot attribute; called once by main.tsx before mount.
+export function initTheme(): void {
+  let stored: string | null = null;
+  try {
+    stored = localStorage.getItem(THEME_STORAGE_KEY);
+  } catch {
+    return;
+  }
+  if (stored !== null && THEMES.includes(stored as Theme)) {
+    document.documentElement.setAttribute(THEME_ATTRIBUTE, stored as Theme);
+  }
+}
+`;
+}
+
+// Render src/lib/chart-colors.ts: token-backed chart palettes so the identity survives to the pixel.
+function chartColorsTs() {
+  return `// src/lib/chart-colors.ts — chart color wiring over the emitted tokens (generated by scaffold.mjs; do not hand-edit).
+// @nurix/components charts accept color props (probed at 0.14.0): LineGraph/PieGraph take a series
+// list, BarGraph takes a status map (success | degraded | error | info | empty). Always pass these
+// exports — never literals — so every chart inherits the theme through the emitted tokens; chart
+// chrome (gridlines, axis labels) stays library-internal, a known substrate limit.
+
+// Series palette for LineGraph / PieGraph \`colors\` — the artifact's five chart tokens, in order.
+export const SERIES_COLORS = [
+  "var(--chart-1)",
+  "var(--chart-2)",
+  "var(--chart-3)",
+  "var(--chart-4)",
+  "var(--chart-5)",
+];
+
+// Status map for BarGraph \`colors\`. info/empty ride accent / muted-foreground: the 36-role
+// artifact carries no dedicated info or empty token, and those two are their closest semantic homes.
+export const STATUS_COLORS = {
+  success: "var(--success)",
+  degraded: "var(--warning)",
+  error: "var(--destructive)",
+  info: "var(--accent)",
+  empty: "var(--muted-foreground)",
+};
+`;
+}
+
 // Render src/App.tsx: one route per surface, wrapped in the persistent operator shell.
 function appTsx(surfaces) {
   const imports = surfaces
@@ -418,6 +539,113 @@ export function AppNav() {
 `;
 }
 
+// Composition region for one surface, per archetype: table archetypes get a substrate row table
+// (rows consume motion-lift — hover feedback, budget-free); card-grid archetypes get a substrate
+// grid (motion-stagger on brand-forward surfaces only — baseline skips arrival cascades, mot-08);
+// chart archetypes carry the token wiring instruction; the rest keep the compose-here placeholder.
+function compositionFn(surface, en) {
+  const comp = toPascal(surface.name);
+  const chartNote = CHART_ARCHETYPES.has(surface.archetype)
+    ? `
+      {/* Charts: import { SERIES_COLORS, STATUS_COLORS } from "../../lib/chart-colors" and pass
+          colors={SERIES_COLORS} to LineGraph/PieGraph, colors={STATUS_COLORS} to BarGraph —
+          token-backed palettes only; chart chrome is library-internal (a substrate limit). */}`
+    : "";
+
+  if (TABLE_ARCHETYPES.has(surface.archetype)) {
+    return `// Composition region: the surfaces phase composes the ${surface.archetype} archetype here, following its exemplar and the emitted tokens.
+function ${comp}Composition({ rows, degraded = false }: { rows: ${en.iface}[]; degraded?: boolean }) {
+  const columns = rows.length > 0 ? Object.keys(rows[0] as unknown as Record<string, unknown>).slice(0, 5) : [];
+  return (
+    <div className="flex flex-1 flex-col rounded-lg border border-border bg-card text-card-foreground">
+      <div className="flex items-center justify-between border-b border-border px-4 py-3">
+        <p className="text-sm font-medium text-foreground">${surface.name}</p>
+        <p className="text-xs text-muted-foreground tabular-nums">
+          {rows.length} records{degraded ? " (partial)" : ""}
+        </p>
+      </div>
+      <div className="overflow-x-auto">
+        <table className="w-full table-fixed text-sm">
+          <thead>
+            <tr className="border-b border-border text-left">
+              {columns.map((column) => (
+                <th key={column} scope="col" className="truncate px-4 py-2 text-xs font-medium text-muted-foreground">
+                  {column}
+                </th>
+              ))}
+            </tr>
+          </thead>
+          <tbody>
+            {rows.map((row, index) => (
+              <tr key={index} className="${MOTION_LIFT_CLASS} border-b border-border">
+                {columns.map((column) => (
+                  <td key={column} className="truncate px-4 py-2">
+                    {String((row as unknown as Record<string, unknown>)[column] ?? "")}
+                  </td>
+                ))}
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </div>${chartNote}
+      <p className="border-t border-border px-4 py-3 text-xs text-muted-foreground">
+        Substrate table: compose the ${surface.archetype} surface for ${surface.entity} here.
+      </p>
+    </div>
+  );
+}`;
+  }
+
+  if (CARD_GRID_ARCHETYPES.has(surface.archetype)) {
+    const staggerClass = surface.budget === "brand-forward" ? ` ${MOTION_STAGGER_CLASS}` : "";
+    return `// Composition region: the surfaces phase composes the ${surface.archetype} archetype here, following its exemplar and the emitted tokens.
+function ${comp}Composition({ rows, degraded = false }: { rows: ${en.iface}[]; degraded?: boolean }) {
+  return (
+    <div className="flex flex-1 flex-col gap-3">
+      <div className="flex items-center justify-between">
+        <p className="text-sm font-medium text-foreground">${surface.name}</p>
+        <p className="text-xs text-muted-foreground tabular-nums">
+          {rows.length} records{degraded ? " (partial)" : ""}
+        </p>
+      </div>
+      <div className="grid auto-rows-min grid-cols-1 gap-4 md:grid-cols-2 xl:grid-cols-3${staggerClass}">
+        {rows.slice(0, ${STAGGER_CHILD_CAP}).map((row, index) => (
+          <article key={index} className="flex flex-col gap-2 rounded-lg border border-border bg-card p-4 text-card-foreground shadow-sm">
+            {Object.entries(row as unknown as Record<string, unknown>).slice(0, 4).map(([field, value]) => (
+              <div key={field} className="flex items-baseline justify-between gap-3">
+                <span className="truncate text-xs text-muted-foreground">{field}</span>
+                <span className="truncate text-sm font-medium">{String(value ?? "")}</span>
+              </div>
+            ))}
+          </article>
+        ))}
+      </div>${chartNote}
+      <p className="text-xs text-muted-foreground">
+        Substrate card grid: compose the ${surface.archetype} surface for ${surface.entity} here.
+      </p>
+    </div>
+  );
+}`;
+  }
+
+  return `// Composition region: the surfaces phase composes the ${surface.archetype} archetype here, following its exemplar and the emitted tokens.
+function ${comp}Composition({ rows, degraded = false }: { rows: ${en.iface}[]; degraded?: boolean }) {
+  return (
+    <div className="flex flex-1 flex-col rounded-lg border border-border bg-card text-card-foreground">
+      <div className="flex items-center justify-between border-b border-border px-4 py-3">
+        <p className="text-sm font-medium text-foreground">${surface.name}</p>
+        <p className="text-xs text-muted-foreground tabular-nums">
+          {rows.length} records{degraded ? " (partial)" : ""}
+        </p>
+      </div>${chartNote}
+      <p className="px-4 py-6 text-sm text-muted-foreground">
+        Compose the ${surface.archetype} surface for ${surface.entity} here.
+      </p>
+    </div>
+  );
+}`;
+}
+
 // Render one surface shell: typed props, fixture wiring, pre-created lifecycle state shells, and the density-step root.
 function surfaceShell(surface) {
   const comp = toPascal(surface.name);
@@ -475,7 +703,9 @@ function surfaceShell(surface) {
   if (hasEmpty) pickBody.push(`  if (state === "empty") return ${en.emptyVar};`);
   pickBody.push(`  return ${en.arrayVar};`);
 
-  const content = `// src/routes/${slug}/${comp}.tsx — ${surface.name} surface shell (${surface.archetype}; generated by scaffold.mjs; do not hand-edit).
+  const stamp = stampFor(surface.budget) || BUDGET_STAMPS.baseline;
+  const content = `${stamp}
+// src/routes/${slug}/${comp}.tsx — ${surface.name} surface shell (${surface.archetype}; generated by scaffold.mjs; do not hand-edit).
 import type { ${en.iface} } from "../../types/${en.typeFile}";
 import { ${named.join(", ")} } from "../../fixtures/${en.fixtureFile}";
 
@@ -502,22 +732,7 @@ ${branches.join("\n")}
   );
 }
 
-// Composition region: the surfaces phase composes the ${surface.archetype} archetype here, following its exemplar and the emitted tokens.
-function ${comp}Composition({ rows, degraded = false }: { rows: ${en.iface}[]; degraded?: boolean }) {
-  return (
-    <div className="flex flex-1 flex-col rounded-lg border border-border bg-card text-card-foreground">
-      <div className="flex items-center justify-between border-b border-border px-4 py-3">
-        <p className="text-sm font-medium text-foreground">${surface.name}</p>
-        <p className="text-xs text-muted-foreground tabular-nums">
-          {rows.length} records{degraded ? " (partial)" : ""}
-        </p>
-      </div>
-      <p className="px-4 py-6 text-sm text-muted-foreground">
-        Compose the ${surface.archetype} surface for ${surface.entity} here.
-      </p>
-    </div>
-  );
-}
+${compositionFn(surface, en)}
 
 // Select the fixture set backing the requested lifecycle state.
 function pickRows(state: SurfaceState): ${en.iface}[] {
@@ -537,8 +752,10 @@ function main() {
   }
   const model = loadStructure(structurePath, { requireSurfaces: true });
   const written = [];
-  emit(out, "index.html", indexHtml(), written);
+  emit(out, "index.html", indexHtml(readThemeDefault(out)), written);
   emit(out, "src/main.tsx", mainTsx(), written);
+  emit(out, "src/lib/theme.ts", themeTs(), written);
+  emit(out, "src/lib/chart-colors.ts", chartColorsTs(), written);
   emit(out, "src/App.tsx", appTsx(model.surfaces), written);
   emit(out, "src/components/nav/AppNav.tsx", navTsx(model.surfaces), written);
   for (const surface of model.surfaces) {

package/data/harnesses/code/skills/design/scripts/self-integrity.mjs

@@ -1,4 +1,4 @@
-// skills/design/scripts/self-integrity.mjs — the design skill's own CI check: anchor parity, catalog invariants, stated-count and fixture-pair validation (pairs exercised through lib/checks.mjs), the token-era net — token file-tree + goldens parity, per-artifact --check validity, and (behind --goldens) golden emission hash match — plus combination-data validation (validate-combinations.mjs); --fixture <rule-id> runs a single pair
+// skills/design/scripts/self-integrity.mjs — the design skill's own CI check: anchor parity (rule ids and the doctrine-floor f-ids), catalog invariants, stated-count and fixture-pair validation (pairs exercised through lib/checks.mjs), the token-era net — token file-tree + goldens parity, per-artifact --check validity, and (behind --goldens) golden emission hash match — plus combination-data validation (validate-combinations.mjs); --fixture <rule-id> runs a single pair
 import { readFileSync, existsSync, readdirSync, mkdtempSync, rmSync } from "node:fs";
 import { join, dirname, resolve } from "node:path";
 import { tmpdir } from "node:os";
@@ -26,7 +26,11 @@ const ANCHOR_PREFIXES = "typ|col|spc|dep|int|mot|sta|cod|proc|inst|trust";
 const ANCHOR_TOKEN = new RegExp("`(" + ANCHOR_PREFIXES + ")-(\\d{2})`", "g");
 const ANCHOR_ID = "(?:" + ANCHOR_PREFIXES + ")-\\d{2}";
 
-const PINNED = { rows: 131, source: 66, render: 10, archetypes: 6, primitives: 26, colorTokens: 34, semanticTokens: 17, substrateTokens: 17 };
+const PINNED = { rows: 136, source: 70, render: 12, archetypes: 6, primitives: 27, colorTokens: 36, semanticTokens: 19, substrateTokens: 17, rampSteps: 7, elevation: 4 };
+
+// The doctrine floor's canonical ids (f01-f12) — enumerated once in hard-rules.md's Doctrine floor
+// section; every in-skill floor citation must name one of these (05-rule-amendments.md, the mapping).
+const FLOOR_IDS = Array.from({ length: 12 }, (_, i) => "f" + String(i + 1).padStart(2, "0"));
 
 // Read a UTF-8 file, returning null when it does not exist.
 function readSafe(path) {
@@ -287,6 +291,58 @@ function checkContrastiveValidity(catalog, onlyId = null) {
     return { name: "contrastive fixture validity", pass: errors.length === 0, detail: `${checked} pair(s) exercised`, errors };
 }
 
+// Recursively collect prose/data files (.md/.csv/.tsx/.json) under a dir for the floor-citation scan.
+function walkTextFiles(dir, acc = []) {
+    if (!existsSync(dir)) return acc;
+    for (const ent of readdirSync(dir, { withFileTypes: true })) {
+        if (ent.name.startsWith(".") || ent.name === "node_modules") continue;
+        const full = join(dir, ent.name);
+        if (ent.isDirectory()) walkTextFiles(full, acc);
+        else if (/\.(md|csv|tsx|json)$/.test(ent.name)) acc.push(full);
+    }
+    return acc;
+}
+
+// ── Check 2b: doctrine-floor anchor parity (f-ids) ─────────────────────────────
+// Same mechanism as rule-id parity: hard-rules.md's Doctrine floor section is the canonical
+// enumeration (exactly f01-f12, once each); every f-id cited anywhere in the skill's prose/data
+// names an enumerated id, and the retired "floor P<n>" numbering is gone.
+function checkFloorParity() {
+    const errors = [];
+    const md = readSafe(HARD_RULES_MD);
+    if (md === null) return { name: "floor parity (f-ids)", pass: false, detail: "hard-rules.md missing", errors: ["hard-rules.md not found at " + HARD_RULES_MD] };
+
+    const section = /^##\s+Doctrine floor\s*$([\s\S]*?)(?=^##\s)/m.exec(md);
+    const enumerated = new Map();
+    if (!section) errors.push('hard-rules.md has no "## Doctrine floor" section (the canonical f01-f12 enumeration)');
+    else {
+        for (const m of section[1].matchAll(/`(f\d{2})`/g)) enumerated.set(m[1], (enumerated.get(m[1]) || 0) + 1);
+        for (const id of FLOOR_IDS) {
+            const n = enumerated.get(id) || 0;
+            if (n === 0) errors.push(`doctrine floor enumeration is missing ${id}`);
+            else if (n > 1) errors.push(`${id} enumerated ${n} times (want exactly 1)`);
+        }
+        for (const id of enumerated.keys()) if (!FLOOR_IDS.includes(id)) errors.push(`enumeration carries unknown floor id ${id} (legal: f01-f12)`);
+    }
+
+    const targets = [join(SKILL_ROOT, "SKILL.md"), ...walkTextFiles(join(SKILL_ROOT, "references")), ...walkTextFiles(join(SKILL_ROOT, "data"))];
+    let cited = 0;
+    for (const file of targets) {
+        const text = readSafe(file);
+        if (text === null) continue;
+        const rel = file.replace(SKILL_ROOT + "/", "");
+        text.split("\n").forEach((line, i) => {
+            for (const m of line.matchAll(/(?:\bfloor\s+|[(`/]\s?)(f\d{2})\b/g)) {
+                cited++;
+                if (!FLOOR_IDS.includes(m[1])) errors.push(`${rel}:${i + 1}: cites unknown floor id ${m[1]} (legal: f01-f12)`);
+            }
+            const stale = /\bfloor\s+P\d+\b/.exec(line);
+            if (stale) errors.push(`${rel}:${i + 1}: retired P-numbered floor citation "${stale[0]}" — rename to its f-id (05-rule-amendments.md mapping)`);
+        });
+    }
+    return { name: "floor parity (f-ids)", pass: errors.length === 0, detail: errors.length ? `${errors.length} parity break(s)` : `${enumerated.size} enumerated, ${cited} citation(s) checked`, errors };
+}
+
 const NUMBER_WORDS = { one: 1, two: 2, three: 3, four: 4, five: 5, six: 6, seven: 7, eight: 8, nine: 9, ten: 10, eleven: 11, twelve: 12, thirteen: 13, fourteen: 14, fifteen: 15, sixteen: 16, seventeen: 17, eighteen: 18, nineteen: 19, twenty: 20, "twenty-six": 26 };
 
 // Resolve a numeric token (digits or an English number word) to a number, or NaN.
@@ -298,10 +354,15 @@ function toNumber(tok) {
 // ── Check 5: stated counts in prose match the ground truth ─────────────────────
 function checkStatedCounts(catalog, ground) {
     const errors = [];
-    // Ground truth drift guard: derived CSV counts must match the pinned numbers.
+    // Ground truth drift guard: derived counts (CSV rows; the token surface counted off the Nurix
+    // default artifact) must match the pinned numbers.
     if (ground.rows !== PINNED.rows) errors.push(`derived row count ${ground.rows} != pinned ${PINNED.rows}`);
     if (ground.source !== PINNED.source) errors.push(`derived source count ${ground.source} != pinned ${PINNED.source}`);
     if (ground.render !== PINNED.render) errors.push(`derived machine-render count ${ground.render} != pinned ${PINNED.render}`);
+    if (ground.primitives !== null && ground.primitives !== PINNED.primitives) errors.push(`derived primitive count ${ground.primitives} != pinned ${PINNED.primitives}`);
+    if (ground.colorTokens !== null && ground.colorTokens !== PINNED.colorTokens) errors.push(`derived color-token count ${ground.colorTokens} != pinned ${PINNED.colorTokens}`);
+    if (ground.rampSteps !== null && ground.rampSteps !== PINNED.rampSteps) errors.push(`derived ramp-step count ${ground.rampSteps} != pinned ${PINNED.rampSteps}`);
+    if (ground.elevation !== null && ground.elevation !== PINNED.elevation) errors.push(`derived elevation count ${ground.elevation} != pinned ${PINNED.elevation}`);
 
     const gtMap = {
         rules: ground.rows, rule: ground.rows, rows: ground.rows, row: ground.rows,
@@ -310,6 +371,7 @@ function checkStatedCounts(catalog, ground) {
         primitives: PINNED.primitives, primitive: PINNED.primitives,
         "color-tokens": PINNED.colorTokens, "color tokens": PINNED.colorTokens, colortokens: PINNED.colorTokens,
         "semantic-tokens": PINNED.semanticTokens, "substrate-tokens": PINNED.substrateTokens,
+        "ramp-steps": PINNED.rampSteps, rampsteps: PINNED.rampSteps, elevation: PINNED.elevation,
     };
 
     const targets = [join(SKILL_ROOT, "SKILL.md"), ...(existsSync(join(SKILL_ROOT, "references")) ? readdirSync(join(SKILL_ROOT, "references")).filter((f) => f.endsWith(".md")).map((f) => join(SKILL_ROOT, "references", f)) : [])];
@@ -491,7 +553,7 @@ async function checkGoldenMatch(enabled) {
         const perSlug = await runPool(goldenSlugs, SPAWN_LIMIT, async (slug) => {
             const slugErrors = [];
             const outdir = join(emitRoot, slug);
-            const res = await execNode([DERIVE_PERSONALITY, join(TOKENS_DIR, slug), "--emit", outdir]);
+            const res = await execNode([DERIVE_PERSONALITY, join(TOKENS_DIR, slug), "--emit", outdir, "--provisional"]);
             if (res.status !== 0) {
                 slugErrors.push(`${slug}: --emit exited ${res.status}: ${firstLine(res.stderr || res.stdout)}`);
                 return slugErrors;
@@ -513,13 +575,25 @@ async function checkGoldenMatch(enabled) {
     return { name: "golden emission match", pass: errors.length === 0, detail: `${matched}/${goldenSlugs.length * 2} hashes match goldens.json`, errors };
 }
 
-// Derive the ground-truth counts from the catalog itself.
+// Derive the ground-truth counts: rule counts from the catalog itself; the token-surface counts
+// (primitives, color roles, ramp steps, elevation levels) from the Nurix default artifact, the
+// schema's worked example. null when the artifact is unreadable (check 8 reports that separately).
 function deriveGround(catalog) {
-    return {
+    const ground = {
         rows: catalog.rows.length,
         source: catalog.rows.filter((r) => r.detector === "source").length,
         render: catalog.rows.filter((r) => r.detector === "render" && r.grade === "machine").length,
+        primitives: null, colorTokens: null, rampSteps: null, elevation: null,
     };
+    try {
+        const nurix = JSON.parse(readFileSync(join(TOKENS_DIR, "nurix", "design.tokens.json"), "utf8"));
+        const count = (group) => Object.keys(group || {}).filter((k) => !k.startsWith("$")).length;
+        ground.primitives = count(nurix.primitive);
+        ground.colorTokens = count(nurix.color);
+        ground.rampSteps = count(nurix.typography && nurix.typography.ramp);
+        ground.elevation = count(nurix.elevation);
+    } catch { /* artifact validity is check 8's job */ }
+    return ground;
 }
 
 // Run one rule's contrastive fixture pair through the check engine and exit 0/1 on its result.
@@ -563,6 +637,7 @@ async function main() {
     const runners = [
         () => checkCsvWellFormed(catalog),
         () => checkAnchorParity(catalog),
+        () => checkFloorParity(),
         () => checkFixturePresence(catalog),
         () => checkContrastiveValidity(catalog),
         () => checkStatedCounts(catalog, ground),

package/data/harnesses/code/skills/design/scripts/snapshot-goldens.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// skills/design/scripts/snapshot-goldens.mjs — snapshot golden hashes of the CSS emitted for every design-tokens artifact (data/design-tokens/<slug>/) into data/design-tokens/goldens.json, the byte-match regression oracle for the emission pipeline.
+// skills/design/scripts/snapshot-goldens.mjs — snapshot golden hashes of the CSS emitted for every design-tokens artifact (data/design-tokens/<slug>/) into data/design-tokens/goldens.json, the byte-match regression oracle for the emission pipeline, then run the Tailwind compile smoke (emission contract 5): one emitted globals.css + personality.css + fonts.css set is actually compiled by @tailwindcss/vite (the fonts.css @fontsource imports resolve against local stubs) — goldens hash bytes and never compile them, so a byte-green gate can hide unbuildable CSS (a derivation comment containing a Tailwind utility literal closes the comment early). Emission uses --provisional: hint-carrying library twins are hashed at their provisional values (--emit alone still refuses on hints).
 
 import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -26,20 +26,23 @@ const entries = readdirSync(tokensDir, { withFileTypes: true })
 
 const goldens = {};
 const failures = [];
+const provisional = [];
 
 for (const { slug, path } of entries) {
   const outdir = join(emitRoot, slug);
-  const run = spawnSync(process.execPath, [derivePersonalityScript, path, "--emit", outdir], { encoding: "utf8" });
+  const run = spawnSync(process.execPath, [derivePersonalityScript, path, "--emit", outdir, "--provisional"], { encoding: "utf8" });
   if (run.status !== 0) {
     failures.push({ slug, error: (run.stderr || run.stdout || `exit status ${run.status}`).trim() });
     console.log(`FAIL ${slug}`);
     continue;
   }
+  const wasProvisional = /^emit PROVISIONAL/m.test(run.stdout || "");
+  if (wasProvisional) provisional.push(slug);
   try {
     const personalityCss = readFileSync(join(outdir, "src", "styles", "personality.css"), "utf8");
     const globalsCss = readFileSync(join(outdir, "src", "styles", "globals.css"), "utf8");
     goldens[slug] = { personality: goldenHash(personalityCss), globals: goldenHash(globalsCss) };
-    console.log(`OK   ${slug}`);
+    console.log(`OK   ${slug}${wasProvisional ? "  (provisional)" : ""}`);
   } catch (err) {
     failures.push({ slug, error: String((err && err.message) || err) });
     console.log(`FAIL ${slug}`);
@@ -49,7 +52,7 @@ for (const { slug, path } of entries) {
 // Assemble the sorted-key document; "_meta" sorts first (ASCII "_" < "a").
 const document = {
   _meta: {
-    description: "Post-carrier golden hashes of the CSS emitted by derive-personality.mjs --emit for every design-tokens artifact (data/design-tokens/<slug>/), dark-inclusive: an artifact shipping design.tokens.dark.json hashes its emitted [data-theme=\"dark\"] block too. Each entry records the sha256 of the comment-stripped personality.css and globals.css (see scripts/lib/golden.mjs). The byte-match regression oracle for the emission pipeline.",
+    description: "Post-carrier golden hashes of the CSS emitted by derive-personality.mjs --emit --provisional for every design-tokens artifact (data/design-tokens/<slug>/), dark-inclusive: an artifact shipping design.tokens.dark.json hashes its emitted :root[data-theme=\"dark\"] block too. Hint-carrying twins are hashed at their provisional $values (--emit without --provisional still refuses on hints). Each entry records the sha256 of the comment-stripped personality.css and globals.css (see scripts/lib/golden.mjs). The byte-match regression oracle for the emission pipeline; the Tailwind compile smoke (emission contract 5) runs after every refresh.",
     generator: "scripts/snapshot-goldens.mjs",
     strip: "css-comments",
   },
@@ -59,10 +62,103 @@ for (const slug of Object.keys(goldens).sort()) document[slug] = goldens[slug];
 mkdirSync(dirname(goldensJsonPath), { recursive: true });
 writeFileSync(goldensJsonPath, JSON.stringify(document, null, 2) + "\n");
 
-console.log(`\n${entries.length} entries: ${Object.keys(goldens).length} OK, ${failures.length} FAIL`);
+console.log(`\n${entries.length} entries: ${Object.keys(goldens).length} OK (${provisional.length} provisional), ${failures.length} FAIL`);
 console.log(`goldens: ${goldensJsonPath}`);
 console.log(`emitted outputs: ${emitRoot}`);
 if (failures.length > 0) {
   for (const f of failures) console.error(`\nFAIL ${f.slug}:\n${f.error}`);
   process.exit(1);
 }
+
+// ---------------------------------------------------------------------------
+// Tailwind compile smoke (emission contract 5) — compile one emitted pair for real
+// ---------------------------------------------------------------------------
+
+// True when a spawn result reads as "npm cannot reach the registry" (the only degradable failure).
+function isNetworkFailure(res) {
+  const text = `${res.stderr || ""}${res.stdout || ""}`;
+  return res.error !== undefined || /ENOTFOUND|ETIMEDOUT|EAI_AGAIN|ECONNREFUSED|ENETUNREACH|network|offline/i.test(text);
+}
+
+// Compile the emitted pair of one slug with @tailwindcss/vite in a scratch project; exits non-zero
+// on a compile failure (the smoke is a gate). Degrades with a notice only when npm is unreachable.
+function runCompileSmoke(slug) {
+  const src = join(emitRoot, slug, "src", "styles");
+  if (!existsSync(join(src, "globals.css"))) {
+    console.error(`\ncompile smoke: no emitted output for ${slug} — cannot smoke`);
+    process.exit(1);
+  }
+  const smokeDir = process.env.GOLDENS_SMOKE_DIR || join(tmpdir(), "design-goldens-smoke");
+  mkdirSync(join(smokeDir, "src", "styles"), { recursive: true });
+
+  writeFileSync(join(smokeDir, "package.json"), JSON.stringify({
+    name: "design-goldens-smoke",
+    private: true,
+    type: "module",
+    devDependencies: { vite: "^7.0.0", tailwindcss: "^4.0.0", "@tailwindcss/vite": "^4.0.0" },
+  }, null, 2) + "\n");
+  writeFileSync(join(smokeDir, "vite.config.mjs"), `// design-goldens-smoke vite.config.mjs — @tailwindcss/vite over the emitted pair
+import { defineConfig } from "vite";
+import tailwindcss from "@tailwindcss/vite";
+export default defineConfig({ plugins: [tailwindcss()], logLevel: "error" });
+`);
+  // Utility classes in the content so the @theme-driven utilities (ramp, shadows, ladder roles,
+  // motion classes) actually generate — a bad @theme value fails here, not just at import.
+  writeFileSync(join(smokeDir, "index.html"), `<!doctype html>
+<html lang="en" data-style="${slug}" data-theme="light" data-density="standard">
+<head><meta charset="utf-8"><title>design-goldens-smoke</title></head>
+<body>
+  <div class="text-h1 tracking-tight p-4 gap-2 rounded-lg shadow-sm bg-surface-raised motion-lift">smoke</div>
+  <div class="text-display shadow-overlay bg-surface-overlay motion-stagger"><span>a</span><span>b</span></div>
+  <script type="module" src="/src/main.js"></script>
+</body>
+</html>
+`);
+  writeFileSync(join(smokeDir, "src", "main.js"), `// design-goldens-smoke entry — pulls the emitted pair through the Tailwind build
+import "./styles/globals.css";
+`);
+  for (const f of ["globals.css", "personality.css", "fonts.css"]) {
+    writeFileSync(join(smokeDir, "src", "styles", f), readFileSync(join(src, f), "utf8"));
+  }
+
+  if (!existsSync(join(smokeDir, "node_modules", "vite"))) {
+    const install = spawnSync("npm", ["install", "--no-audit", "--no-fund"], { cwd: smokeDir, encoding: "utf8" });
+    if (install.status !== 0) {
+      if (isNetworkFailure(install)) {
+        console.log(`\ncompile smoke SKIPPED — npm unreachable (${(install.stderr || "").split("\n")[0] || "no network"}); the goldens are hashed but this refresh is NOT compile-verified. Re-run snapshot-goldens.mjs online.`);
+        return;
+      }
+      console.error(`\ncompile smoke: npm install failed in ${smokeDir}:\n${(install.stderr || install.stdout || "").slice(0, 2000)}`);
+      process.exit(1);
+    }
+  }
+  // The library import resolves against a local stub: the smoke gates OUR emitted bytes compiling,
+  // not restricted-registry availability. Written after install so npm pruning cannot drop it.
+  const stubDir = join(smokeDir, "node_modules", "@nurix", "components");
+  mkdirSync(stubDir, { recursive: true });
+  writeFileSync(join(stubDir, "package.json"), JSON.stringify({ name: "@nurix/components", version: "0.0.0-smoke-stub", exports: { "./styles.css": "./styles.css" } }, null, 2) + "\n");
+  writeFileSync(join(stubDir, "styles.css"), `/* @nurix/components/styles.css — compile-smoke stub: import resolution + cascade shape only */
+:root { --background: oklch(1 0 0); --radius-sm: calc(var(--radius) - 4px); }
+`);
+  // The emitted fonts.css imports resolve against local @fontsource stubs for the same reason:
+  // the smoke gates OUR bytes compiling, never per-package registry availability.
+  const fontsCss = readFileSync(join(smokeDir, "src", "styles", "fonts.css"), "utf8");
+  for (const m of fontsCss.matchAll(/@import\s+['"]((@fontsource(?:-variable)?\/[^'"/]+)(?:\/([^'"]+))?)['"]/g)) {
+    const [, spec, pkgName, relFile] = m;
+    const rel = relFile || "index.css";
+    const pkgDir = join(smokeDir, "node_modules", ...pkgName.split("/"));
+    mkdirSync(dirname(join(pkgDir, rel)), { recursive: true });
+    writeFileSync(join(pkgDir, "package.json"), JSON.stringify({ name: pkgName, version: "0.0.0-smoke-stub" }, null, 2) + "\n");
+    writeFileSync(join(pkgDir, rel), `/* ${spec} — compile-smoke stub: import resolution only */\n`);
+  }
+
+  const build = spawnSync("npm", ["exec", "--no", "--", "vite", "build"], { cwd: smokeDir, encoding: "utf8" });
+  if (build.status !== 0) {
+    console.error(`\ncompile smoke FAILED — the emitted ${slug} pair does not compile under @tailwindcss/vite:`);
+    console.error((build.stderr || build.stdout || "").slice(0, 4000));
+    process.exit(1);
+  }
+  console.log(`compile smoke PASSED — emitted ${slug} pair compiles under @tailwindcss/vite (${smokeDir})`);
+}
+
+runCompileSmoke(goldens.nurix ? "nurix" : Object.keys(goldens).sort()[0]);