@bongos/core 1.24.81 → 1.24.83

package/release-notes.json

@@ -11589,5 +11589,17 @@
       "id": "1005192",
       "text": "The hall now wears the new Helm look: deep night panels, ice-blue text, wide capital titles and cut-corner buttons, all from one shared design system. The start and load screens are rebuilt to match, and the hall is dark only."
     }
+  ],
+  "1.24.82": [
+    {
+      "id": "1005200",
+      "text": "The hall now has two separate views, Game and Classic, and never mixes them. You choose one each time you sign in and can switch only in Options. Game mode stays full screen and only opens the game's places."
+    }
+  ],
+  "1.24.83": [
+    {
+      "id": "1005194",
+      "text": "The options menu and the choose-your-character screen now wear the Helm look: a night panel with wide capital rows, and three tall cut-corner doors with the real characters. Fields and tags across the hall are squared to match"
+    }
   ]
 }

package/scripts/hall-preview/pref-writes.js

@@ -14,7 +14,7 @@
 //
 // What it is NOT: storage. Nothing is written to disk and a restart forgets
 // everything; each recorded write is logged so the harness console shows what the
-// page sent. Only these five routes are recorded — every other write is refused
+// page sent. Only these routes are recorded — every other write is refused
 // exactly as before.
 'use strict';
 
@@ -27,6 +27,7 @@ const wandering = lib('wandering-prefs');
 const models = lib('model-alloc-prefs');
 const render = lib('render-prefs');
 const skills = lib('skill-prefs');
