@bongos/core 1.24.79 → 1.24.81

package/tests/hall_city.mjs

@@ -12,8 +12,8 @@
 //     the ring road, or a task with no building;
 //   * the line under the button saying anything but the docket's own line;
 //   * the start governing button going anywhere but the street;
-//   * the switch not using the hall's own preference, so the city opens in a
-//     different mode from every other hall page;
+//   * a light/dark switch coming back: the hall is dark only (task 1005192,
+//     ADR 0402), so the city draws its night faces and reads no stored choice;
 //   * motion that escapes the Kill Switch, or docket text reaching innerHTML.
 //
 // Run:  node tests/hall_city.mjs
@@ -263,7 +263,7 @@ test('parcels ride only the roads of plots that hold a district, and leave throu
 
 // ── the page ────────────────────────────────────────────────────────────────
 
-test('the page holds only the wordmark, the switch, the city, one button and one line', () => {
+test('the page holds only the wordmark, the city, one door and one line, and no light/dark switch', () => {
   const html = read('city.html').replace(/<!--[\s\S]*?-->/g, ''); // the markup, not the prose about it
   assert.equal((html.match(/<header\b/g) || []).length, 1);
   assert.equal((html.match(/<main\b/g) || []).length, 1);
@@ -271,7 +271,8 @@ test('the page holds only the wordmark, the switch, the city, one button and one
   assert.match(html, /<a class="city-start" id="cityStart" href="#decide"/);
   assert.equal((html.match(/<a\b/g) || []).length, 3, 'one door, and the two faint archived links to the street');
   assert.ok(html.includes('<p class="city-archived">Archived: <a href="/builders/street">Street</a> &amp; <a href="/builders/street#building=charter">Building Level Views</a>.</p>'), 'the street is archived behind two faint links');
-  assert.equal((html.match(/<button\b/g) || []).length, 1, 'one switch');
+  assert.equal((html.match(/<button\b/g) || []).length, 0, 'no switch: the hall is dark only (task 1005192, ADR 0402)');
+  assert.doesNotMatch(html, /cityMode/);
   assert.match(html, /class="city-mark">\{\{productName\}\}</);
   assert.equal(City.STREET_HREF, '/builders/street');
 });
@@ -289,7 +290,7 @@ test('the city sits in the hall chrome, behind the shell\'s full-screen switch',
   // task 1004685 (the living city): gov-living.js, the model under the drawing, and
   // gov-feeds.js, its one reader per page (shared with the shell's tally), load before it
   // task 1004702: the card answers its first ask in place, so the deck's card and sender (and the desk rows under them) load before the page
-  assert.deepEqual(scripts, ['dom-utils', 'shell-game', 'shell-trail', 'craft-mode', 'shell', 'hall-dialog', 'palette', 'gov-living', 'gov-feeds', 'city-draw', 'hall-kit', 'street-draw', 'street-card', 'street-inside', 'street-desk', 'street-deck', 'city-decide', 'city-switchboard', 'city'], 'the shell first, then the shared dialog (task 1005085), as on every hall page');
+  assert.deepEqual(scripts, ['dom-utils', 'shell-game', 'shell-trail', 'craft-mode', 'shell', 'hall-dialog', 'visor', 'palette', 'gov-living', 'gov-feeds', 'city-draw', 'hall-kit', 'street-draw', 'street-card', 'street-inside', 'street-desk', 'street-deck', 'city-decide', 'city-switchboard', 'city'], 'the shell first, then the shared dialog (task 1005085) and the visor (task 1005148)');
   // task 1004925: every script but dom-utils.js is deferred, so none holds up the
   // parser; defer runs them in document order, which is why the order above still
   // holds. dom-utils.js stays synchronous: the one-escaper guard
@@ -346,7 +347,7 @@ function fakeDom() {
     return el;
   };
   const html = mk('html');
-  for (const id of ['cityMode', 'cityModeIcon', 'cityStage', 'cityFlat', 'cityBlds', 'cityParcels', 'cityPins', 'cityLine', 'cityStart']) mk('x').setAttribute('id', id);
+  for (const id of ['cityStage', 'cityFlat', 'cityBlds', 'cityParcels', 'cityPins', 'cityLine', 'cityStart']) mk('x').setAttribute('id', id);
   const document = {
     documentElement: html,
     getElementById: (id) => byId.get(id) || null,
@@ -421,33 +422,18 @@ test('a failed docket read draws no pins and says the docket could not be read',
   assert.equal(p.byId.get('cityLine').textContent, City.FALLBACK_LINE);
 });
 
-test('the switch reads and writes the hall\'s own theme preference', async () => {
-  const p = await bootPage({ feeds: FEEDS([]), stored: 'light', osDark: true });
-  assert.equal(p.html.attrs['data-theme'], 'light', 'the stored hall choice beats the OS');
-  assert.equal(p.byId.get('cityMode').attrs['aria-label'], 'Switch to dark mode');
-  const before = JSON.stringify(p.byId.get('cityFlat').children[0].attrs);
-  p.byId.get('cityMode').fire('click');
-  assert.equal(p.store.get('hall-theme'), 'dark');
-  assert.equal(p.html.attrs['data-theme'], 'dark');
-  assert.equal(p.byId.get('cityMode').attrs['aria-label'], 'Switch to light mode');
-  assert.notEqual(JSON.stringify(p.byId.get('cityFlat').children[0].attrs), before, 'the city redraws in the new mode');
+test('the city is dark only: no stored choice and no OS setting reaches it (task 1005192, ADR 0402)', async () => {
+  const p = await bootPage({ feeds: FEEDS([]), stored: 'light', osDark: false, shell: { applyTheme() { throw new Error('the city no longer drives the shell'); } } });
+  assert.equal(p.html.attrs['data-theme'], 'dark', 'a stored light choice and a light OS are both ignored');
+  assert.equal(p.store.get('hall-theme'), 'light', 'and the old preference is never written');
+  assert.equal(p.observers.length, 0, 'nothing flips the theme, so nothing watches it');
   const q = await bootPage({ feeds: FEEDS([]), stored: null, osDark: true });
-  assert.equal(q.html.attrs['data-theme'], 'dark', 'no stored choice follows the OS');
+  assert.equal(JSON.stringify(q.byId.get('cityFlat').children[0].attrs), JSON.stringify(p.byId.get('cityFlat').children[0].attrs), 'one drawing whatever was stored');
+  const src = read('city.js');
+  assert.doesNotMatch(src, /hall-theme|localStorage|prefers-color-scheme/, 'city.js reads no theme preference');
 });
 
-test('in the hall, the city and the top bar\'s theme switch never disagree (task 1004544)', async () => {
-  let shellPaints = 0;
-  const p = await bootPage({ feeds: FEEDS([]), stored: 'light', osDark: true, shell: { applyTheme() { shellPaints++; } } });
-  assert.equal(p.observers.length, 1, 'the page watches html[data-theme]');
-  p.byId.get('cityMode').fire('click');
-  assert.equal(shellPaints, 1, 'this switch repaints the shell\'s');
-  const before = JSON.stringify(p.byId.get('cityFlat').children[0].attrs);
-  p.store.set('hall-theme', 'light'); p.html.setAttribute('data-theme', 'light'); // the shell's switch
-  p.observers[0].fn();
-  assert.equal(p.byId.get('cityMode').attrs['aria-label'], 'Switch to dark mode', 'this switch follows the shell\'s');
-  assert.notEqual(JSON.stringify(p.byId.get('cityFlat').children[0].attrs), before, 'and the city redraws in that mode');
-  assert.equal(shellPaints, 1, 'following the shell does not echo back to it');
-});
+
 
 test('the artboard fits the stage the hall chrome leaves, not the window (task 1004544)', async () => {
   const p = await bootPage({ feeds: FEEDS([]), stage: { clientWidth: 688, clientHeight: 900 } });

package/tests/hall_controls.mjs

@@ -9,6 +9,11 @@
 //     button (it loads later) without re-drawing it;
 //   * THE SIZES — primary is DESIGN.md's 46–48px door, the row size and the
 //     text button keep the 24px floor, the field clears it;
+//   * THE HELM SHAPE AND VOICE (task 1005192, ADR 0402) — in the hall a button
+//     is the cut corner in the name voice, every piece of it a hall-tier token
+//     spent with the old pill/lowercase as its fallback (the status page links
+//     this sheet without the hall's tier), and a cut button's focus ring is
+//     drawn inside the shape, because a clip-path clips an outline;
 //   * CONTRAST, MEASURED — the button's ink on its fill (rest AND hover), the
 //     ghost's and the text button's ink on both grounds, the field's text and
 //     its edge (3:1, WCAG 1.4.11), in both modes, resolved from the real
@@ -144,11 +149,11 @@ test('style.css imports controls.css right after the shared token sheet', () =>
 
 // ── 2. the sizes ─────────────────────────────────────────────────────────────
 
-test('primary is the 46–48px pill; the row size and the text button keep the 24px floor', () => {
+test('primary is the 46–48px door; the row size and the text button keep the 24px floor', () => {
   const base = sharedRule('.btn');
   const h = px(prop(base, 'min-height'));
   assert.ok(h >= 46 && h <= 48, `.btn is ${h}px — DESIGN.md's door is 46–48px`);
-  assert.equal(prop(base, 'border-radius'), 'var(--radius-pill)', 'pill or nothing (DESIGN.md, Shapes)');
+  assert.equal(prop(base, 'border-radius'), 'var(--press-radius, var(--radius-pill))', 'the hall\'s corner, and the pill where the hall\'s tier is not loaded');
   assert.match(prop(base, 'border'), /transparent$/, 'the edge is reserved, so a modifier that sets only its colour draws');
   for (const sel of ['.btn--sm', '.btn--text']) {
     assert.ok(px(prop(sharedWith(sel, 'min-height'), 'min-height')) >= 24, `${sel} keeps 24px of height`);
@@ -203,6 +208,49 @@ test('no hall sheet puts white ink on an accent fill', () => {
 const PRIMARY = ['.btn', '.btn-accent', '.landing__btn', '.task__claim', '.setup-gate__save', '.td-btn--primary', '.pbtn--save', '.craft-save'];
 const GHOST = ['.btn--ghost', '.btn-ghost', '.landing__btn--quiet', '.td-btn', '.wip__release', '.pbtn', '.settings-btn'];
 const SMALL = ['.btn--sm', '.btn-ghost', '.task__claim', '.td-btn', '.wip__release'];
+// the ghost's fill: the hall's press fill, and nothing at all without the hall's tier
+const GHOST_FILL = 'var(--press-fill, transparent)';
+
+// ── 3b. the Helm shape and voice (task 1005192, ADR 0402) ───────────────────
+
+test('in the hall a button is the cut corner in the name voice, and without the hall\'s tier it is the pill it was', () => {
+  const base = sharedRule('.btn');
+  // every Helm piece is a token with the old look as its fallback
+  assert.equal(prop(base, 'clip-path'), 'var(--cut-path, none)');
+  assert.equal(prop(base, 'font-family'), 'var(--name-face, var(--font-body))');
+  assert.equal(prop(base, 'font-weight'), 'var(--name-weight, 500)');
+  assert.equal(prop(base, 'letter-spacing'), 'var(--name-space-tight, normal)');
+  assert.equal(prop(base, 'text-transform'), 'var(--name-case, lowercase)');
+  assert.equal(prop(sharedWith('.btn--sm', 'clip-path'), 'clip-path'), 'var(--cut-path-sm, none)', 'the row size takes the smaller cut');
+  // the tokens are the hall tier's, and the status page (which links this sheet) defines none of them
+  const status = fs.readFileSync(path.join(ROOT, 'modules', 'status-ui', 'public', 'style.css'), 'utf8');
+  for (const name of ['--cut-path', '--cut-path-sm', '--press-radius', '--press-fill', '--press-focus', '--name-face', '--name-weight', '--name-space-tight', '--name-case']) {
+    assert.ok(root[name], `${name} is in the hall's token block`);
+    assert.ok(!new RegExp(`${name}\\s*:`).test(status), `the status page does not define ${name}, so the fallback stands there`);
+  }
+  assert.equal(root['--cut-path'], 'polygon(var(--cut) 0, 100% 0, 100% calc(100% - var(--cut)), calc(100% - var(--cut)) 100%, 0 100%, 0 var(--cut))', 'top-left and bottom-right are cut');
+  assert.equal(root['--name-case'], 'uppercase');
+  // a link in a sentence is not a cut control and does not shout
+  const text = sharedWith('.btn--text', 'clip-path');
+  assert.equal(prop(text, 'clip-path'), 'none');
+  assert.equal(prop(text, 'text-transform'), 'none');
+});
+
+test('a cut button keeps a visible focus ring: inset, two-tone, 3:1 on its own fill', () => {
+  // clip-path clips the outline and the outer halo, so the base rule hands the shell's
+  // :focus-visible rule an inset ring instead; the text button (not cut) hands it back
+  assert.equal(prop(sharedRule('.btn'), '--focus-ring'), 'var(--press-focus)');
+  assert.equal(prop(sharedWith('.btn--text', '--focus-ring'), '--focus-ring'), 'initial');
+  const shell = rulesOf(styleSrc).find((x) => x.sels.length === 1 && x.sels[0] === ':focus-visible');
+  assert.ok(shell, 'the shell\'s ring rule');
+  assert.match(prop(shell.body, 'box-shadow'), /^var\(--focus-ring, /, 'the shell\'s ring spends what a cut control hands in');
+  assert.equal(root['--press-focus'], 'inset 0 0 0 2px var(--focus), inset 0 0 0 4px var(--bg)', 'the focus colour on the edge, then a 2px band of the ground');
+  // one of the two tones reads against each fill a cut button paints (WCAG 1.4.11, 3:1), in the mode the hall renders
+  for (const [what, fill] of [['primary', 'var(--accent)'], ['primary hover', 'var(--accent-lift)'], ['ghost on the page', onGround(GHOST_FILL, 'var(--bg)', 'dark')], ['ghost on a panel', onGround(GHOST_FILL, 'var(--bg-card)', 'dark')], ['danger', 'var(--danger)']]) {
+    const best = Math.max(contrast('var(--focus)', fill, 'dark'), contrast('var(--bg)', fill, 'dark'));
+    assert.ok(best >= 3, `dark ${what}: the ring's better tone is ${best.toFixed(2)}:1 on the fill`);
+  }
+});
 
 test('every older button name sits in the shared rule it means', () => {
   const fill = (sel) => {
@@ -210,11 +258,11 @@ test('every older button name sits in the shared rule it means', () => {
     return r.length ? prop(r[0].body, 'background') : null;
   };
   for (const sel of PRIMARY) assert.equal(fill(sel), 'var(--accent)', `${sel} is a primary door`);
-  for (const sel of GHOST) assert.equal(fill(sel), 'transparent', `${sel} is a ghost`);
+  for (const sel of GHOST) assert.equal(fill(sel), GHOST_FILL, `${sel} is a ghost`);
   for (const sel of SMALL) assert.equal(prop(sharedWith(sel, 'min-height'), 'min-height'), '30px', `${sel} is the row size`);
   // and the primary-on-a-ghost-base names come AFTER the ghost rule, or the ghost wins on order
   const list = rulesOf(controls);
-  const ghostAt = list.findIndex((x) => x.sels.includes('.td-btn') && prop(x.body, 'background') === 'transparent');
+  const ghostAt = list.findIndex((x) => x.sels.includes('.td-btn') && prop(x.body, 'background') === GHOST_FILL);
   const primaryAt = list.findIndex((x) => x.sels.includes('.td-btn--primary') && prop(x.body, 'background'));
   assert.ok(primaryAt > ghostAt, '.td-btn--primary follows .td-btn, so the shared order paints it');
 });

package/tests/hall_fullscreen.mjs

@@ -93,7 +93,8 @@ function boot({ page = 'thinking', optIn = true, store = {}, storageThrows = fal
     addEventListener() {}, dispatchEvent() {},
     get cookie() { return ''; }, set cookie(_v) {},
   };
-  const location = { hostname: 'h', origin: 'https://h', href: 'https://h/' + page + search, pathname: path || '/' + page, hash, search, assign() {}, replace() {} };
+  const assigned = []; // task 1005144: where the page sent the browser (game mode's Escape opens the menu)
+  const location = { hostname: 'h', origin: 'https://h', href: 'https://h/' + page + search, pathname: path || '/' + page, hash, search, assign(u) { assigned.push(u); }, replace() {} };
   // `session` is the TAB's sessionStorage: pass one object to several boots and
   // they are page loads in one tab (the trail, task 1004476).
   const sessionStorage = {
@@ -133,6 +134,7 @@ function boot({ page = 'thinking', optIn = true, store = {}, storageThrows = fal
   const root = documentObj.documentElement;
   return {
     store,
+    assigned,
     game: () => windowObj.OTBShellGame,
     gameStamp: () => root.dataset.game === 'on',
     // The "how to leave" line: showing = the shell created it and it is not hidden.
@@ -518,8 +520,8 @@ test('game mode: every hall page carries the switch — none opts out, and each
 test('game mode: leaving brings the bars back for THIS page only, and never rewrites a page\'s own memory', () => {
   const store = { 'hall-game': 'on', 'hall-fullscreen:thinking': 'on' };
   const goals = boot({ page: 'goals', optIn: false, store });
-  goals.press('Escape');
-  assert.equal(goals.on(), false, 'Escape still leaves');
+  goals.button().click();
+  assert.equal(goals.on(), false, 'the corner button still leaves (Escape opens the options menu, below)');
   assert.equal(store['hall-fullscreen:goals'], undefined, 'nothing remembered for the page');
   assert.equal(boot({ page: 'goals', optIn: false, store }).on(), true, 'the next load opens without bars again');
   const sky = boot({ page: 'thinking', store });
@@ -528,6 +530,28 @@ test('game mode: leaving brings the bars back for THIS page only, and never rewr
   assert.equal(store['hall-fullscreen:thinking'], 'on', 'the sky\'s own choice survives game mode');
 });
 
+// task 1005144 (BONGOS-V3 R04, ADR 0399 §2.4 row 6): in game mode the last Escape is the
+// options menu's. It opens the menu, remembering where it came from, and the bars stay away.
+test('game mode: the last Escape opens the options menu, and the bars stay hidden', () => {
+  const store = { 'hall-game': 'on' };
+  const goals = boot({ page: 'goals', optIn: false, store, hash: '#/goal/7' });
+  goals.press('Escape');
+  assert.equal(goals.on(), true, 'the shell did not take the press');
+  assert.deepEqual(goals.assigned, ['/settings?from=' + encodeURIComponent('/goals#/goal/7')], 'the menu, and the way back');
+  const apex = boot({ page: 'goals', optIn: false, store, path: '/builders/goals' });
+  apex.press('Escape');
+  assert.deepEqual(apex.assigned, ['/builders/settings?from=' + encodeURIComponent('/builders/goals')], 'on the apex too');
+  const used = boot({ page: 'goals', optIn: false, store });
+  used.press('Escape', { pageUses: true });
+  used.press('Escape', { target: { tagName: 'INPUT' } });
+  assert.deepEqual(used.assigned, [], 'a press a page used, or one in a field, never opens it');
+  const plain = boot({ page: 'goals', optIn: false, store: {} });
+  plain.button().click();
+  plain.press('Escape');
+  assert.deepEqual(plain.assigned, [], 'outside game mode Escape is the shell\'s, as before');
+  assert.equal(plain.on(), false, 'and it leaves full screen');
+});
+
 test('game mode: the Escape hand-off is unchanged — a press the page used, or one in a field, does not leave', () => {
   const p = boot({ page: 'goals', optIn: false, store: { 'hall-game': 'on' } });
   p.press('Escape', { pageUses: true });

package/tests/hall_helm.mjs

@@ -0,0 +1,187 @@
+// tests/hall_helm.mjs — Helm, the look the builders' hall wears (task 1005192, ADR 0402).
+//
+// WHY. Two owner decisions are easy to break without anyone seeing it on their own
+// machine: Helm is the hall's alone (the landing, the hub and the status page keep
+// their look), and the hall is dark only (no page offers light, and a light OS never
+// flashes it). Both are decided in one serve-time seam, src/hall-helm.js, which
+// recognises a hall page by the sheet it links. This file runs that seam over the
+// real pages, and holds the pieces of the kit a browser would hide:
+//   * every hall page is served with html[data-theme="dark"], and nothing else is;
+//   * the Helm faces reach a hall whose pack names the default faces, and never a
+//     hall that chose its own, and never the landing or the status page;
+//   * the font stylesheet loads the way tests/google_fonts_nonblocking.mjs asks of
+//     a typed-in link (both preconnects on the page, display=swap), which that sweep
+//     cannot see because the link is built at serve time;
+//   * no hall script writes a theme choice, and the shell offers no switch;
+//   * the Helm neutrals: the two dark twins carry the night, the ice and no black;
+//   * the kit's recipes exist once, as hall-tier tokens and shared rules.
+//
+// Run:  node --test tests/hall_helm.mjs
+import { test } 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 ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const read = (...p) => fs.readFileSync(path.join(ROOT, ...p), 'utf8');
+const decomment = (css) => css.replace(/\/\*[\s\S]*?\*\//g, '');
+
+const { applyHelm, isHallPage, wearsHelmFaces, stampHtml, HELM_FONTS_HREF } = require('../src/hall-helm.js');
+const { injectBrandingGlobal } = require('../src/bongos/serve-internal.js');
+const { clientBranding, resolveBranding } = require('../src/branding.js');
+
+const NEUTRAL = JSON.parse(read('config', 'branding.neutral.json'));
+const DEFAULTS = NEUTRAL.theme.ui.fonts;
+const hallPages = fs.readdirSync(HALL).filter((f) => f.endsWith('.html'));
+const htmlTag = (html) => (html.match(/<html\b[^>]*>/i) || [''])[0];
+
+// ── the seam ────────────────────────────────────────────────────────────────
+
+test('a hall page is the one that links the hall sheet; the landing, the hub and the status page are not', () => {
+  for (const f of hallPages) assert.ok(isHallPage(read('modules', 'hall-ui', 'public', f)), `${f} links the hall's sheet`);
+  for (const p of [['modules', 'public-landing', 'public', 'index.html'], ['modules', 'public-landing', 'public', 'projects.html'], ['modules', 'status-ui', 'public', 'index.html'], ['modules', 'ui-design', 'public', 'brand.html']]) {
+    assert.equal(isHallPage(read(...p)), false, `${p.join('/')} is not a hall page`);
+  }
+});
+
+test('every hall page is served pinned dark, in the Helm faces, and no other surface is touched', () => {
+  const brand = clientBranding(resolveBranding({ neutral: NEUTRAL }));
+  for (const f of hallPages) {
+    const out = injectBrandingGlobal(read('modules', 'hall-ui', 'public', f), brand, {});
+    const tag = htmlTag(out);
+    assert.match(tag, / data-theme="dark"/, `${f}: dark before first paint`);
+    assert.match(tag, / data-faces="helm"/, `${f}: the Helm faces`);
+    assert.equal((tag.match(/data-theme=/g) || []).length, 1, `${f}: stamped once`);
+    assert.ok(out.includes(`href="${HELM_FONTS_HREF.replace(/&/g, '&amp;')}"`), `${f}: the two families are linked`);
+    // the link follows the pack's own splice, so it is the last word in <head>
+    assert.ok(out.indexOf('Barlow') > out.indexOf('--font-display:'), `${f}: after the pack's :root`);
+  }
+  for (const p of [['modules', 'public-landing', 'public', 'index.html'], ['modules', 'status-ui', 'public', 'index.html']]) {
+    const src = read(...p);
+    const out = injectBrandingGlobal(src, brand, {});
+    assert.equal(htmlTag(out), htmlTag(src), `${p.join('/')}: its <html> tag is as authored`);
+    assert.doesNotMatch(out, /Barlow|data-faces/, `${p.join('/')}: no Helm face`);
+  }
+});
+
+test('a hall that wears faces of its own keeps them; it is still dark only', () => {
+  const page = '<!doctype html><html lang="en"><head><link rel="stylesheet" href="/builders/style.css?v=1"></head><body></body></html>';
+  const own = { fonts: { display: '"Archivo", sans-serif', body: DEFAULTS.body, links: [] } };
+  assert.equal(wearsHelmFaces(own, DEFAULTS), false, 'one face of its own is a pack that chose');
+  const kept = applyHelm(page, own, DEFAULTS);
+  assert.match(htmlTag(kept.html), /data-theme="dark"/);
+  assert.doesNotMatch(kept.html, /data-faces/);
+  assert.equal(kept.tail, '', 'and no Helm stylesheet is linked');
+  // the default faces, and a pack that names none, take Helm
+  assert.equal(wearsHelmFaces({ fonts: { display: DEFAULTS.display, body: DEFAULTS.body } }, DEFAULTS), true);
+  assert.equal(wearsHelmFaces({}, DEFAULTS), true);
+  // a look from the style library with its own faces (ADR 0358) keeps them through the real resolver
+  const looked = clientBranding(resolveBranding({ neutral: NEUTRAL, env: { BONGOS_LOOK: 'expedition' } }));
+  if (looked.theme.look === 'expedition') {
+    const out = injectBrandingGlobal(page, looked, {});
+    assert.match(htmlTag(out), /data-theme="dark"/);
+    assert.doesNotMatch(out, /data-faces|Barlow/, 'the expedition look keeps Archivo');
+  }
+});
+
+test('the stamp replaces an attribute already there and leaves the others alone', () => {
+  assert.equal(stampHtml('<html lang="en" data-artist="on">', 'data-theme', 'dark'), '<html lang="en" data-artist="on" data-theme="dark">');
+  assert.equal(stampHtml('<html data-theme="light" lang="en">', 'data-theme', 'dark'), '<html lang="en" data-theme="dark">');
+  assert.equal(applyHelm('<html><head></head></html>', {}, DEFAULTS).html, '<html><head></head></html>', 'a page with no hall sheet is untouched');
+});
+
+test('the Helm stylesheet loads without blocking: swap, and both preconnects on every hall page', () => {
+  assert.match(HELM_FONTS_HREF, /^https:\/\/fonts\.googleapis\.com\/css2\?/);
+  assert.match(HELM_FONTS_HREF, /[?&]display=swap$/);
+  assert.match(HELM_FONTS_HREF, /family=Barlow\+Condensed:wght@400;500;600/);
+  assert.match(HELM_FONTS_HREF, /family=Barlow:wght@400;500/);
+  const missing = [];
+  for (const f of hallPages) {
+    const html = read('modules', 'hall-ui', 'public', f);
+    if (!/<link rel="preconnect" href="https:\/\/fonts\.googleapis\.com">/.test(html)) missing.push(`${f}: fonts.googleapis.com`);
+    if (!/<link rel="preconnect" href="https:\/\/fonts\.gstatic\.com" crossorigin>/.test(html)) missing.push(`${f}: fonts.gstatic.com (crossorigin)`);
+  }
+  assert.deepEqual(missing, [], 'a hall page that links a web font warms both font origins first');
+});
+
+// ── dark only ───────────────────────────────────────────────────────────────
+
+test('no hall script stores or offers a theme, and the shell pins dark', () => {
+  const shell = read('modules', 'hall-ui', 'public', 'shell.js');
+  assert.match(shell, /function applyTheme\(\) \{\s*document\.documentElement\.dataset\.theme = 'dark';\s*\}/, 'the shell sets dark, whatever was stored');
+  assert.doesNotMatch(shell, /theme-toggle|toggleTheme/, 'no switch on the top bar');
+  const writers = [];
+  for (const f of fs.readdirSync(HALL).filter((x) => x.endsWith('.js'))) {
+    const src = read('modules', 'hall-ui', 'public', f).replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:'"])\/\/.*$/gm, '$1');
+    if (/['"]hall-theme['"]/.test(src)) writers.push(`${f}: names the retired 'hall-theme' preference`);
+    if (/dataset\.theme\s*=\s*(?![\s=]|'dark')|setAttribute\(\s*['"]data-theme['"]\s*,\s*(?!\s|'dark')/.test(src)) writers.push(`${f}: writes a theme other than dark`);
+  }
+  assert.deepEqual(writers, []);
+  for (const f of hallPages) assert.doesNotMatch(read('modules', 'hall-ui', 'public', f), /id="(theme-toggle|cityMode|streetMode)"/, `${f}: no light/dark switch`);
+  assert.doesNotMatch(decomment(read('modules', 'hall-ui', 'public', 'style.css')), /\.theme-toggle/, 'and no styles for one');
+});
+
+// ── the Helm tier ───────────────────────────────────────────────────────────
+
+const STYLE = read('modules', 'hall-ui', 'public', 'style.css');
+const blockAt = (marker) => {
+  const at = STYLE.indexOf(marker);
+  assert.notEqual(at, -1, `style.css holds ${marker}`);
+  const open = STYLE.indexOf('{', at);
+  let depth = 0;
+  for (let i = open; i < STYLE.length; i++) {
+    if (STYLE[i] === '{') depth++;
+    else if (STYLE[i] === '}' && --depth === 0) return STYLE.slice(open + 1, i);
+  }
+  throw new Error('unbalanced');
+};
+const decls = (body) => Object.fromEntries([...decomment(body).matchAll(/(--[\w-]+)\s*:\s*([^;]+);/g)].map((m) => [m[1], m[2].replace(/\s+/g, ' ').trim()]));
+const root = decls(blockAt('\n:root {'));
+const dark = decls(blockAt('html[data-theme="dark"] {'));
+
+test('the dark tier is the Helm neutrals: night grounds, white and ice inks, ice hairlines', () => {
+  assert.deepEqual(
+    Object.fromEntries(['--bg', '--bg-card', '--bg-deep', '--bg-frame', '--ink', '--ink-soft', '--rule', '--rule-soft', '--void'].map((k) => [k, dark[k]])),
+    { '--bg': '#050d16', '--bg-card': '#0a1622', '--bg-deep': '#050d16', '--bg-frame': '#07111b', '--ink': '#ffffff', '--ink-soft': '#c8f1f7', '--rule': 'rgba(200, 241, 247, .4)', '--rule-soft': 'rgba(200, 241, 247, .2)', '--void': '#050d16' },
+  );
+  // the accent is still the pack's: the moon is never pinned (the Unpinned Accent Rule)
+  for (const name of ['--accent', '--accent-deep', '--sea', '--terracotta', '--font-display', '--font-body']) assert.equal(dark[name], undefined, `${name} is not set in the dark tier`);
+  // in dark a label is the name voice
+  assert.equal(dark['--label-face'], 'var(--font-display)');
+});
+
+test('the Helm faces are hall-tier tokens, handed to the two font tokens only under html[data-faces="helm"]', () => {
+  assert.match(root['--helm-display'], /^"Barlow Condensed", /);
+  assert.match(root['--helm-body'], /^"Barlow", /);
+  // the contract tier still equals the pack (tests/hall_tokens.mjs holds that); Helm does not overwrite it there
+  assert.equal(root['--font-display'], DEFAULTS.display);
+  const faces = decls(blockAt('\nhtml[data-faces="helm"] {'));
+  assert.deepEqual(faces, { '--font-display': 'var(--helm-display)', '--font-body': 'var(--helm-body)' });
+  assert.equal((decomment(STYLE).match(/Barlow/g) || []).length, 2, 'the family names live once each, in the token block');
+  for (const f of fs.readdirSync(HALL).filter((x) => x.endsWith('.css') && x !== 'style.css')) {
+    assert.doesNotMatch(read('modules', 'hall-ui', 'public', f), /Barlow/, `${f} takes the face from the tokens`);
+  }
+});
+
+test('the kit\'s recipes are named once: the name voice, the cut, the segment, the panel over art', () => {
+  assert.equal(root['--name-face'], 'var(--font-display)');
+  assert.equal(root['--name-case'], 'uppercase');
+  for (const k of ['--name-space', '--name-space-wide', '--name-space-tight']) {
+    const em = Number((root[k].match(/^(\.\d+)em$/) || [])[1]);
+    assert.ok(em >= 0.16 && em <= 0.3, `${k} is wide tracking (${root[k]})`);
+  }
+  assert.equal(root['--cut'], '12px');
+  assert.equal(root['--seg-skew'], '-28deg');
+  assert.equal(root['--night-glass'], 'color-mix(in srgb, var(--bg) 72%, transparent)');
+  const controls = decomment(read('modules', 'hall-ui', 'public', 'controls.css'));
+  const seg = controls.match(/\n\.seg \{([^}]*)\}/);
+  assert.ok(seg, 'the segment is a shared rule');
+  assert.match(seg[1], /transform: skewX\(var\(--seg-skew\)\);/);
+  assert.match(seg[1], /height: var\(--seg-h\);/);
+  assert.match(controls, /\n\.seg--done \{ background: var\(--ink-soft\);/, 'a finished step is information, so it is ice, not the accent');
+  assert.match(controls, /\n\.seg--now \{ background: var\(--accent\);/, 'the accent is the step you can act on');
+});

package/tests/hall_kit_charts.mjs

@@ -379,7 +379,7 @@ test('the migrated pages run for real against the kit and emit its classes', ()
   assert.equal(typeof s.window.OTBHallRender, 'function', 'the renderer factory survived the migration');
   assert.equal(typeof s.window.OTBKit.barSeriesHtml, 'function');
   assert.match(
-    s.window.OTBKit.barSeriesHtml([{ label: 'engineer', value: 3 }]),
+    s.window.OTBKit.barSeriesHtml([{ label: 'artisan', value: 3 }]),
     /class="kit-bars"/,
   );
 });

package/tests/hall_landing_boot.mjs

@@ -72,7 +72,7 @@ async function boot({ meStatus, settle = false }) {
       // the same reason categoryChip is: an undefined helper throws mid-render.
       roleAxisLabel: () => 'Role',
       roleLabel: (d) => (!d ? '' : d === 'unclassified' ? 'No role yet' : d === 'ui' ? 'UI' : d.charAt(0).toUpperCase() + d.slice(1)),
-      roleOptions: () => [{ value: '', label: '— any —' }, { value: 'engineer', label: 'Engineer' }, { value: 'artist', label: 'Artist' }],
+      roleOptions: () => [{ value: '', label: '— any —' }, { value: 'artisan', label: 'Artisan' }, { value: 'artist', label: 'Artist' }],
       roleIsUnset: (d) => !d || d === 'unclassified',
       ROLE_UNSET: 'unclassified',
       moduleOn: () => true,

package/tests/hall_my_agents.mjs

@@ -388,48 +388,48 @@ function bootCraft({ session = {} } = {}) {
 }
 const seatOf = (has, title) => ({ known: true, has_position: has, title: has ? title : null });
 
-test('CRAFT: with no seat, Governing is not offered anywhere', () => {
+test('CRAFT: with no seat, Patron (Governing until task 1005141) is not offered anywhere', () => {
   const b = bootCraft();
   b.craft.setPositions(seatOf(false));
-  assert.match(b.craft.switchHtml(), /data-craft-opt="governing"[^>]* hidden>/, 'the switch hides it');
-  b.craft.choose('governing');
+  assert.match(b.craft.switchHtml(), /data-craft-opt="patron"[^>]* hidden>/, 'the switch hides it');
+  b.craft.choose('patron');
   assert.equal(b.root.dataset.craft, undefined, 'and choosing it does nothing');
   b.craft.open();
   const picker = b.body.children[0];
   assert.ok(picker, 'the picker opened');
-  assert.doesNotMatch(picker.innerHTML, /data-craft-pick="governing"/, 'no Governing door');
-  assert.match(picker.innerHTML, /data-doors="3"/, 'three doors, laid out as three');
+  assert.doesNotMatch(picker.innerHTML, /data-craft-pick="patron"/, 'no Patron door');
+  assert.match(picker.innerHTML, /data-doors="2"/, 'two doors, laid out as two');
 });
 
-test('CRAFT: a stored Governing reads as no mode for a builder known to hold no seat', () => {
+test('CRAFT: a stored Patron — even under its pre-rename id, Governing — reads as no mode for a builder known to hold no seat', () => {
   const b = bootCraft({ session: { 'hall-craft': 'governing' } });
-  assert.equal(b.craft.current(), 'governing', 'unknown seats: today\'s behaviour');
+  assert.equal(b.craft.current(), 'patron', 'unknown seats: today\'s behaviour, the old id read as Patron (task 1005141)');
   b.craft.setPositions(seatOf(false));
   assert.equal(b.craft.current(), null);
   assert.equal(b.session['hall-craft'], undefined, 'and the stored choice is dropped');
 });
 
-test('CRAFT: a seat names the Governing mode', () => {
+test('CRAFT: a seat names the Patron mode', () => {
   const b = bootCraft();
   b.craft.setPositions(seatOf(true, 'Treasury Lead'));
   assert.equal(b.craft.seatName(), 'Treasury Lead');
-  assert.match(b.craft.switchHtml(), /data-craft-opt="governing"[^>]*>[\s\S]*?Treasury Lead<\/span>/);
-  b.craft.choose('governing');
-  assert.equal(b.root.dataset.craft, 'governing');
+  assert.match(b.craft.switchHtml(), /data-craft-opt="patron"[^>]*>[\s\S]*?Treasury Lead<\/span>/);
+  b.craft.choose('patron');
+  assert.equal(b.root.dataset.craft, 'patron');
   b.craft.open();
   assert.match(b.body.children[0].innerHTML, /craft-door__name">Treasury Lead</);
-  assert.match(b.body.children[0].innerHTML, /data-doors="4"/);
+  assert.match(b.body.children[0].innerHTML, /data-doors="3"/);
 });
 
-test('CRAFT: unknown seats are today\'s picker — four doors and a free Governing', () => {
+test('CRAFT: unknown seats are today\'s picker — three doors and a free Patron', () => {
   const b = bootCraft();
   b.craft.setPositions(null);
   assert.equal(b.craft.seatName(), null);
   assert.doesNotMatch(b.craft.switchHtml(), / hidden>/);
-  assert.match(b.craft.switchHtml(), />Governing<\/span>/);
+  assert.match(b.craft.switchHtml(), />Patron<\/span>/);
   b.craft.setPositions({ known: false, has_position: false });
-  b.craft.choose('governing');
-  assert.equal(b.root.dataset.craft, 'governing', 'an unknown answer never takes the mode away');
+  b.craft.choose('patron');
+  assert.equal(b.root.dataset.craft, 'patron', 'an unknown answer never takes the mode away');
 });
 
 // ---------------------------------------------------------------------------