@bongos/core 1.24.55 → 1.24.57

package/scripts/bongos/fitness-ratchets.js

@@ -27,6 +27,13 @@
 //     docs-entropy scanner's three counts, reused as a library
 //   source_text_only_tests — test files that only read source text and match
 //     its wording, never running the code (task 1004868)
+//   design counts — PER STYLESHEET, the typed-in colours, font sizes, radii,
+//     shadows and breakpoints (task 1005093, goal 1000138; detector:
+//     css-literal-scan.js). Kept in their own `design_counts` object rather than
+//     `metrics` — ~60 sheets × 5 kinds would drown the metric line — but with the
+//     same verdict: higher than baseline fails, lower nudges a ratchet-down. A
+//     sheet with no baseline row has a baseline of zero, so a NEW sheet starts on
+//     the --ds-* tokens.
 //
 // The knip dead-code ratchet needs node_modules + ~seconds, so it is NOT part
 // of the in-suite check: CI runs `node scripts/bongos/fitness-ratchets.js --knip`
@@ -535,6 +542,46 @@ function skillListingMetrics() {
   }
 }
 
+// ---------- design counts (task 1005093) ----------
+
+const DESIGN_HINT = ' — use a --ds-* scale token (modules/ui-design/public/tokens.css) or one of the fifteen colour '
+  + 'tokens instead of a typed-in value (DESIGN.md, the Fifteen Rule). Run '
+  + '`node scripts/bongos/css-literal-scan.js` to see every sheet\'s counts and the rule.';
+
+// Current per-sheet counts, or null when the scan found no stylesheet at all —
+// a collapsed enumeration is a scan defect, never a flattering all-zero tree.
+function designCounts() {
+  const { scanCssLiterals } = require('./css-literal-scan.js');
+  const { sheets, scanned } = scanCssLiterals();
+  if (!scanned) {
+    process.stderr.write('fitness-ratchets: design counts NOT MEASURED — the stylesheet scan enumerated ZERO files, which is a scan defect, not a clean tree\n');
+    return null;
+  }
+  return sheets;
+}
+
+// Pure verdict over { sheet: { kind: n } } maps. Keys starting with `_` are notes.
+function compareDesignCounts(current, baseline) {
+  const { KINDS } = require('./css-literal-scan.js');
+  const violations = [];
+  const warnings = [];
+  const sheets = new Set([...Object.keys(current || {}), ...Object.keys(baseline || {})].filter((k) => !k.startsWith('_')));
+  for (const sheet of [...sheets].sort()) {
+    const cur = (current || {})[sheet] || {};
+    const base = (baseline || {})[sheet] || {};
+    for (const kind of KINDS) {
+      const value = cur[kind] || 0;
+      const floor = base[kind] || 0;
+      if (value > floor) {
+        violations.push(`design count ${kind} in ${sheet} regressed: ${value} > baseline ${floor} — fix the regression; never raise the baseline to pass${DESIGN_HINT}`);
+      } else if (value < floor) {
+        warnings.push(`ratchet-down available: design count ${kind} in ${sheet} improved to ${value} (baseline ${floor}) — lower it in config/fitness-baselines.json design_counts`);
+      }
+    }
+  }
+  return { violations, warnings };
+}
+
 function computeMetrics({ withDocs = true } = {}) {
   const files = trackedJsFiles();
   const contents = new Map(files.map((f) => [f, readRepoFile(f)]));
@@ -560,15 +607,28 @@ function computeMetrics({ withDocs = true } = {}) {
 // computeMetrics() sweep — git ls-files plus every tracked .js plus the
 // docs-entropy scan, measured at 23.7s + 2.5s + 2.8s, i.e. ~29s of this file's
 // 29s runtime, which is what pushed it into the 90s timeout in the first place.
-function checkQualityRatchets({ baselinePath = BASELINE_PATH, metrics: injectedMetrics = null } = {}) {
+// `designCounts` (task 1005093) is injectable the same way; when a test injects
+// `metrics` alone, the stylesheet scan is skipped rather than run for real.
+function checkQualityRatchets({ baselinePath = BASELINE_PATH, metrics: injectedMetrics = null, designCounts: injectedDesign = null } = {}) {
   const metrics = injectedMetrics === null ? computeMetrics() : injectedMetrics;
-  const { metrics: baselines, error: baselineError } = readBaselines(baselinePath);
+  const { metrics: baselines, error: baselineError, parsed } = readBaselines(baselinePath);
   const { violations, warnings } = compareToBaselines(metrics, baselines);
+  const design = injectedDesign !== null ? injectedDesign : (injectedMetrics === null ? designCounts() : null);
+  if (design) {
+    const designBaseline = parsed && parsed.design_counts;
+    if (!baselineError && (!designBaseline || typeof designBaseline !== 'object')) {
+      violations.push('config/fitness-baselines.json has no "design_counts" object — the per-stylesheet design ratchet cannot verify anything, so it fails CLOSED. Bootstrap deliberately: node scripts/bongos/fitness-ratchets.js --update-baselines');
+    } else if (designBaseline) {
+      const d = compareDesignCounts(design, designBaseline);
+      violations.push(...d.violations);
+      warnings.push(...d.warnings);
+    }
+  }
   // task 1003227: an unreadable baseline file is a hard failure, not silence. Put it
   // FIRST so it is the headline rather than buried under per-metric noise.
   if (baselineError) violations.unshift(baselineError);
   return {
-    name: 'quality ratchets — size, duplication, cycles, console, doc entropy, legacy GDS literals, source-text-only tests only tighten (task 1003129)',
+    name: 'quality ratchets — size, duplication, cycles, console, doc entropy, legacy GDS literals, source-text-only tests, per-stylesheet design counts only tighten (task 1003129)',
     hardFail: violations.length > 0,
     violations,
     warnings,
@@ -598,6 +658,12 @@ function main() {
     // this file cannot be eaten by a refresh either.
     const preserved = existingFile && typeof existingFile === 'object' ? { ...existingFile } : {};
     delete preserved.metrics;
+    // design_counts is recomputed too (task 1005093), keeping its `_` notes.
+    const design = designCounts();
+    if (design) {
+      const notes = Object.fromEntries(Object.entries(preserved.design_counts || {}).filter(([k]) => k.startsWith('_')));
+      preserved.design_counts = { ...notes, ...design };
+    }
     if (!preserved._comment) {
       preserved._comment = 'fitness-ratchets baselines (task 1003129): quality debt recorded at gate-adoption. Shrink-only — lower a value when the metric improves; raising one to pass CI is out of policy.';
     }
@@ -647,6 +713,7 @@ module.exports = {
   readBaselines,
   computeMetrics,
   compareToBaselines,
+  compareDesignCounts,
   sourceTextTestMetrics,
   duplicateWindowCount,
   normalizeLines,

package/scripts/bongos/fitness.js

@@ -200,7 +200,7 @@ function checkNestedDocsPresent() {
 // here would false-fail every PR (the gitignored whole file is absent from a clean checkout, so it
 // always reads as "would change"); `--check-block` is the exact, non-noisy gate. (docs/file-map.md +
 // the OpenAPI docs are still fully committed and unchanged by ADR 0110 — they keep the plain --check.)
-function checkGeneratedArtifactsFresh() {
+function checkGeneratedArtifactsFresh({ designRoot = REPO_ROOT } = {}) { // designRoot: tests only (task 1005093)
   const violations = [];
   try {
     execFileSync(process.execPath, [path.join(__dirname, 'gen-repo-map.js'), '--check-block'], { cwd: REPO_ROOT, stdio: 'pipe' });
@@ -254,9 +254,10 @@ function checkGeneratedArtifactsFresh() {
   } catch {
     violations.push('docs/page-inventory.json + docs/page-inventory.md are STALE (or two pages claim one id) — a page was added, renamed, retitled or changed its scripts/states. Run `node scripts/bongos/page-inventory.js` and commit (task 1004314).');
   }
+  violations.push(...require('./design-generators-fresh.js').checkDesignGeneratorsFresh(designRoot)); // task 1005093
   // NB the role packs' responsibility blocks are generated too, but their freshness
   // is asserted by role-pack-guard.js — one check owns "the packs are correct".
-  return { name: 'generated artifacts fresh', ok: violations.length === 0, hardFail: violations.length > 0, violations, warnings: [], note: 'Tracked generated content matches source: nested CLAUDE.md symbol blocks (code) + the CLAUDE.md §13 snippet (sessions) via --check-block, plus the CLAUDE.md §2 interaction-posture block (the knob defaults), docs/file-map.md skills/scheduled-tasks sections, the API spec + typed client GENERATE from the routes (both gitignored, task 1004866), docs/copy-registry.json + copy-inventory.md (the reader-facing copy, task 1003556) and docs/page-inventory.json + page-inventory.md (every page and its stable id, task 1004314). The gitignored docs/repo-map.md + docs/session-log-index.md are deploy-regenerated (ADR 0110), not gated here.' };
+  return { name: 'generated artifacts fresh', ok: violations.length === 0, hardFail: violations.length > 0, violations, warnings: [], note: 'Tracked generated content matches source: nested CLAUDE.md symbol blocks (code) + the CLAUDE.md §13 snippet (sessions) via --check-block, plus the CLAUDE.md §2 interaction-posture block (the knob defaults), docs/file-map.md skills/scheduled-tasks sections, the API spec + typed client GENERATE from the routes (both gitignored, task 1004866), docs/copy-registry.json + copy-inventory.md (the reader-facing copy, task 1003556) and docs/page-inventory.json + page-inventory.md (every page and its stable id, task 1004314), and the design system config/design-tokens.neutral.json + public /brand reference (task 1005093). The gitignored docs/repo-map.md + docs/session-log-index.md are deploy-regenerated (ADR 0110), not gated here.' };
 }
 
 // ---- deterministic cron routine boundary (System 4 / ADR 0078) -------------

package/scripts/gds/css-literal-scan.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// scripts/gds/css-literal-scan.js — @bongos-forwarder (task 1004848). Generated by
+// scripts/bongos/codemod-rename-scripts-gds.js; do not edit.
+// The real script is scripts/bongos/css-literal-scan.js. This forwarder keeps callers that still name
+// the old path working, and warns once so they get repointed. Task 1003706 removes it.
+'use strict';
+require('../bongos/forwarder.js').forward(module, 'css-literal-scan.js');

package/scripts/gds/design-generators-fresh.js

@@ -0,0 +1,6 @@
+// scripts/gds/design-generators-fresh.js — @bongos-forwarder (task 1004848). Generated by
+// scripts/bongos/codemod-rename-scripts-gds.js; do not edit.
+// The real script is scripts/bongos/design-generators-fresh.js. This forwarder keeps callers that still name
+// the old path working, and warns once so they get repointed. Task 1003706 removes it.
+'use strict';
+require('../bongos/forwarder.js').forward(module, 'design-generators-fresh.js');

package/src/bongos/module-scope-map.js

@@ -473,7 +473,7 @@ const MODULE_GLOBS = {
     'scripts/bongos/adr-namespace.js', 'scripts/bongos/baseline-staleness.js',
     'scripts/bongos/category-advisory-guard.js', 'scripts/bongos/client-baseurl-guard.js',
     'scripts/bongos/doc-cli-guard.js', 'scripts/bongos/doc-control-claims.js', 'scripts/bongos/doc-comment-coverage.js',
-    'scripts/bongos/exec-path-guard.js', 'scripts/bongos/fitness-lib.js',
+    'scripts/bongos/exec-path-guard.js', 'scripts/bongos/fitness-lib.js', 'scripts/bongos/design-generators-fresh.js',
     'scripts/bongos/fitness-checks-error-envelope.js', 'scripts/bongos/fitness-checks-identity.js',
     'scripts/bongos/fitness-checks-packaging.js', 'scripts/bongos/fitness-checks-route-pins.js',
     'scripts/bongos/fitness-checks-vocabulary.js', 'scripts/bongos/fitness-checks-write-validation.js',

package/src/module-api.js

@@ -81,7 +81,7 @@ const { sleep } = require('./sleep');
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.24.55'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.24.57'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');

package/tests/design_counts_ratchet.mjs

@@ -0,0 +1,134 @@
+// tests/design_counts_ratchet.mjs — design counts that can only go down, and the
+// design generators wired into the fitness freshness gate (task 1005093, goal 1000138).
+//
+// Done when: adding a new hard-coded font-size to a hall sheet fails fitness, and
+// editing the shared token sheet without regenerating fails the freshness gate.
+// Both are proved here on the real tree: the first by scanning the real sheets with
+// one extra declaration, the second by running the gate on a copied tree.
+//
+// Run:  node --test tests/design_counts_ratchet.mjs
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const scan = require(path.join(ROOT, 'scripts', 'bongos', 'css-literal-scan.js'));
+const ratchets = require(path.join(ROOT, 'scripts', 'bongos', 'fitness-ratchets.js'));
+const fitness = require(path.join(ROOT, 'scripts', 'bongos', 'fitness.js'));
+const { checkDesignGeneratorsFresh } = require(path.join(ROOT, 'scripts', 'bongos', 'design-generators-fresh.js'));
+
+const HALL_SHEET = 'modules/hall-ui/public/style.css';
+const readReal = (f) => fs.readFileSync(path.join(ROOT, f), 'utf8');
+
+test('the detector counts typed-in values and leaves tokens alone', () => {
+  const c = scan.countSheet(`
+    :root { --ds-x: 14px; --tone: #123456; }            /* token definitions: not counted */
+    .a { font-size: 13px; border-radius: 6px; color: #abc; }
+    .b { font-size: var(--ds-text-sm); border-radius: var(--ds-radius-tile); color: var(--ink); }
+    .c { box-shadow: 0 2px 4px rgba(0, 0, 0, .2); }      /* a shadow; the black scrim is allowed */
+    .d { box-shadow: none; background: url("data:image/svg+xml;fill='#fff'"); }
+    .e { background: color-mix(in srgb, var(--ink) 40%, rgb(12 34 56)); padding: 0; }
+    @media (max-width: 720px) { .f { border-radius: 0; } }
+    @media (prefers-reduced-motion: reduce) { .g { transition: none; } }
+  `);
+  assert.deepEqual(c, { colours: 2, font_sizes: 1, radii: 1, shadows: 1, breakpoints: 1 });
+});
+
+test('a selector with a colon is not read as a declaration', () => {
+  assert.equal(scan.countSheet('a:hover, b:focus-visible { color: var(--ink); }').colours, 0);
+});
+
+test('the real tree matches its committed design-count baselines', () => {
+  const { sheets, scanned } = scan.scanCssLiterals();
+  assert.ok(scanned > 40, `the scan should see the live stylesheets (saw ${scanned})`);
+  const r = ratchets.checkQualityRatchets({ metrics: {}, designCounts: sheets });
+  assert.deepEqual(r.violations, [], 'design counts regressed against config/fitness-baselines.json');
+});
+
+test('a NEW hard-coded font-size in a hall sheet fails fitness', () => {
+  const { sheets } = scan.scanCssLiterals({
+    read: (f) => readReal(f) + (f === HALL_SHEET ? '\n.planted { font-size: 13px; }\n' : ''),
+  });
+  const r = ratchets.checkQualityRatchets({ metrics: {}, designCounts: sheets });
+  assert.equal(r.hardFail, true);
+  assert.ok(r.violations.some((v) => v.includes(`font_sizes in ${HALL_SHEET} regressed`)), r.violations.join('\n'));
+});
+
+test('a new sheet starts at zero: any typed-in colour in it fails', () => {
+  const d = ratchets.compareDesignCounts({ 'modules/x/public/new.css': { colours: 1 } }, { _comment: 'note' });
+  assert.equal(d.violations.length, 1);
+  assert.match(d.violations[0], /colours in modules\/x\/public\/new\.css regressed: 1 > baseline 0/);
+});
+
+test('a lower count nudges a ratchet-down and does not fail', () => {
+  const d = ratchets.compareDesignCounts({ 'a.css': { radii: 2 } }, { 'a.css': { radii: 3 } });
+  assert.deepEqual(d.violations, []);
+  assert.match(d.warnings[0], /ratchet-down available: design count radii in a\.css improved to 2/);
+});
+
+test('a baseline file with no design_counts fails closed', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'design-counts-'));
+  const file = path.join(dir, 'baselines.json');
+  fs.writeFileSync(file, JSON.stringify({ metrics: {} }));
+  try {
+    const r = ratchets.checkQualityRatchets({ baselinePath: file, metrics: {}, designCounts: {} });
+    assert.equal(r.hardFail, true);
+    assert.match(r.violations[0], /no "design_counts" object/);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// The generators resolve their sources from their own location, so a copy of the
+// files they read is a complete, isolated tree the gate can run against.
+const GENERATOR_SOURCES = [
+  'config/branding.neutral.json',
+  'config/design-tokens.neutral.json',
+  'modules/ui-design/public/tokens.css',
+  'modules/ui-design/public/brand.html',
+  'modules/ui-design/public/brand',
+  'modules/ui-design/scripts/gen-design-tokens.js',
+  'modules/ui-design/scripts/gen-design-reference.js',
+  'modules/hall-ui/public/style.css',
+  'modules/hall-ui/public/controls.css',
+  'modules/hall-ui/public/dom-utils.js',
+  'scripts/bongos/gen-brand.js',
+  'DESIGN.md',
+];
+
+function copiedTree() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'design-fresh-'));
+  for (const rel of GENERATOR_SOURCES) {
+    fs.mkdirSync(path.dirname(path.join(dir, rel)), { recursive: true });
+    fs.cpSync(path.join(ROOT, rel), path.join(dir, rel), { recursive: true });
+  }
+  return dir;
+}
+
+test('the freshness gate passes on a fresh tree and fails when the token sheet changes without a regeneration', () => {
+  const dir = copiedTree();
+  try {
+    assert.deepEqual(checkDesignGeneratorsFresh(dir), [], 'the copied tree should start fresh');
+    const sheet = path.join(dir, 'modules/ui-design/public/tokens.css');
+    const before = fs.readFileSync(sheet, 'utf8');
+    const after = before.replace(/--ds-space-xs:\s*[^;]+;/, '--ds-space-xs: 11px;');
+    assert.notEqual(after, before, 'the token sheet should declare --ds-space-xs');
+    fs.writeFileSync(sheet, after);
+    const v = checkDesignGeneratorsFresh(dir);
+    assert.ok(v.some((x) => x.startsWith('config/design-tokens.neutral.json is STALE')), v.join('\n'));
+    assert.ok(v.some((x) => x.startsWith('modules/ui-design/public/brand.html')), v.join('\n'));
+    // …and the registered fitness check carries that verdict, so the build goes red.
+    assert.ok(fitness.CHECKS.includes(fitness.checkGeneratedArtifactsFresh));
+    const gate = fitness.checkGeneratedArtifactsFresh({ designRoot: dir });
+    assert.equal(gate.hardFail, true);
+    assert.ok(gate.violations.some((x) => x.startsWith('config/design-tokens.neutral.json is STALE')), gate.violations.join('\n'));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

package/tests/hall_catalog_world.mjs

@@ -168,10 +168,15 @@ test('the shell no longer aliases .mod-chip onto the pill', () => {
 
 test('atlas: the nine semantic colours stay fixed literals, and nothing else in the sheet is one', () => {
   const css = read('atlas.css');
-  for (const t of ['--ab-sun', '--ab-sky', '--ab-coral', '--ab-paper', '--ab-good', '--ab-core', '--ab-db', '--ab-ghost', '--ab-danger']) {
+  for (const t of ['--ab-sun', '--ab-sky', '--ab-coral', '--ab-paper', '--ab-ghost']) {
     assert.match(css, new RegExp(`${t}:#[0-9a-f]{6}`), `${t} is a fixed literal (ADR 0094)`);
   }
-  const rest = decomment(css).replace(/--ab-(sun|sky|coral|paper|good|core|db|ghost|danger):#[0-9a-f]{6}/g, '');
+  // task 1005087: the four STATE colours are the hall's status vocabulary — fixed per instance
+  // (never the pack's), so ADR 0094's no-scramble invariant still holds, and no longer Tailwind's.
+  for (const [t, tok] of [['--ab-good', '--ok'], ['--ab-core', '--warn'], ['--ab-db', '--danger'], ['--ab-danger', '--danger']]) {
+    assert.match(css, new RegExp(`${t}:var\\(${tok}\\)`), `${t} is the hall's ${tok}`);
+  }
+  const rest = decomment(css).replace(/--ab-(sun|sky|coral|paper|ghost):#[0-9a-f]{6}/g, '');
   assert.deepEqual(rest.match(/#[0-9a-f]{3,8}\b/gi) || [], [], 'no other literal colour');
   noAlias(css, 'atlas.css');
   tokensDefined(css, 'atlas.css');

package/tests/hall_city.mjs

@@ -25,6 +25,7 @@ import path from 'node:path';
 import vm from 'node:vm';
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
+import { cityTokens } from './helpers.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const PUB = path.join(ROOT, 'modules/hall-ui/public');
@@ -66,13 +67,13 @@ test('the nine civic recipes draw exactly the prototype paths, in both modes', (
       const a = []; const b = [];
       p.isoInstitution(a, pk, kind, x, y, { fixes: false });
       City.isoInstitution(b, ck, kind, x, y, { fixes: false });
-      assert.deepEqual(b, a, `${mode} ${kind}`);
+      assert.deepEqual(b, cityTokens(a), `${mode} ${kind}`);
     }
   }
 });
 
 test('the iso sub-palette is the prototype theme().iso, both modes', () => {
-  for (const mode of ['dark', 'light']) assert.deepEqual(City.isoTheme(mode), new Proto({ mode }).theme(mode).iso, mode);
+  for (const mode of ['dark', 'light']) assert.deepEqual(City.isoTheme(mode), cityTokens(new Proto({ mode }).theme(mode).iso), mode);
 });
 
 test('every work kind the prototype draws is drawn the same way', () => {
@@ -83,7 +84,7 @@ test('every work kind the prototype draws is drawn the same way', () => {
     const a = []; const b = [];
     p.isoWork(a, pk, 6, 2, kind, 58);
     City.isoWork(b, ck, 6, 2, kind, 58);
-    assert.deepEqual(b, a, kind);
+    assert.deepEqual(b, cityTokens(a), kind);
   }
 });
 
@@ -95,7 +96,7 @@ test('the ground, ring road, lanes and plaza are the prototype home view, path f
   const home = p.homeView(T, p.matters(), false);
   const model = City.cityModel({ docket: docket([matter()]), goals: [], rollups: [], mode: 'light' });
   // The prototype's flat list is ground, 4 roads, lanes, plaza, then its 4 plots and their grid.
-  assert.deepEqual(model.flat.slice(0, 7), home.flat.slice(0, 7));
+  assert.deepEqual(model.flat.slice(0, 7), cityTokens(home.flat.slice(0, 7)));
 });
 
 test('with four goals the districts sit on the prototype\'s four plots, in its order', () => {

package/tests/hall_private_palettes.mjs

@@ -0,0 +1,148 @@
+// tests/hall_private_palettes.mjs — the hall's private-palette rooms mix the shared tokens only
+// (task 1005087, goal 1000138 "One Cloud Bongos design system").
+//
+// The UI audit found Studio, Thinking (the sky), the Tweak editor, City, Approvals, Atlas and the
+// welcome screen each re-typing the salmon and the ink, their own font stacks, and off-the-shelf
+// green / amber / red — so a re-branded instance saw those rooms in Cloud Bongos's colours. This
+// scans every sheet and script of those rooms (comments stripped) and fails on:
+//   * a hex, an rgb()/rgba() or a bare [r, g, b] triple equal to one of the pack's colours, the
+//     hall's dark-tier inks, the accent's light tint, or an off-the-shelf status green/amber/red;
+//   * a font family typed in by name instead of the pack's stacks;
+//   * an overshooting (bounce) easing;
+//   * the welcome screen's beacon or star twinkle coming back.
+// Black and white (with or without alpha) stay legal: they are scrims, halos and the glass rooms'
+// inks. Each guard was watched go red on the pre-task sheets.
+import { test, after } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const kit = require('../modules/ui-design/kit/lib.js');
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const PUB = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const ROOMS = /^(studio|thinking|sky-|tweak-editor|city|approval-queue|atlas|welcome-boot)/;
+const FILES = fs.readdirSync(PUB).filter((f) => ROOMS.test(f) && /\.(css|js|html)$/.test(f));
+
+const strip = (s) => s.replace(/\/\*[\s\S]*?\*\//g, '').replace(/<!--[\s\S]*?-->/g, '').replace(/(^|[^:'"`\\])\/\/[^\n]*/g, '$1');
+
+const PACK = Object.values(JSON.parse(fs.readFileSync(path.join(ROOT, 'config', 'branding.neutral.json'), 'utf8')).theme.ui.colors);
+const BRAND = new Set([...PACK,
+  // the hall's dark-tier inks and grounds, and the accent's light tint the glass rooms used for links
+  '#101012', '#08080a', '#c0c0c0', '#a8a8a8', '#fcbfa4', '#96410f',
+  // off-the-shelf status green / amber / red (Tailwind's, and the rooms' own copies of them)
+  '#10b981', '#22c55e', '#4ade80', '#16a34a', '#15803d', '#166534', '#1f7a44',
+  '#f59e0b', '#fbbf24', '#facc15', '#d97706', '#b45309', '#92400e', '#8f6a0c',
+  '#ef4444', '#dc2626', '#b91c1c', '#991b1b', '#f87171', '#bb1f1f',
+].map((h) => h.toLowerCase()));
+const tripleOf = (h) => [1, 3, 5].map((i) => parseInt(h.slice(i, i + 2), 16)).join(',');
+const TRIPLES = new Set([...BRAND].map(tripleOf));
+
+function brandLiterals(src) {
+  const s = strip(src);
+  const hits = [];
+  for (const m of s.matchAll(/#[0-9a-f]{6}\b/gi)) if (BRAND.has(m[0].toLowerCase())) hits.push(m[0]);
+  for (const m of s.matchAll(/rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/gi)) if (TRIPLES.has(`${+m[1]},${+m[2]},${+m[3]}`)) hits.push(m[0]);
+  for (const m of s.matchAll(/\[\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\]/g)) if (TRIPLES.has(`${+m[1]},${+m[2]},${+m[3]}`)) hits.push(m[0]);
+  for (const m of s.matchAll(/--[a-z-]+-rgb\s*:\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/gi)) if (TRIPLES.has(`${+m[1]},${+m[2]},${+m[3]}`)) hits.push(m[0]);
+  return hits;
+}
+
+test('the rooms are all here (the scan is not vacuous)', () => {
+  for (const f of ['studio.css', 'thinking.css', 'sky-draw.js', 'tweak-editor.css', 'city.css', 'city-draw.js', 'approval-queue.css', 'atlas.css', 'atlas.js', 'welcome-boot.css', 'welcome-boot.js']) {
+    assert.ok(FILES.includes(f), `${f} is scanned`);
+  }
+});
+
+test('no hex, rgb or [r, g, b] literal for a brand colour or an off-the-shelf status colour remains', () => {
+  const found = {};
+  for (const f of FILES) { const h = brandLiterals(fs.readFileSync(path.join(PUB, f), 'utf8')); if (h.length) found[f] = [...new Set(h)]; }
+  assert.deepEqual(found, {}, 'mix the shared tokens (the pack\'s, the status vocabulary) instead');
+});
+
+test('the scan catches each shape of brand literal, and spares black, white and comments', () => {
+  assert.deepEqual(brandLiterals('a { color: #FB9569; }'), ['#FB9569']);
+  assert.deepEqual(brandLiterals('a { color: rgba(23, 24, 26, .4); }'), ['rgba(23, 24, 26']);
+  assert.deepEqual(brandLiterals('const ACC = [251, 149, 105];'), ['[251, 149, 105]']);
+  assert.deepEqual(brandLiterals('--sky-accent-rgb: 251,149,105;'), ['--sky-accent-rgb: 251,149,105']);
+  assert.deepEqual(brandLiterals("dot: '#f59e0b'"), ['#f59e0b']);
+  assert.deepEqual(brandLiterals('/* was #fb9569 */ a { color: rgba(0, 0, 0, .5); background: #ffffff; }'), []);
+});
+
+test('no room types a font family by name: the pack\'s stacks only', () => {
+  const hits = [];
+  for (const f of FILES.filter((n) => /\.(css|js)$/.test(n))) {
+    const s = strip(fs.readFileSync(path.join(PUB, f), 'utf8'));
+    if (/Manrope|JetBrains Mono|Segoe UI|Helvetica|Arial\b/.test(s)) hits.push(f);
+  }
+  assert.deepEqual(hits, [], 'use var(--font-body) / var(--font-display) / var(--font-mono)');
+});
+
+test('no bounce: no easing in the rooms overshoots (use --ds-ease / --ds-ease-arrive)', () => {
+  const hits = [];
+  for (const f of FILES) {
+    const s = strip(fs.readFileSync(path.join(PUB, f), 'utf8'));
+    for (const m of s.matchAll(/cubic-bezier\(\s*([-\d.]+)\s*,\s*([-\d.]+)\s*,\s*([-\d.]+)\s*,\s*([-\d.]+)\s*\)/g)) {
+      if (+m[2] > 1 || +m[4] > 1 || +m[2] < 0 || +m[4] < 0) hits.push(`${f}: ${m[0]}`);
+    }
+  }
+  assert.deepEqual(hits, []);
+});
+
+test('the welcome screen keeps no beacon and no twinkle', () => {
+  const css = strip(fs.readFileSync(path.join(PUB, 'welcome-boot.css'), 'utf8'));
+  const js = strip(fs.readFileSync(path.join(PUB, 'welcome-boot.js'), 'utf8'));
+  assert.doesNotMatch(css, /wb-beacon|wb-twinkle/, 'no beacon blink, no star twinkle in the sheet');
+  assert.doesNotMatch(js, /wb-beacon/, 'the script draws no beacon');
+  assert.doesNotMatch(js, /\.wb-star[^]*animation-duration/, 'no star carries a twinkle timing');
+});
+
+// ── the done-when, in a browser: a re-branded look renders the rooms in its own colours ──
+// The ui-design kit's stub serves the hall under a look from the style library (grove: a
+// sand accent), and every computed colour on each room is checked for the neutral pack's
+// salmon. Skips when the machine has no system Edge or Chrome, as ui_design_kit_fit does.
+let browser = null;
+try { browser = await kit.launchBrowser(); } catch (e) { if (!(e instanceof kit.NoBrowserError)) throw e; }
+after(() => browser && browser.close());
+
+test('under the grove look, Thinking, the Tweak editor, Atlas, City and Studio show no salmon in either mode', { skip: !browser && 'no system Edge or Chrome', timeout: 180000 }, async () => {
+  const stub = await kit.startStub({ surface: 'hall-ui', prefix: '/builders/', style: 'grove', auth: true });
+  try {
+    for (const mode of ['dark', 'light']) {
+      const ctx = await browser.newContext({ viewport: { width: 1280, height: 860 }, colorScheme: mode });
+      await ctx.addInitScript(() => { try { sessionStorage.setItem('hall-craft-asked', '1'); } catch (e) { /* private mode */ } });
+      for (const room of ['thinking', 'tweak-editor', 'atlas', 'city', 'studio']) {
+        const page = await ctx.newPage();
+        await page.goto(`${stub.base}/builders/${room}`, { waitUntil: 'load' });
+        await page.waitForTimeout(800);
+        const r = await page.evaluate(() => {
+          const SALMON = /\b251,\s*149,\s*105\b/;
+          const hits = [];
+          for (const el of document.querySelectorAll('*')) {
+            const cs = getComputedStyle(el);
+            for (const k of ['color', 'backgroundColor', 'borderTopColor', 'fill', 'stroke', 'outlineColor', 'boxShadow', 'backgroundImage']) {
+              if (SALMON.test(cs[k] || '')) hits.push(`${el.tagName.toLowerCase()} ${k}`);
+            }
+          }
+          return { accent: getComputedStyle(document.documentElement).getPropertyValue('--accent').trim().toLowerCase(), hits };
+        });
+        await page.close();
+        assert.notEqual(r.accent, '#fb9569', `${mode} ${room}: the look's accent is applied`);
+        assert.deepEqual(r.hits, [], `${mode} ${room}: no salmon left`);
+      }
+      await ctx.close();
+    }
+  } finally { stub.stop(); }
+});
+
+test('the sky reads its colours off the stage as tokens, not channels', () => {
+  const css = strip(fs.readFileSync(path.join(PUB, 'thinking.css'), 'utf8'));
+  assert.doesNotMatch(css, /--sky-[a-z]+-rgb/, 'no rgb channel tokens');
+  assert.match(css, /--void:\s*var\(--bg\)/, 'the void is the hall\'s ground');
+  assert.match(css, /--accent:\s*var\(--accent-ink\)/, 'the accent is the pack\'s (darkened on paper by the hall\'s own rule)');
+  const draw = fs.readFileSync(path.join(PUB, 'sky-draw.js'), 'utf8');
+  for (const tok of ['--ink', '--void', '--sky-cold', '--accent', '--chart']) assert.match(draw, new RegExp(`fill\\('${tok}'`), `sky-draw reads ${tok}`);
+});

package/tests/hall_sky.mjs

@@ -559,65 +559,62 @@ const skyBlocks = () => {
   return { dark: dark && dark[1], light: light && light[1], twin: twin && twin[1] };
 };
 
+// What the stage's computed style answers in each theme: the two blocks above,
+// read the way the browser would.
+const stageStyles = (body) => Object.fromEntries([...body.matchAll(/(--[\w-]+)\s*:\s*([^;]+);/g)].map((m) => [m[1], m[2].trim()]));
+
 await test('LIGHT IS WRITTEN TWICE AND THE TWO ARE ONE — the data-theme block and its first-paint twin declare the same lines', () => {
   const { dark, light, twin } = skyBlocks();
-  assert.ok(dark, 'the dark (template) token block is found');
+  assert.ok(dark, 'the stage token block is found');
   assert.ok(light, 'the html[data-theme="light"] block is found');
   assert.ok(twin, 'the prefers-color-scheme: light twin is found');
   same(declLines(twin), declLines(light), 'the twin is the data-theme block, line for line');
-  assert.ok(declLines(light).length >= 6, 'and the block is not vacuously empty');
-});
-
-await test('light re-declares every colour the dark set declares, and every channel is three bytes', () => {
-  const { dark, light } = skyBlocks();
-  const type = new Set(['--label', '--mono', '--face']); // the faces are not a theme
-  const want = [...declNames(dark)].filter((n) => !type.has(n));
-  assert.ok(want.length >= 15, `the dark set names its colours (${want.length})`);
-  const have = declNames(light);
-  same(want.filter((n) => !have.has(n)), [], 'no dark colour is left for light to inherit');
-  for (const [name, body] of [['dark', dark], ['light', light]]) {
-    const chans = [...body.matchAll(/(--sky-[\w-]+-rgb)\s*:\s*([^;]+);/g)];
-    assert.ok(chans.length >= 5, `${name} declares the canvas's channels`);
-    for (const [, n, v] of chans) {
-      const parts = v.split(',').map((x) => Number(x.trim()));
-      assert.ok(parts.length === 3 && parts.every((x) => Number.isInteger(x) && x >= 0 && x <= 255), `${name} ${n} is r,g,b (got "${v}")`);
-    }
-  }
+  same([...declNames(light)].sort(), ['--sky-drop', '--sky-temp', 'color-scheme'], 'and it carries only what the hall\'s own tier cannot: the card shadow and the canvas warmth');
 });
 
-// What the stage's computed style answers in each theme: the two blocks above,
-// read the way the browser would.
-const stageStyles = (body) => Object.fromEntries([...body.matchAll(/(--[\w-]+)\s*:\s*([^;]+);/g)].map((m) => [m[1], m[2].trim()]));
+// task 1005087: the sky's colours are the HALL's tokens, which already flip with the theme and
+// follow the pack, so a re-branded instance's sky wears its colours. No literal, no rgb channel.
+await test('the stage mixes the hall\'s tokens only: every colour is a var() or a color-mix of them', () => {
+  const { dark } = skyBlocks();
+  const type = new Set(['--label', '--mono', '--face', '--sky-temp', '--sky-drop']);
+  const colours = Object.entries(stageStyles(dark)).filter(([n]) => !type.has(n));
+  assert.ok(colours.length >= 10, `the stage names its colours (${colours.length})`);
+  for (const [n, v] of colours) assert.match(v, /^(var\(--[\w-]+\)|color-mix\(in srgb, var\(--[\w-]+\) [\d.]+%, (transparent|var\(--[\w-]+\))\))$/, `${n}: ${v}`);
+  assert.doesNotMatch(SKY_CSS.replace(/\/\*[\s\S]*?\*\//g, ''), /--sky-[\w-]+-rgb/, 'no rgb channel is left');
+});
+
+// The stage's computed colours in each theme, as the browser answers the probe sky-draw.js reads.
+const DARK = { '--ink': 'rgb(255, 255, 255)', '--void': 'rgb(0, 0, 0)', '--sky-cold': 'color(srgb 0.08 0.08 0.08)', '--accent': 'rgb(251, 149, 105)', '--chart': 'rgb(251, 191, 36)', '--sky-temp': '1' };
+const LIGHT = { '--ink': 'rgb(23, 24, 26)', '--void': 'rgb(237, 236, 238)', '--sky-cold': 'color(srgb 0.88 0.88 0.89)', '--accent': 'rgb(163, 72, 26)', '--chart': 'rgb(180, 83, 9)', '--sky-temp': '.42' };
 
 await test('THE CANVAS FOLLOWS THE TOGGLE — a theme flip re-reads the stage and repaints, with no reload', async () => {
-  const { dark, light } = skyBlocks();
-  const styles = stageStyles(dark);
+  const styles = { ...DARK };
   const p = await boot({ mine: mine(FIVE()), sky: sky([well()]), versions: versions(), styles });
   const SKY = p.SKY(); const acc = SKY.ACC;
   assert.ok(p.themeObservers() >= 1, 'the page watches html[data-theme]');
   p.frame();
-  same(SKY.INK, [255, 255, 255], 'dark: the ink is the template white');
+  same(SKY.INK, [255, 255, 255], 'dark: the ink is the hall\'s white');
   same(SKY.VOID, [0, 0, 0], 'dark: the void is black');
   same(SKY.tone([255, 238, 222]), [255, 238, 222], 'dark: a thought keeps its temperature');
 
-  Object.assign(styles, stageStyles(light));
+  Object.assign(styles, LIGHT);
   p.S().dirty = false;
   p.setTheme('light');
   assert.equal(!!p.S().dirty, true, 'the flip marks the sky for a redraw');
   p.frame();
-  same(SKY.INK, stageStyles(light)['--sky-ink-rgb'].split(',').map(Number), 'light: the ink is the stage\'s');
-  same(SKY.VOID, stageStyles(light)['--sky-void-rgb'].split(',').map(Number), 'light: the void is paper');
-  same(SKY.ACC, stageStyles(light)['--sky-accent-rgb'].split(',').map(Number), 'light: the accent darkens');
+  same(SKY.INK, [23, 24, 26], 'light: the ink is the stage\'s');
+  same(SKY.VOID, [237, 236, 238], 'light: the void is paper');
+  same(SKY.ACC, [163, 72, 26], 'light: the accent darkens');
   assert.equal(SKY.ACC === acc, true, 'refilled in place, so SKY.ACC is still the object every file holds');
-  const k = Number(stageStyles(light)['--sky-temp']);
-  same(SKY.tone([255, 238, 222]), [255, 238, 222].map((v) => Math.round(v * k)), 'light: a near-white thought darkens to read on paper');
+  same(SKY.tone([255, 238, 222]), [255, 238, 222].map((v) => Math.round(v * 0.42)), 'light: a near-white thought darkens to read on paper');
   assert.equal(SKY.ink(0.5), `rgba(${SKY.INK.join(',')},0.5)`, 'ink() paints in the new ink');
 
-  Object.assign(styles, stageStyles(dark));
+  Object.assign(styles, DARK);
   p.setTheme('dark');
   p.frame();
   same(SKY.INK, [255, 255, 255], 'and back: the white returns');
   assert.equal(SKY.ink(0.5), 'rgba(255,255,255,0.5)', 'ink() forgot the light strings');
 });
 
+
 summary();