+const hallView = lib('hall-view-prefs'); // task 1005200: game or classic
 
 // apiPath → the /me slice it answers for (null: the skill prefs, not on /me)
 const ROUTES = {
@@ -35,6 +36,7 @@ const ROUTES = {
   'me/model-allocation': 'model_allocation',
   'me/render': 'render',
   'me/skill-prefs': null,
+  'me/hall-view': 'hall_view',
 };
 
 function createPrefRecorder({ log = console.log } = {}) {
@@ -63,6 +65,7 @@ function createPrefRecorder({ log = console.log } = {}) {
     if (slice === 'wandering') return wandering.describeForApi(behavior, rank);
     if (slice === 'model_allocation') return models.describeForApi(behavior, instanceModels);
     if (slice === 'render') return render.describeForApi(behavior);
+    if (slice === 'hall_view') return hallView.describeForApi(behavior);
     return {
       prefs: skillPrefs, effective: skills.listEffective(skillPrefs), defaults: skills.SKILL_DEFAULTS,
       known_skills: skills.KNOWN_SKILLS, allowed_models: skills.ALLOWED_MODELS,
@@ -96,6 +99,10 @@ function createPrefRecorder({ log = console.log } = {}) {
       v = render.validatePatch(b);
       if (!v.ok) return invalid(v.errors);
       behavior = render.applyPatch(behavior, v.patch);
+    } else if (slice === 'hall_view') {
+      v = hallView.validatePatch(b);
+      if (!v.ok) return invalid(v.errors);
+      behavior = hallView.applyView(behavior, v.view);
     } else {
       v = skills.validatePatch(b);
       if (!v.ok) return invalid(v.errors);

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.81'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.24.83'; // 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_tokens_shared.mjs

@@ -133,13 +133,17 @@ test('the landing, hub, status and raise pages link it before their own sheet',
 
 test('the hall\'s old token names still resolve — each alias names a defined --ds-* token', () => {
   const style = decomment(read('modules', 'hall-ui', 'public', 'style.css'));
-  const want = ['--line', '--radius', '--radius-sm', '--radius-pill', '--sp-hair', '--sp-xs', '--sp-sm', '--sp-md', '--sp-lg', '--sp-xl',
+  const want = ['--line', '--radius', '--radius-sm', '--sp-hair', '--sp-xs', '--sp-sm', '--sp-md', '--sp-lg', '--sp-xl',
     '--shadow-pop', '--z-progress', '--z-topbar', '--z-sidebar', '--z-scrim', '--z-drawer', '--z-modal', '--z-diagram-full', '--label-size'];
   for (const n of want) {
     const m = style.match(new RegExp(`${n}\\s*:\\s*var\\((--ds-[\\w-]+)\\)`));
     assert.ok(m, `${n} is an alias onto the shared sheet`);
     assert.ok(ROOT_TOKENS[m[1]], `${n} → ${m[1]} is defined in tokens.css`);
   }
+  // --radius-pill left the aliases with Helm (task 1005194, ADR 0402): the hall draws no pill,
+  // so its tier sets the name to a square corner; the shared --ds-radius-pill is untouched.
+  assert.match(style, /--radius-pill: 0px;/, 'the hall has no pill');
+  assert.equal(ROOT_TOKENS['--ds-radius-pill'], '999px', 'the shared pill is still a pill for every other surface');
   // the four-step --space-* scale still rides the --sp-* aliases
   for (const n of ['--space-1', '--space-2', '--space-3', '--space-4']) assert.match(style, new RegExp(`${n}\\s*:\\s*var\\(--sp-`));
 });

package/tests/hall_controls.mjs

@@ -161,7 +161,7 @@ test('primary is the 46–48px door; the row size and the text button keep the 2
   }
   const field = sharedRule('select');
   assert.ok(px(prop(field, 'min-height')) >= 24, 'the field clears the floor');
-  assert.equal(prop(field, 'border-radius'), 'var(--radius-pill)', 'a field is a pill too');
+  assert.equal(prop(field, 'border-radius'), 'var(--radius-pill)', 'a field spends the pill name: a pill on the status page, square in the hall, whose tier sets --radius-pill to 0px (tests/hall_helm.mjs)');
 });
 
 // ── 3. AA, measured, in both modes ───────────────────────────────────────────

package/tests/hall_fullscreen.mjs

@@ -94,7 +94,8 @@ function boot({ page = 'thinking', optIn = true, store = {}, storageThrows = fal
     get cookie() { return ''; }, set cookie(_v) {},
   };
   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() {} };
+  const replaced = []; // task 1005200: a classic page in game mode sends the browser to the city
+  const location = { hostname: 'h', origin: 'https://h', href: 'https://h/' + page + search, pathname: path || '/' + page, hash, search, assign(u) { assigned.push(u); }, replace(u) { replaced.push(u); } };
   // `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 = {
@@ -135,6 +136,7 @@ function boot({ page = 'thinking', optIn = true, store = {}, storageThrows = fal
   return {
     store,
     assigned,
+    replaced,
     game: () => windowObj.OTBShellGame,
     gameStamp: () => root.dataset.game === 'on',
     // The "how to leave" line: showing = the shell created it and it is not hidden.
@@ -517,17 +519,36 @@ 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', () => {
+// task 1005200 (owner, 2026-11-11): game OR classic, never both. Inside game mode there is
+// no way back to the bars — the corner button is hidden (style.css) and, pressed
+// anyway, does nothing; Escape is the options menu's, where the view is switched.
+test('game mode: there is no way back to the bars inside it, and a page\'s own memory is never rewritten', () => {
   const store = { 'hall-game': 'on', 'hall-fullscreen:thinking': 'on' };
-  const goals = boot({ page: 'goals', optIn: false, store });
-  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 profile = boot({ page: 'profile', optIn: false, store });
+  profile.button().click();
+  assert.equal(profile.on(), true, 'the corner button does not leave game mode');
+  assert.equal(store['hall-fullscreen:profile'], undefined, 'nothing remembered for the page');
   const sky = boot({ page: 'thinking', store });
   sky.button().click();
-  assert.equal(sky.on(), false, 'the corner button leaves too');
+  sky.press('Escape');
+  assert.equal(sky.on(), true, 'nor does Escape');
   assert.equal(store['hall-fullscreen:thinking'], 'on', 'the sky\'s own choice survives game mode');
+  assert.match(read('style.css'), /html\[data-game="on"\] \.fullscreen-toggle \{ display: none; \}/, 'and the button is not drawn');
+});
+
+test('game mode: only the game\'s places are there — a classic page sends the browser to the city', () => {
+  const store = { 'hall-game': 'on' };
+  assert.deepEqual(boot({ page: 'goals', optIn: false, store }).replaced, ['/'], 'Goals is a classic page');
+  assert.deepEqual(boot({ page: 'work', optIn: false, store, path: '/builders/work' }).replaced, ['/builders/'], 'on the apex too');
+  for (const page of ['home', 'city', 'goal-map', 'thinking', 'atlas', 'settings', 'profile']) {
+    assert.deepEqual(boot({ page, optIn: false, store }).replaced, [], `${page} is a game place`);
+  }
+  assert.deepEqual(boot({ page: 'goals', optIn: false, store: {} }).replaced, [], 'classic reaches every page');
+  const G = boot({ page: 'city', store }).game();
+  assert.equal(G.isPlace('/city'), true);
+  assert.equal(G.isPlace('/builders/'), true);
+  assert.equal(G.isPlace('/work'), false);
+  assert.equal(G.isPlace('/blockers?x=1'), false);
 });
 
 // task 1005144 (BONGOS-V3 R04, ADR 0399 §2.4 row 6): in game mode the last Escape is the
@@ -562,35 +583,35 @@ test('game mode: the Escape hand-off is unchanged — a press the page used, or
 
 test('game mode: set() switches the page live, and turning it off hands each page back its own memory', () => {
   const store = { 'hall-fullscreen:thinking': 'on' };
-  const goals = boot({ page: 'goals', optIn: false, store });
+  const goals = boot({ page: 'profile', optIn: false, store });
   goals.game().set(true);
   assert.equal(store['hall-game'], 'on');
   assert.equal(goals.on(), true, 'on at once, no reload');
   assert.ok(goals.resizes() >= 1, 'a page that sizes to its box is told to re-measure');
   goals.game().set(false);
-  assert.equal(goals.on(), false, 'goals remembered nothing, so its bars return');
+  assert.equal(goals.on(), false, 'the profile remembered nothing, so its bars return');
   assert.equal(goals.gameStamp(), false);
-  assert.equal(store['hall-fullscreen:goals'], undefined, 'and switching the mode wrote nothing for the page');
+  assert.equal(store['hall-fullscreen:profile'], undefined, 'and switching the mode wrote nothing for the page');
+  const work = boot({ page: 'work', optIn: false, store: {} });
+  work.game().set(true);
+  assert.deepEqual(work.replaced, ['/'], 'switched to game on a classic page: to the city');
   const sky = boot({ page: 'thinking', store: Object.assign(store, { 'hall-game': 'on' }) });
   sky.game().set(false);
   assert.equal(sky.on(), true, 'the sky had chosen full screen itself, and keeps it');
 });
 
-test('game mode: ?game=on / ?game=off set it from the URL; anything else is ignored', () => {
+test('game mode: the address does not switch it — Options and the sign-in chooser do (task 1005200)', () => {
   const store = {};
-  assert.equal(boot({ page: 'work', optIn: false, store, search: '?game=on' }).on(), true);
-  assert.equal(store['hall-game'], 'on');
-  assert.equal(boot({ page: 'goals', optIn: false, store }).on(), true, 'and it holds on the next page');
-  assert.equal(boot({ page: 'work', optIn: false, store, search: '?game=off' }).on(), false);
-  boot({ page: 'work', optIn: false, store, search: '?game=%22%3E%3Cimg%3E' });
-  assert.equal(store['hall-game'], 'off', 'a value that is not on/off is not stored');
+  assert.equal(boot({ page: 'profile', optIn: false, store, search: '?game=on' }).on(), false);
+  assert.equal(store['hall-game'], undefined, 'nothing stored from the URL');
+  assert.doesNotMatch(read('shell-game.js'), /get\('game'\)/, 'the ?game= reader is gone');
 });
 
-test('game mode: how to leave is said once per tab, not on every page; outside it the shell\'s rule stands', () => {
+test('game mode never says how to leave full screen (there is no leaving); outside it the shell\'s rule stands', () => {
   const store = { 'hall-game': 'on' };
   const session = {};
-  assert.equal(boot({ page: 'goals', optIn: false, store, session }).hintShowing(), true, 'the first page says it');
-  assert.equal(boot({ page: 'work', optIn: false, store, session }).hintShowing(), false, 'the next does not repeat it');
+  assert.equal(boot({ page: 'profile', optIn: false, store, session }).hintShowing(), false, 'no line in game mode');
+  assert.equal(boot({ page: 'city', store, session }).hintShowing(), false);
   const own = { 'hall-fullscreen:thinking': 'on' };
   assert.equal(boot({ page: 'thinking', store: own, session: {} }).hintShowing(), true);
   assert.equal(boot({ page: 'thinking', store: own, session: {} }).hintShowing(), true, 'a remembered page says it on every open, as before');

package/tests/hall_helm.mjs

@@ -14,7 +14,9 @@
 //     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.
+//   * the kit's recipes exist once, as hall-tier tokens and shared rules;
+//   * Helm look 2 (task 1005194): the hall has no pill, and the options menu and
+//     character select are Helm screens written from the tokens alone.
 //
 // Run:  node --test tests/hall_helm.mjs
 import { test } from 'node:test';
@@ -185,3 +187,103 @@ test('the kit\'s recipes are named once: the name voice, the cut, the segment, t
   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');
 });
+
+// ── Helm look 2 (task 1005194): the square corner, the options menu, character select ──
+
+// one rule's body, by its exact selector line, from a decommented sheet
+const ruleOf = (css, sel) => {
+  const at = css.indexOf('\n' + sel + ' {');
+  assert.notEqual(at, -1, `no rule ${sel}`);
+  const open = css.indexOf('{', at);
+  return css.slice(open + 1, css.indexOf('}', open));
+};
+const NO_COLOUR_LITERAL = /#[0-9a-fA-F]{3,8}\b|\brgba?\(|\bhsla?\(/;
+
+test('the hall has no pill: --radius-pill is a square corner in the hall tier, and only there', () => {
+  assert.equal(root['--radius-pill'], '0px', 'Helm draws no pill');
+  // the panel and the tile keep their corners until each page's own task (DESIGN.md "The hall")
+  assert.equal(root['--radius'], 'var(--ds-radius-panel)');
+  assert.equal(root['--radius-sm'], 'var(--ds-radius-tile)');
+  // the shared scale is untouched, so the landing and the status page keep their pill
+  assert.match(read('modules', 'ui-design', 'public', 'tokens.css'), /--ds-radius-pill:\s*999px;/);
+  const controls = decomment(read('modules', 'hall-ui', 'public', 'controls.css'));
+  // the field and the status tag spend the name, so they are square in the hall with no rule of their own
+  assert.match(controls, /\.input \{[^}]*border-radius: var\(--radius-pill\);/);
+  assert.match(controls, /\ntextarea \{[^}]*border-radius: var\(--press-radius, var\(--radius-sm\)\);/, 'a textarea is square too, the tile where the tier is not loaded');
+});
+
+test('what is pressed in the top bar, and a filter chip, take the small cut and the inset focus ring', () => {
+  const css = decomment(STYLE.replace(/\r\n/g, '\n'));
+  for (const sel of ['.upd-pill', '.chip', 'html[data-fullscreen="on"] .fullscreen-toggle']) {
+    const body = ruleOf(css, sel);
+    assert.match(body, /clip-path: var\(--cut-path-sm\);/, `${sel} is cut`);
+    assert.match(body, /--focus-ring: var\(--press-focus\);/, `${sel}: a cut clips an outline, so the ring is inside`);
+    assert.match(body, /border-radius: var\(--press-radius\);/, `${sel} has no round corner`);
+  }
+  // an outer shadow would be clipped away with the corner, and would outrank the focus ring
+  assert.doesNotMatch(ruleOf(css, 'html[data-fullscreen="on"] .upd-pill'), /box-shadow/);
+});
+
+test('the options menu is a Helm screen: a night panel, name-voice rows, the open one the accent bar', () => {
+  const sheet = decomment(read('modules', 'hall-ui', 'public', 'settings.css').replace(/\r\n/g, '\n'));
+  const menu = sheet.slice(0, sheet.indexOf('.cli-result'));
+  assert.ok(menu.includes('.opt-rail') && menu.includes('.opt-screen'), 'the menu and the open screen are the first part of the sheet');
+  assert.doesNotMatch(menu, NO_COLOUR_LITERAL, 'no colour is typed in');
+  assert.doesNotMatch(menu, /border-radius:\s*\d/, 'no corner is typed in');
+  const rail = ruleOf(menu, '.opt-rail');
+  assert.match(rail, /background: var\(--night-glass\);/);
+  assert.match(rail, /border-left-width: var\(--line-strong\); border-right-width: var\(--line-strong\);/, 'closed left and right by the strong hairline');
+  const link = ruleOf(menu, '.opt-link');
+  assert.match(link, /font-family: var\(--name-face\);/);
+  assert.match(link, /text-transform: var\(--name-case\);/);
+  assert.match(link, /min-height: var\(--ds-space-xl\);/, 'a row clears the 24px floor many times over');
+  assert.match(link, /border-bottom: var\(--line\) solid var\(--rule-soft\);/, 'rows on hairlines, not boxes');
+  assert.match(ruleOf(menu, '.opt-link--active, .opt-link--active:hover'), /color: var\(--accent-on\); background: var\(--accent\);/);
+  assert.match(ruleOf(menu, '.opt-link:focus-visible'), /box-shadow: var\(--press-focus\);/, 'the ring is inside the row, so it reads on the accent bar');
+  const screen = ruleOf(menu, '.opt-screen');
+  assert.match(screen, /font-family: var\(--name-face\);/);
+  assert.match(screen, /border-bottom: var\(--line-strong\) solid var\(--rule\);/);
+  const section = ruleOf(menu, '.settings-groups .scroll');
+  assert.match(section, /background: none;/, 'a section is a row on a hairline, not a card');
+  assert.match(section, /border-bottom: var\(--line\) solid var\(--rule-soft\);/);
+  // the search is the hall's one field: the sheet draws no edge, corner or focus of its own for it
+  assert.doesNotMatch(ruleOf(menu, '.opt-search input'), /border|outline/);
+  assert.doesNotMatch(menu, /\.opt-search input:focus/);
+  // the two names are words the menu already had: its own label, and the open entry's
+  const js = read('modules', 'hall-ui', 'public', 'options-menu.js');
+  assert.match(js, /<p class="opt-title" aria-hidden="true">Options<\/p>/);
+  assert.match(js, /h\.setAttribute\('aria-hidden', 'true'\);/);
+  assert.match(js, /h\.textContent = e\.label;/);
+  assert.match(js, /<nav|opt-search/, 'the search is still drawn');
+  assert.match(read('modules', 'hall-ui', 'public', 'settings.html'), /<nav class="opt-rail" id="settings-rail" aria-label="Options"><\/nav>/);
+});
+
+test('character select is a Helm screen: the night, cut doors, the suggested door lit, the ring inside the cut', () => {
+  const css = decomment(STYLE.replace(/\r\n/g, '\n'));
+  const picker = css.slice(css.indexOf('\n.craft-picker {'), css.indexOf('\n.craft-art {'));
+  assert.doesNotMatch(picker, NO_COLOUR_LITERAL, 'no colour is typed in');
+  assert.doesNotMatch(picker, /border-radius:\s*\d|font-size:\s*\d/, 'no corner or size is typed in');
+  assert.match(ruleOf(css, '.craft-picker--create'), /background: var\(--bg\);/, 'a screen on the night, not a box on a scrim');
+  assert.match(ruleOf(css, '.craft-picker__panel--create'), /background: none;/);
+  const title = ruleOf(css, '.craft-picker__title');
+  assert.match(title, /font-family: var\(--name-face\);/);
+  assert.match(title, /text-transform: var\(--name-case\);/);
+  const door = ruleOf(css, '.craft-door');
+  assert.match(door, /clip-path: var\(--cut-path\);/, 'a door is pressed, so it is cut');
+  assert.match(door, /background: var\(--night-glass\);/);
+  assert.match(ruleOf(css, '.craft-door:focus-visible'), /outline: 0;[^}]*box-shadow: var\(--press-focus\);/);
+  assert.match(ruleOf(css, '.craft-door--pre, .craft-door--pre:hover'), /box-shadow: inset 0 0 0 2px var\(--accent\);/);
+  assert.match(ruleOf(css, '.craft-door::after'), /box-shadow: inherit;/, 'the edge is drawn over the portrait as well as under it');
+  assert.match(ruleOf(css, '.craft-door__name'), /font-family: var\(--name-face\);/);
+  // the real sprites, and the words where they were
+  const js = read('modules', 'hall-ui', 'public', 'craft-mode.js');
+  for (const id of ['artisan', 'artist', 'patron']) assert.ok(fs.existsSync(path.join(HALL, 'characters', id + '.png')), `${id}.png`);
+  assert.match(js, /id="craft-picker-title">Choose your character<\/h2>/);
+  assert.match(js, /aria-describedby="craft-picker-lede"/);
+});
+
+test('the visor reads in the Helm night: no hover falls back to the pack\'s dark accent', () => {
+  const visor = decomment(read('modules', 'hall-ui', 'public', 'visor.css'));
+  assert.doesNotMatch(visor, /--accent-deep/, 'the deep accent is a light-ground colour; on the night it is under 4.5:1');
+  assert.match(visor, /\.visor__row:hover \{ color: var\(--accent-ink\); \}/);
+});

package/tests/hall_start_screen.mjs

@@ -188,12 +188,21 @@ test('a sign-in passes through the start screen and the load screen before the w
   const { page, errors } = await signedIn(ctx);
   await page.waitForSelector('#game-start');
   assert.deepEqual(await state(page), { start: true, welcome: false, picker: false, game: null, full: null },
-    'the start screen, not the welcome and not the picker; game mode is not on until Start');
+    'the start screen, not the welcome and not the picker; game mode is not on until it is chosen');
+  // task 1005200: first the chooser — game or classic — then, for game, the start screen.
+  const views = await page.evaluate(() => ({
+    items: Array.from(document.querySelectorAll('.gs__items:not([hidden]) .gs__item')).map((e) => e.textContent),
+    focus: document.activeElement.textContent,
+  }));
+  assert.deepEqual(views, { items: ['GameThe city, full screen', 'ClassicThe hall with its sidebar'], focus: 'GameThe city, full screen' });
+  await page.keyboard.press('Enter');
+  await page.waitForSelector('#gs-items:not([hidden])');
+  assert.equal((await state(page)).game, 'on', 'choosing Game turns game mode on');
   const menu = await page.evaluate(() => ({
     title: document.getElementById('gs-title').textContent,
-    items: Array.from(document.querySelectorAll('.gs__items:not(.gs__items--extras) .gs__item')).map((e) => e.textContent),
+    items: Array.from(document.querySelectorAll('.gs__items:not(.gs__items--extras):not([hidden]) .gs__item')).map((e) => e.textContent),
     focus: document.activeElement.textContent,
-    small: Array.from(document.querySelectorAll('.gs__items:not(.gs__items--extras) .gs__item')).filter((e) => e.getBoundingClientRect().height < 46).length,
+    small: Array.from(document.querySelectorAll('.gs__items:not(.gs__items--extras):not([hidden]) .gs__item')).filter((e) => e.getBoundingClientRect().height < 46).length,
   }));
   assert.deepEqual(menu, { title: 'Harbor', items: ['Start', 'Options', 'Achievements', 'Extras', 'Quit'], focus: 'Start', small: 0 });
 
@@ -253,6 +262,29 @@ test('a sign-in passes through the start screen and the load screen before the w
   await ctx.close();
 });
 
+// task 1005200: Classic at the chooser — the screen goes, game mode is off, and the account
+// is told. The view chosen last time is the one marked and focused.
+test('choosing Classic at sign-in closes the screen, leaves game mode off, and saves it to the account', { skip }, async () => {
+  const ctx = await hall();
+  const saved = [];
+  await ctx.route(ORIGIN + '/api/bongos/me/hall-view', (route) => {
+    if (route.request().method() === 'PATCH') saved.push(JSON.parse(route.request().postData()));
+    return route.fulfill({ contentType: 'application/json', body: JSON.stringify({ view: null }) });
+  });
+  const page = await ctx.newPage();
+  await page.addInitScript(() => { try { localStorage.setItem('hall-welcome-signin', '1'); localStorage.setItem('hall-game', 'off'); } catch (_) { /* no storage */ } });
+  await page.goto(ORIGIN + '/');
+  await page.waitForFunction(() => !!window.OTBShell && !!window.OTBWelcome && !!window.OTBShellGame);
+  await page.evaluate(() => { const me = { authed: true, rank: 'metic', builder: { id: 7, display_name: 'Ada', github_login: 'ada' } }; window.OTBShell.applyAccess(me); window.OTBShell.applyAccess(me); });
+  await page.waitForSelector('#game-start');
+  assert.equal(await page.evaluate(() => document.activeElement.textContent), 'ClassicLast timeThe hall with its sidebar', 'the view chosen last time is focused and marked');
+  await page.keyboard.press('Enter');
+  await page.waitForSelector('#game-start', { state: 'detached' });
+  assert.equal((await state(page)).game, null);
+  assert.deepEqual(saved, [{ view: 'classic' }]);
+  await ctx.close();
+});
+
 test('on a phone the panel is the whole width, nothing scrolls sideways and every choice clears the floor (task 1005192)', { skip }, async () => {
   for (const [w, h] of [[390, 844], [320, 700]]) {
     const ctx = await hall({ viewport: { width: w, height: h } });
@@ -266,6 +298,7 @@ test('on a phone the panel is the whole width, nothing scrolls sideways and ever
       };
     });
     assert.deepEqual(m, { x: 0, w, sideways: 0, small: 0 }, `at ${w}px`);
+    await page.click('[data-gs="view-game"]');
     await page.click('[data-gs="start"]');
     await page.waitForSelector('#gs-load:not([hidden])');
     assert.equal(await page.evaluate(() => { const gs = document.getElementById('game-start'); return gs.scrollWidth - gs.clientWidth; }), 0, `the load screen fits ${w}px`);
@@ -279,6 +312,7 @@ test('Quit closes the tab, and says so when the browser keeps it open', { skip }
   const { page } = await signedIn(ctx);
   await page.waitForSelector('#game-start');
   await page.evaluate(() => { window.__closed = 0; window.close = () => { window.__closed += 1; }; });
+  await page.click('[data-gs="view-game"]');
   await page.click('[data-gs="quit"]');
   await page.waitForSelector('#gs-note:not([hidden])');
   assert.equal(await page.evaluate(() => window.__closed), 1);
@@ -291,6 +325,7 @@ test('with no city to draw, or with reduced motion, the still and the tip stand
     const ctx = await hall(opts);
     const { page, errors } = await signedIn(ctx);
     await page.waitForSelector('#game-start');
+    await page.click('[data-gs="view-game"]');
     await page.click('[data-gs="start"]');
     await page.waitForSelector('#gs-load:not([hidden])');
     assert.match(await page.textContent('#gs-tip'), /\.$/);

package/tests/hall_topbar_320.mjs

@@ -99,7 +99,9 @@ for (const scheme of ['light', 'dark']) {
   });
 }
 
-test('the top bar search and the mode switch are one shape: a pill with the same hairline', { skip }, async () => {
+// Helm (task 1005194): the hall has no pill, so the one shape the two share is the hall's
+// square corner (--radius-pill is 0px in the hall tier) inside the same hairline.
+test('the top bar search and the mode switch are one shape: the square corner of the hall with the same hairline', { skip }, async () => {
   const ctx = await context(1440, 'dark');
   const page = await ctx.newPage();
   await page.goto(ORIGIN + '/work');
@@ -115,11 +117,12 @@ test('the top bar search and the mode switch are one shape: a pill with the same
       switchRadius: css(sw).borderTopLeftRadius,
       jumpEdge: css(jump).borderTopColor,
       switchShadow: css(sw).boxShadow,
-      pill: root.getPropertyValue('--ds-radius-pill').trim(),
+      pill: root.getPropertyValue('--radius-pill').trim(),
     };
   }).finally(() => ctx.close());
-  assert.equal(s.jumpRadius, s.pill, 'the search is a full pill');
-  assert.equal(s.switchRadius, s.pill, 'the mode switch is a full pill');
+  assert.equal(s.pill, '0px', 'the hall tier squares the pill');
+  assert.equal(s.jumpRadius, s.pill, 'the search takes the corner of the hall');
+  assert.equal(s.switchRadius, s.pill, 'the mode switch takes the same corner');
   assert.ok(s.switchShadow.startsWith(s.jumpEdge), `the two share one hairline colour (${s.jumpEdge} vs ${s.switchShadow})`);
 });
 

package/tests/hall_view_prefs.mjs

@@ -0,0 +1,42 @@
+// tests/hall_view_prefs.mjs — the game-or-classic choice kept on the account
+// (task 1005200, modules/builder-settings/hall-view-prefs.js), and the two routes
+// that read and write it.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = fileURLToPath(new URL('..', import.meta.url));
+const prefs = require('../modules/builder-settings/hall-view-prefs.js');
+
+test('never chosen is null, not a default view: the sign-in chooser asks', () => {
+  assert.equal(prefs.storedView({}), null);
+  assert.equal(prefs.storedView(null), null);
+  assert.equal(prefs.storedView({ hall_view: 'fullscreen' }), null, 'an unknown value is not a choice');
+  assert.deepEqual(prefs.describeForApi({ hall_view: 'game' }), { view: 'game', views: ['game', 'classic'] });
+});
+
+test('a PATCH takes exactly { view: game | classic }', () => {
+  assert.deepEqual(prefs.validatePatch({ view: 'classic' }), { ok: true, view: 'classic' });
+  assert.equal(prefs.validatePatch({}).ok, false, 'no view');
+  assert.equal(prefs.validatePatch({ view: 'both' }).ok, false);
+  assert.equal(prefs.validatePatch({ view: 'game', extra: 1 }).ok, false, 'unknown keys refused');
+  assert.equal(prefs.validatePatch([]).ok, false);
+});
+
+test('saving the view keeps every other behaviour preference', () => {
+  const before = { wandering: 2, widgets: 'rich', interaction: { verbosity: 'concise' } };
+  const after = prefs.applyView(before, 'game');
+  assert.deepEqual(after, { ...before, hall_view: 'game' });
+  assert.equal(before.hall_view, undefined, 'pure: the input is not changed');
+});
+
+test('the routes: own builder only, GET and PATCH on /me/hall-view', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules/builder-settings/routes/settings.js'), 'utf8');
+  assert.match(src, /router\.get\('\/me\/hall-view', api\.requireBuilder,/);
+  assert.match(src, /router\.patch\('\/me\/hall-view', api\.requireBuilder,/);
+  assert.match(src, /hallViewPrefs\.applyView\(existing, v\.view\)/, 'writes through the pure shaper');
+});

package/tests/hall_visor.mjs

@@ -151,7 +151,7 @@ test('in game mode the glass shows the place, the main action, the sprite and th
   }));
   assert.equal(g.shown, 'block');
   assert.equal(g.place, 'Test city');
-  assert.match(g.main, /^Claim a task/);
+  assert.match(g.main, /^Goal sky/, 'Claim a task opens a classic page, so it is off the glass in game mode (task 1005200)');
   assert.equal(g.who, 'Artisan');
   assert.equal(g.credits, '56,021 credits');
   assert.equal(g.sprite, '/builders/characters/artisan.png');
@@ -189,7 +189,8 @@ test('the sheet lists the character\'s actions, then this place, and runs a scen
   const { ctx, page } = await open();
   await page.click('[data-visor-sheet]');
   const rows = await page.$$eval('.visor__sheet .visor__row', (r) => r.map((x) => [...x.children].map((c) => c.textContent).join(' ')));
-  assert.deepEqual(rows, ['Claim a task C', 'Blockers B', 'Goal sky G', 'Your thinking T', 'Back to centre 0', 'Look around drag', 'Options Esc']);
+  // task 1005200: Claim a task and Blockers open classic pages, so they are off the glass.
+  assert.deepEqual(rows, ['Goal sky G', 'Your thinking T', 'Back to centre 0', 'Look around drag', 'Options Esc']);
   await page.click('[data-visor-scene="0"]');
   assert.deepEqual(await page.evaluate(() => ({ centred: window.centred, open: OTBVisor.isOpen() })), { centred: true, open: false });
   await ctx.close();

package/tests/nav_permission_atoms.mjs

@@ -103,7 +103,7 @@ test('the hall-preview fixture carries every atom /me resolves', () => {
 // task 1005070: the remembered nav (the rail paints before /me).
 // task 1005088: the sidebar mark is drawn by reference to the one brand mark.
 // task 1005144: My agents, Project settings, Permissions and Modules left for the options menu.
-const SHELL_SHA = 'a4d41b30b41e49f4';
+const SHELL_SHA = '89f6f166ed22a8ee';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);