@bongos/core 1.21.175 → 1.21.176

package/tests/version_literals.mjs

@@ -18,8 +18,8 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const g = require(path.join(ROOT, 'scripts', 'gds', 'version-literal-guard.js'));
-const { pickDefaultVersion } = require(path.join(ROOT, 'scripts', 'gds', 'version-select.js'));
+const g = require(path.join(ROOT, 'scripts', 'bongos', 'version-literal-guard.js'));
+const { pickDefaultVersion } = require(path.join(ROOT, 'scripts', 'bongos', 'version-select.js'));
 const read = (...p) => fs.readFileSync(path.join(ROOT, ...p), 'utf8');
 const scan = (files) => g.scanScripts(Object.keys(files), (f) => files[f]);
 
@@ -51,25 +51,25 @@ test('a null started_at cannot decide the answer', () => {
 
 // ---- what the guard MUST catch -------------------------------------------
 test('THE INCIDENT: a version field assigned a literal is caught', () => {
-  const r = scan({ 'scripts/gds/smoke.sh': "  'version_id': 'PMS-V1'," });
+  const r = scan({ 'scripts/bongos/smoke.sh': "  'version_id': 'PMS-V1'," });
   assert.equal(r.violations.length, 1);
   assert.match(r.violations[0], /RESOLVED/);
   assert.match(r.violations[0], /version-select/, 'and it names the remedy');
 });
 
 test('a --version default is caught', () => {
-  const r = scan({ 'scripts/gds/a.js': "  const v = arg('--version', args) || 'GDS-V3';" });
+  const r = scan({ 'scripts/bongos/a.js': "  const v = arg('--version', args) || 'GDS-V3';" });
   assert.equal(r.violations.length, 1);
 });
 
 test('a DEFAULT_VERSION constant is caught', () => {
-  const r = scan({ 'scripts/gds/b.js': "const DEFAULT_VERSION = process.env.X || 'BONGOS-V1';" });
+  const r = scan({ 'scripts/bongos/b.js': "const DEFAULT_VERSION = process.env.X || 'BONGOS-V1';" });
   assert.equal(r.violations.length, 1);
 });
 
 test('an unknown future prefix is caught too', () => {
   // Enumerating PMS/GDS/BONGOS/CB would let the next scheme through.
-  const r = scan({ 'scripts/gds/c.js': "  version_id: 'ACME-V7'," });
+  const r = scan({ 'scripts/bongos/c.js': "  version_id: 'ACME-V7'," });
   assert.equal(r.violations.length, 1, 'the shape is matched, not a fixed list');
 });
 
@@ -77,29 +77,29 @@ test('an unknown future prefix is caught too', () => {
 test('a COMMENT naming an old version is not a violation', () => {
   // smoke-claim-consistency.sh legitimately says "PMS-V2 P6 not live yet".
   const r = scan({
-    'scripts/gds/d.sh': '# TODO: once PMS-V2 P6 ships, drop this',
-    'scripts/gds/e.js': "// version_id: 'GDS-V3' used to live here",
+    'scripts/bongos/d.sh': '# TODO: once PMS-V2 P6 ships, drop this',
+    'scripts/bongos/e.js': "// version_id: 'GDS-V3' used to live here",
   });
   assert.deepEqual(r.violations, []);
 });
 
 test('prose printed to the operator is not a violation', () => {
-  const r = scan({ 'scripts/gds/f.sh': '  echo "SKIP — PMS-V2 P6 not live yet"' });
+  const r = scan({ 'scripts/bongos/f.sh': '  echo "SKIP — PMS-V2 P6 not live yet"' });
   assert.deepEqual(r.violations, []);
 });
 
 test('a RESOLVED assignment is not a violation', () => {
-  const r = scan({ 'scripts/gds/g.js': '  version_id: await resolveDefaultVersion(),' });
+  const r = scan({ 'scripts/bongos/g.js': '  version_id: await resolveDefaultVersion(),' });
   assert.deepEqual(r.violations, []);
 });
 
 test('seeders and tests are exempt BY PATH, not by allowlist', () => {
   // A seeder's whole subject IS a historical version; asking it to resolve one
   // at runtime would break it.
-  for (const p of ['scripts/gds/seed-v3-tasks.js', 'scripts/gds/newcomer-floor.test.js', 'scripts/hall-preview/fixtures/x.js']) {
+  for (const p of ['scripts/bongos/seed-v3-tasks.js', 'scripts/bongos/newcomer-floor.test.js', 'scripts/hall-preview/fixtures/x.js']) {
     assert.equal(g.isExempt(p), true, `${p} must be exempt`);
   }
-  assert.equal(g.isExempt('scripts/gds/smoke-write.sh'), false, 'an ops script is not exempt');
+  assert.equal(g.isExempt('scripts/bongos/smoke-write.sh'), false, 'an ops script is not exempt');
 });
 
 // ---- the live tree --------------------------------------------------------
@@ -124,7 +124,7 @@ test('every allowlist entry carries a real justification', () => {
 
 // ---- the reported bug is actually fixed ----------------------------------
 test('smoke-write.sh resolves its version instead of naming one', () => {
-  const sh = read('scripts', 'gds', 'smoke-write.sh');
+  const sh = read('scripts', 'bongos', 'smoke-write.sh');
   assert.ok(!/'version_id': '[A-Z]/.test(sh), 'no literal remains');
   // The invocation is `$(node "$(dirname "$0")/version-select.js")`, so the
   // closing paren is preceded by a quote AND the inner $(dirname "$0") contains
@@ -135,7 +135,7 @@ test('smoke-write.sh resolves its version instead of naming one', () => {
 
 test('all four bash smokes resolve, and none names a version', () => {
   for (const f of ['smoke-write.sh', 'smoke-claim-consistency.sh', 'smoke-batch-release.sh', 'smoke-batch-claim.sh']) {
-    const sh = read('scripts', 'gds', f);
+    const sh = read('scripts', 'bongos', f);
     assert.match(sh, /version-select\.js/, `${f} resolves`);
     assert.match(sh, /'version_id': '\$\{VERSION_ID\}'/, `${f} uses the resolved id`);
   }
@@ -143,7 +143,7 @@ test('all four bash smokes resolve, and none names a version', () => {
 
 test('capture.js no longer keeps its own copy of the rule', () => {
   // It was the precedent; now it is a caller, so there is ONE implementation.
-  const src = read('scripts', 'gds', 'capture.js');
+  const src = read('scripts', 'bongos', 'capture.js');
   assert.match(src, /require\('\.\/version-select\.js'\)/);
   assert.ok(!/async function resolveDefaultVersion/.test(src), 'the private copy is gone');
 });
@@ -153,7 +153,7 @@ test('an unsafe version id is REFUSED, not printed', () => {
   // Bash callers splice this into a quoted Python string, so the one place that
   // can guarantee safety is the source. Ids with a quote or backslash could
   // otherwise break out of the literal (the grader's defense-in-depth finding).
-  const { SAFE_ID } = require(path.join(ROOT, 'scripts', 'gds', 'version-select.js'));
+  const { SAFE_ID } = require(path.join(ROOT, 'scripts', 'bongos', 'version-select.js'));
   for (const bad of ["CB-V1'; import os", 'CB\\V1', "'", '', '1-V1', 'a b']) {
     assert.equal(SAFE_ID.test(bad), false, `${JSON.stringify(bad)} must be refused`);
   }
@@ -165,7 +165,7 @@ test('an unsafe version id is REFUSED, not printed', () => {
 test('session-eval resolves the version ONCE, not per finding', () => {
   // It was called inside `for (const s of systemic)` — a network round trip per
   // finding, for a value invariant across the run.
-  const src = read('scripts', 'gds', 'session-eval.js');
+  const src = read('scripts', 'bongos', 'session-eval.js');
   // Anchored on the CALL COUNT rather than on a loop position: the file has TWO
   // `for (const s of systemic)` loops, so an indexOf-based test picked the wrong
   // one and passed vacuously. Exactly one call site is the real invariant.
@@ -177,7 +177,7 @@ test('session-eval resolves the version ONCE, not per finding', () => {
 
 test('version-select exits through cliExit, not process.exit', () => {
   // CLAUDE.md: cliExit is the always-correct move for handle closure.
-  const src = read('scripts', 'gds', 'version-select.js');
+  const src = read('scripts', 'bongos', 'version-select.js');
   assert.match(src, /require\('\.\/cli-lib'\)/);
   assert.ok(!/process\.exit\(/.test(src), 'no raw process.exit remains');
 });
@@ -188,7 +188,7 @@ test('ship-flow.js imports every cross-module function it calls', () => {
   // claim resolved — found by hitting it while shipping this task. Guarding the
   // one name is not enough; assert the import exists for anything it calls from
   // its sibling deploy-target module.
-  const src = read('scripts', 'gds', 'ship-flow.js');
+  const src = read('scripts', 'bongos', 'ship-flow.js');
   const deployTargetExports = ['pushVia', 'resolveDeployMode', 'mainIsProtected', 'resolveDeployTarget'];
   const imported = /require\('\.\/ship-deploy-target\.js'\)/.test(src)
     ? (src.match(/const \{([^}]*)\} = require\('\.\/ship-deploy-target\.js'\)/) || [, ''])[1]
@@ -201,7 +201,7 @@ test('ship-flow.js imports every cross-module function it calls', () => {
 });
 
 // ---- an exemption must not outlive its justification ----------------------
-// Task 1004071. scripts/gds/status.js sat on VERSION_LITERAL_ALLOW justified by
+// Task 1004071. scripts/bongos/status.js sat on VERSION_LITERAL_ALLOW justified by
 // "TWO versions are currently building — so 'most recent building' is not a
 // derivable answer here." That was true the day it was written (BONGOS-V1 and
 // CB-V1). It is false now: one version builds. Nothing noticed, because the
@@ -217,7 +217,7 @@ test('ship-flow.js imports every cross-module function it calls', () => {
 // dead, including grade-smoke.js, which plainly still carries two. The source is
 // therefore re-scanned under a synthetic path that is on neither the allowlist
 // nor isExempt's patterns, which is the only way to see what the guard WOULD say.
-const PROBE = 'scripts/gds/__allowlist_probe__.js';
+const PROBE = 'scripts/bongos/__allowlist_probe__.js';
 const scanUnexempt = (src) => g.scanScripts([PROBE], () => src);
 
 test('the probe path really is unexempt — otherwise every check below is vacuous', () => {
@@ -249,10 +249,10 @@ test('THE INCIDENT: status.js is no longer exempt, and names no version literal'
   // nothing for good. Scanned under the probe path so this stays honest even if
   // someone re-adds the allowlist entry.
   assert.ok(
-    !g.VERSION_LITERAL_ALLOW.has('scripts/gds/status.js'),
+    !g.VERSION_LITERAL_ALLOW.has('scripts/bongos/status.js'),
     'status.js resolves its default at runtime now — it must not stay exempt'
   );
-  assert.deepEqual(scanUnexempt(read('scripts', 'gds', 'status.js')).violations, []);
+  assert.deepEqual(scanUnexempt(read('scripts', 'bongos', 'status.js')).violations, []);
 });
 
 // ---- the fallback shape ASSIGNED could not see ----------------------------

package/tests/visual_review.mjs

@@ -14,8 +14,8 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { makeRunner } from './helpers.mjs';
-import { parseArgs, buildReviewPage } from '../scripts/gds/review-sheet.js';
-import { pathsNamedIn, visualReviewNudge } from '../scripts/gds/visual-review-nudge.js';
+import { parseArgs, buildReviewPage } from '../scripts/bongos/review-sheet.js';
+import { pathsNamedIn, visualReviewNudge } from '../scripts/bongos/visual-review-nudge.js';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const read = (rel) => fs.readFileSync(path.join(ROOT, rel), 'utf8');
@@ -52,7 +52,7 @@ await test('the CLI writes the page and prints its path; a missing image is an e
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'visual-review-test-'));
   const png = path.join(dir, 'shot.png');
   fs.writeFileSync(png, 'not really a png');
-  const cli = path.join(ROOT, 'scripts', 'gds', 'review-sheet.js');
+  const cli = path.join(ROOT, 'scripts', 'bongos', 'review-sheet.js');
   const ok = spawnSync(process.execPath, [cli, '--shot', `Before=${png}`, '--out', dir, '--no-open'], { encoding: 'utf8' });
   assert.equal(ok.status, 0, ok.stderr);
   assert.equal(ok.stdout.trim(), path.join(dir, 'index.html'));
@@ -86,12 +86,12 @@ await test('touches[], a UI module label, and the artist craft nudge too — the
 
 await test('a backend task is not nudged — no noise on work that renders nothing', () => {
   assert.equal(visualReviewNudge(task({ description: 'Fix modules/lifecycle/cascade.js and modules/hall-ui/module.json.' })), null);
-  assert.equal(visualReviewNudge(task({ touches: ['scripts/gds/claim.js'] })), null);
+  assert.equal(visualReviewNudge(task({ touches: ['scripts/bongos/claim.js'] })), null);
   assert.equal(visualReviewNudge(task()), null);
 });
 
 await test('claim.js prints the nudge after the craft role line, and cannot fail a claim with it', () => {
-  const src = read('scripts/gds/claim.js');
+  const src = read('scripts/bongos/claim.js');
   const at = src.indexOf('visualReviewNudge(task)');
   const role = src.indexOf('printRoleLine(task);');
   assert.ok(role > -1, 'the role line call exists (task 1002992 renamed it from printDisciplineMode)');

package/tests/wedge_remedy.mjs

@@ -19,11 +19,11 @@ import path from 'node:path';
 
 process.env.PROVISION_APP_USER = process.env.PROVISION_APP_USER || 'lars'; // appUser() refuses a Windows account name
 const require = createRequire(import.meta.url);
-const W = require('../scripts/gds/wedge-remedy.js');
-const R = require('../scripts/gds/provision-core-upgrade.js');
-const P = require('../scripts/gds/provision.js');
-const { REASON_CLASS } = require('../scripts/gds/upgrade-outcome.js');
-const { DEFAULT_RETRY_DELAY_MS } = require('../scripts/gds/intent-retry.js');
+const W = require('../scripts/bongos/wedge-remedy.js');
+const R = require('../scripts/bongos/provision-core-upgrade.js');
+const P = require('../scripts/bongos/provision.js');
+const { REASON_CLASS } = require('../scripts/bongos/upgrade-outcome.js');
+const { DEFAULT_RETRY_DELAY_MS } = require('../scripts/bongos/intent-retry.js');
 
 let passed = 0;
 let failed = 0;

package/tests/welcome_boot.mjs

@@ -0,0 +1,116 @@
+// tests/welcome_boot.mjs — the welcome's pure parts (tasks 1004785, 1004818).
+//
+// WHY. The welcome decides things a reader would only notice going wrong over days: whether today
+// is the first visit, whether it is day or night (and so which painting), what the banner names,
+// where each role goes, and whether the motion still sits on the painting. Those are pure, so this
+// runs the REAL welcome-boot.js (it is Node-require-safe). The overlay itself is
+// tests/welcome_boot_browser.mjs.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+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 W = require(path.join(HALL, 'welcome-boot.js'));
+
+test('the first visit of the day is by LOCAL date, and a stored day for today is not one', () => {
+  const morning = new Date(2026, 9, 23, 0, 5);      // 00:05 local, Oct 23
+  const night = new Date(2026, 9, 23, 23, 55);
+  assert.equal(W.localDay(morning), '2026-10-23');
+  assert.equal(W.localDay(night), '2026-10-23', 'late evening is still the same local day');
+  assert.equal(W.localDay(new Date(2026, 0, 5, 12)), '2026-01-05', 'months and days are zero-padded');
+  assert.equal(W.firstVisitToday(null, morning), true, 'never seen');
+  assert.equal(W.firstVisitToday('2026-10-22', morning), true, 'seen yesterday');
+  assert.equal(W.firstVisitToday('2026-10-23', night), false, 'seen earlier today');
+  assert.equal(W.firstVisitToday('garbage', night), true);
+});
+
+test('the greeting follows the local hour, and the name falls back sensibly', () => {
+  assert.equal(W.greetingFor(new Date(2026, 9, 23, 6)), 'Good morning');
+  assert.equal(W.greetingFor(new Date(2026, 9, 23, 11, 59)), 'Good morning');
+  assert.equal(W.greetingFor(new Date(2026, 9, 23, 12)), 'Good afternoon');
+  assert.equal(W.greetingFor(new Date(2026, 9, 23, 18)), 'Good evening');
+  assert.equal(W.nameOf({ display_name: 'Ada', github_login: 'ada' }), 'Ada');
+  assert.equal(W.nameOf({ github_login: 'ada' }), 'ada');
+  assert.equal(W.nameOf({}), 'builder');
+});
+
+test('day is 06:00 to 17:59 local, night the rest, and each has its painting (task 1004818)', () => {
+  const at = (h, m = 0) => W.timeOfDay(new Date(2026, 9, 23, h, m));
+  assert.deepEqual([at(5, 59), at(6), at(12), at(17, 59), at(18), at(23, 30), at(0)],
+    ['night', 'day', 'day', 'day', 'night', 'night', 'night']);
+  assert.equal(W.artFor('day'), '/builders/welcome-day.webp');
+  assert.equal(W.artFor('night'), '/builders/welcome-night.webp');
+});
+
+test('both paintings ship, as WebP, in the one shape the motion is laid out for', () => {
+  for (const url of Object.values(W.ART)) {
+    const file = path.join(HALL, url.replace(/^\/builders\//, ''));
+    const buf = fs.readFileSync(file);
+    assert.equal(buf.toString('latin1', 0, 4) + buf.toString('latin1', 8, 12), 'RIFFWEBP', url + ' is a WebP');
+    assert.ok(buf.length < 400 * 1024, url + ' stays small enough for a first paint');
+    // The VP8X header carries the canvas size (24-bit, minus one) at bytes 24..29.
+    assert.equal(buf.toString('latin1', 12, 16), 'VP8X', url + ' carries its size');
+    const w = 1 + buf.readUIntLE(24, 3), h = 1 + buf.readUIntLE(27, 3);
+    assert.deepEqual([w, h], [W.AW, W.AH], url + ' is the painting the lights were placed on');
+  }
+});
+
+test('every light sits inside the painting, and every pulse climbs inside its tower', () => {
+  const inside = ([x, y]) => x >= 0 && x <= W.AW && y >= 0 && y <= W.AH;
+  for (const b of W.BEACONS) assert.ok(inside(b), 'beacon ' + b);
+  for (const t of W.TOWERS) assert.ok(inside([t.x, t.y]) && inside([t.x + t.w, t.y + t.h]), 'tower inside the painting');
+  const runs = W.pulseRuns(W.TOWERS, 3, 7);
+  assert.equal(runs.length, W.TOWERS.length * 3);
+  for (const r of runs) {
+    const t = W.TOWERS[r.tower];
+    assert.ok(r.x >= t.x && r.x <= t.x + t.w, 'a pulse runs up its own tower');
+    assert.ok(r.y1 > r.y0 && r.y0 >= t.y && r.y1 <= t.y + t.h, 'bottom to top, within the tower');
+    assert.ok(r.dur > 0 && r.delay >= 0);
+  }
+  assert.deepEqual(W.pulseRuns(W.TOWERS, 3, 7), runs, 'seeded: every visit draws the same picture');
+});
+
+test('the banner names the project from the branding pack, never a hardcoded word', () => {
+  assert.equal(W.bannerText({ identity: { worldName: 'Harbor', productName: 'Cloud Bongos' } }), 'Working on the core of Harbor');
+  assert.equal(W.bannerText({ identity: { productName: 'Cloud Bongos' } }), 'Working on the core of Cloud Bongos');
+  assert.equal(W.bannerText(undefined), 'Working on the core of this project', 'no branding: still a sentence');
+  const branding = JSON.parse(fs.readFileSync(path.join(ROOT, 'config', 'branding.neutral.json'), 'utf8'));
+  assert.equal(W.bannerText(branding), 'Working on the core of ' + branding.identity.worldName);
+});
+
+test('the owner\'s role mapping: destination and craft mode', () => {
+  const map = Object.fromEntries(W.ROLES.map((r) => [r.id, [r.label, r.room, r.href, r.mode]]));
+  assert.deepEqual(map, {
+    owner: ['Owner', 'City', '/city', 'governing'],
+    ideator: ['Ideator', 'Your thinking', '/thinking', 'ideating'],
+    artist: ['Artist', 'Studio', '/studio', 'artistry'],
+    engineer: ['Engineer', 'Home', null, 'building'],
+  });
+  // Every mode is one craft-mode.js knows, so OTBCraftMode.choose can never be handed a stranger.
+  const craft = fs.readFileSync(path.join(HALL, 'craft-mode.js'), 'utf8');
+  for (const r of W.ROLES) assert.match(craft, new RegExp(`id: '${r.mode}'`), r.mode);
+});
+
+test('the Owner role shows only where Governing is offered', () => {
+  const ids = (c) => W.rolesFor(c).map((r) => r.id);
+  assert.deepEqual(ids({ offered: (m) => m !== 'governing' }), ['ideator', 'artist', 'engineer'], 'no seat: no Owner');
+  assert.deepEqual(ids({ offered: () => true }), ['owner', 'ideator', 'artist', 'engineer']);
+  assert.deepEqual(ids(null), ['owner', 'ideator', 'artist', 'engineer'], 'no craft mode at all: the four, the pages gate themselves');
+});
+
+test('Home loads the welcome before the shell, and the shell asks it before the craft picker', () => {
+  const html = fs.readFileSync(path.join(HALL, 'index.html'), 'utf8');
+  const at = (f) => html.indexOf('/builders/' + f);
+  // Before the shell-trail/craft-mode/shell trio, which tests/craft_mode.mjs keeps adjacent.
+  assert.ok(at('welcome-boot.js') > 0 && at('welcome-boot.js') < at('shell-trail.js') && at('shell-trail.js') < at('shell.js'),
+    'welcome-boot.js, then the shell trio');
+  assert.ok(at('welcome-boot.css') > 0, 'and its sheet');
+  const shell = fs.readFileSync(path.join(HALL, 'shell.js'), 'utf8');
+  assert.match(shell, /if \(!\(window\.OTBWelcome && window\.OTBWelcome\.onAccess\(access, state && state\.builder\)\) && CRAFT\) CRAFT\.onAccess\(/,
+    'the picker is asked only when the welcome did not show');
+});

package/tests/welcome_boot_browser.mjs

@@ -0,0 +1,271 @@
+// tests/welcome_boot_browser.mjs — the welcome in a real browser (tasks 1004785, 1004818).
+//
+// WHY. "Once a day", "Skip", "the craft picker does not also open", "Owner only with a seat", the day
+// and night paintings and the slow way out are behaviour across the real shell.js, craft-mode.js and
+// welcome-boot.js together — the shell is what decides which of the two greets a builder — so this
+// serves the REAL Home markup, the REAL hall scripts and the REAL paintings from a routed origin
+// (localStorage needs one) in the ui-design kit's launcher. Every wait is on DOM state, never on a
+// flag that flips before the DOM settles (the task 1004780 CI flake). Skips when the machine has no
+// system Edge or Chrome, as ui_design_kit_fit does.
+import assert from 'node:assert/strict';
+import { test, after } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+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 lib = require(path.join(ROOT, 'modules', 'ui-design', 'kit', 'lib.js'));
+
+let browser = null;
+try { browser = await lib.launchBrowser(); } catch (e) { if (!(e instanceof lib.NoBrowserError)) throw e; }
+after(() => browser && browser.close());
+const skip = !browser && 'no system Edge or Chrome';
+
+const ORIGIN = 'http://hall.test';
+const TYPES = { '.js': 'text/javascript', '.css': 'text/css', '.webp': 'image/webp' };
+
+// Home's real markup with its scripts swapped for the four this is about, after a client stub.
+// `{{…}}` placeholders are the server's to fill; blanked here.
+const INDEX = fs.readFileSync(path.join(HALL, 'index.html'), 'utf8')
+  .replace(/<script\b[^>]*>[\s\S]*?<\/script>/g, '')
+  .replace(/\{\{[^}]*\}\}/g, '');
+const STUB = '<script>window.__BRANDING__ = { identity: { worldName: "Harbor" } }; window.BongosClient = { createClient: () => ({ request: async () => ({ ok: false, status: 404, data: null }) }) };</script>';
+const SCRIPTS = ['shell-trail.js', 'craft-mode.js', 'welcome-boot.js', 'shell.js']
+  .map((f) => `<script src="/builders/${f}"></script>`).join('');
+const PAGE = INDEX.replace('</body>', STUB + SCRIPTS + '</body>');
+
+async function hall({ art = true, reducedMotion = 'no-preference', time = null } = {}) {
+  const ctx = await browser.newContext({ viewport: { width: 1280, height: 800 }, reducedMotion });
+  if (time) await ctx.clock.setFixedTime(time);   // the wall clock only; timers still run
+  await ctx.route(ORIGIN + '/**', (route) => {
+    const p = new URL(route.request().url()).pathname;
+    if (p === '/' || p === '/index.html') return route.fulfill({ contentType: 'text/html', body: PAGE });
+    if (p === '/thinking' || p === '/city') return route.fulfill({ contentType: 'text/html', body: '<!doctype html><title>room</title><p id="room">' + p + '</p>' });
+    const ext = path.extname(p);
+    if (ext === '.webp' && !art) return route.fulfill({ status: 404, body: '' });
+    const f = path.join(HALL, p.replace(/^\/builders\//, ''));
+    if (p.startsWith('/builders/') && TYPES[ext] && fs.existsSync(f)) return route.fulfill({ contentType: TYPES[ext], body: fs.readFileSync(f) });
+    return route.fulfill({ status: 404, body: '' });
+  });
+  return ctx;
+}
+async function open(ctx) {
+  const page = await ctx.newPage();
+  const errors = [];
+  page.on('pageerror', (e) => errors.push(String(e.message)));
+  await page.goto(ORIGIN + '/');
+  await page.waitForFunction(() => !!window.OTBShell && !!window.OTBWelcome);
+  return { page, errors };
+}
+// What builders.js tells the shell once /me lands. Called twice, as a real load does. `positions` is
+// /me's server-resolved seats block; the shell settles it through the real gov-positions.js.
+const signIn = (page, positions) => page.evaluate((pos) => {
+  const builder = { id: 7, display_name: 'Ada', github_login: 'ada' };
+  const me = { authed: true, rank: 'metic', builder };
+  if (pos) me.positions = pos;
+  window.OTBShell.applyAccess(me);
+  window.OTBShell.applyAccess(me);
+}, positions || null);
+// The seats are settled once the top bar's Governing option says so (hidden, or named by the seat).
+const seatsSettled = (page, want) => page.waitForFunction((w) => {
+  const opt = document.querySelector('#craft-switch [data-craft-opt="governing"]');
+  return !!opt && (w === null ? opt.hidden : !opt.hidden && opt.textContent.indexOf(w) !== -1);
+}, want);
+const state = (page) => page.evaluate(() => ({
+  welcome: !!document.getElementById('welcome-boot'),
+  picker: !!document.getElementById('craft-picker'),
+  craft: document.documentElement.dataset.craft || null,
+  asked: sessionStorage.getItem('hall-craft-asked'),
+}));
+const done = (page) => page.waitForSelector('#welcome-boot.wb--done', { timeout: 10000 });
+
+test('first visit of the day: the welcome, not the craft picker; Skip brings the greeting up', { skip }, async () => {
+  const ctx = await hall();
+  const { page, errors } = await open(ctx);
+  await signIn(page);
+  assert.deepEqual(await state(page), { welcome: true, picker: false, craft: null, asked: '1' },
+    'the welcome shows, the picker is marked asked and does not stack on it');
+  // The painting loads and its motion is laid over it.
+  await page.waitForFunction(() => { const i = document.querySelector('#welcome-boot .wb__img'); return i && i.complete && i.naturalWidth === 1024; });
+  assert.equal(await page.isVisible('[data-wb-skip]'), true);
+  await page.click('[data-wb-skip]');
+  await done(page);
+  const after = await page.evaluate(() => ({
+    hi: document.getElementById('wb-hi').textContent,
+    live: document.getElementById('welcome-boot').classList.contains('wb--live'),
+    skip: document.querySelector('[data-wb-skip]').hidden,
+    focus: document.activeElement && document.activeElement.className,
+    day: localStorage.getItem('hall-welcome-day:7'),
+    today: window.OTBWelcome.localDay(new Date()),
+  }));
+  assert.match(after.hi, /^Good (morning|afternoon|evening), Ada$/);
+  assert.deepEqual([after.live, after.skip, after.focus, after.day], [true, true, 'wb__choice', after.today]);
+  await page.click('[data-wb-home]');
+  await page.waitForSelector('#welcome-boot', { state: 'detached' });
+  assert.deepEqual(await state(page), { welcome: false, picker: false, craft: null, asked: '1' }, 'Your home page closes it, and no picker follows');
+  assert.deepEqual(errors, []);
+  await ctx.close();
+});
+
+test('once a day: the next load the same day gets no welcome (and the picker is back to its own rule)', { skip }, async () => {
+  const ctx = await hall();
+  const first = await open(ctx);
+  await signIn(first.page);
+  await first.page.waitForSelector('#welcome-boot');
+  await first.page.close();
+  const { page } = await open(ctx);   // a new tab: a new browser session, the same local day
+  await signIn(page);
+  await page.waitForSelector('#craft-picker');
+  assert.deepEqual(await state(page), { welcome: false, picker: true, craft: null, asked: '1' });
+  await ctx.close();
+});
+
+test('a visitor who is not signed in is never greeted, and nothing is remembered', { skip }, async () => {
+  const ctx = await hall();
+  const { page } = await open(ctx);
+  await page.evaluate(() => window.OTBShell.applyAccess({ authed: false }));
+  const s = await page.evaluate(() => ({ welcome: !!document.getElementById('welcome-boot'), keys: Object.keys(localStorage).filter((k) => k.startsWith('hall-welcome-day')) }));
+  assert.deepEqual(s, { welcome: false, keys: [] });
+  await ctx.close();
+});
+
+test('Escape leaves the welcome at any point', { skip }, async () => {
+  const ctx = await hall();
+  const { page } = await open(ctx);
+  await signIn(page);
+  await page.waitForSelector('#welcome-boot');
+  await page.keyboard.press('Escape');
+  await page.waitForSelector('#welcome-boot', { state: 'detached' });
+  assert.deepEqual(await state(page), { welcome: false, picker: false, craft: null, asked: '1' });
+  assert.equal(await page.evaluate(() => document.documentElement.classList.contains('wb-open')), false, 'the page scrolls again');
+  await ctx.close();
+});
+
+test('roles: no seat hides Owner; Ideator sets the mode and goes to Your thinking', { skip }, async () => {
+  const ctx = await hall();
+  const { page } = await open(ctx);
+  await signIn(page, { held: [] });
+  await seatsSettled(page, null);
+  await page.click('[data-wb-skip]');
+  await done(page);
+  await page.click('[data-wb-roles]');
+  await page.waitForSelector('#wb-roles:not([hidden]) [data-wb-role]');
+  const roles = await page.evaluate(() => [...document.querySelectorAll('[data-wb-role]')].map((b) => b.getAttribute('data-wb-role')));
+  assert.deepEqual(roles, ['ideator', 'artist', 'engineer']);
+  const stored = await Promise.all([
+    page.waitForURL(ORIGIN + '/thinking'),
+    page.click('[data-wb-role="ideator"]'),
+  ]).then(() => page.evaluate(() => sessionStorage.getItem('hall-craft')));
+  assert.equal(stored, 'ideating', 'the hall wears Ideating on arrival');
+  await ctx.close();
+});
+
+test('roles: a seat holder sees Owner; Engineer stays on Home in Building', { skip }, async () => {
+  const ctx = await hall();
+  const { page } = await open(ctx);
+  await signIn(page, { held: [{ kind: 'lead', seat: 'planning', title: 'Planning Lead' }] });
+  await seatsSettled(page, 'Planning Lead');
+  await page.click('[data-wb-skip]');
+  await done(page);
+  await page.click('[data-wb-roles]');
+  await page.waitForSelector('#wb-roles:not([hidden]) [data-wb-role]');
+  const roles = await page.evaluate(() => [...document.querySelectorAll('[data-wb-role]')].map((b) => b.getAttribute('data-wb-role')));
+  assert.deepEqual(roles, ['owner', 'ideator', 'artist', 'engineer']);
+  await page.click('[data-wb-role="engineer"]');
+  await page.waitForSelector('#welcome-boot', { state: 'detached' });
+  assert.deepEqual(await state(page), { welcome: false, picker: false, craft: 'building', asked: '1' });
+  assert.equal(new URL(page.url()).pathname, '/');
+  await ctx.close();
+});
+
+test('no painting: the greeting and the choice still come up, over the sky colour', { skip }, async () => {
+  const ctx = await hall({ art: false });
+  const { page } = await open(ctx);
+  await signIn(page);
+  await done(page);
+  const s = await page.evaluate(() => ({
+    bare: document.getElementById('welcome-boot').classList.contains('wb--bare'),
+    img: document.querySelector('#welcome-boot .wb__img').hidden,
+    choices: document.querySelectorAll('.wb__choice').length,
+  }));
+  assert.deepEqual(s, { bare: true, img: true, choices: 2 });
+  await ctx.close();
+});
+
+test('reduced motion: nothing moves, the greeting is up at once', { skip }, async () => {
+  const ctx = await hall({ reducedMotion: 'reduce' });
+  const { page } = await open(ctx);
+  await signIn(page);
+  await page.waitForSelector('#welcome-boot.wb--done', { timeout: 4000 });
+  const moving = await page.evaluate(() => [...document.querySelectorAll('#welcome-boot *')].filter((e) => getComputedStyle(e).animationName !== 'none').length);
+  assert.equal(moving, 0);
+  await ctx.close();
+});
+
+const look = (page) => page.evaluate(() => {
+  const r = document.getElementById('welcome-boot');
+  return {
+    day: r.classList.contains('wb--day'), night: r.classList.contains('wb--night'),
+    veil: getComputedStyle(r.querySelector('.wb__veil')).backgroundColor,
+    art: r.querySelector('.wb__img').getAttribute('src'),
+    beacons: r.querySelectorAll('.wb-beacon').length,
+  };
+});
+
+test('by day the day painting opens from a white veil; by night the night one from black, with its lights', { skip }, async () => {
+  for (const [time, want] of [
+    [new Date(2026, 9, 23, 10, 0), { day: true, night: false, veil: 'rgb(255, 255, 255)', art: '/builders/welcome-day.webp', beacons: 0 }],
+    [new Date(2026, 9, 23, 22, 0), { day: false, night: true, veil: 'rgb(0, 0, 0)', art: '/builders/welcome-night.webp', beacons: 4 }],
+  ]) {
+    const ctx = await hall({ time });
+    const { page } = await open(ctx);
+    await signIn(page);
+    await page.waitForSelector('#welcome-boot');
+    assert.deepEqual(await look(page), want, String(time));
+    // The veil lifts: the root is marked lit, and the veil settles fully transparent.
+    await page.waitForFunction(() => {
+      const r = document.getElementById('welcome-boot');
+      return r && r.classList.contains('wb--lit') && getComputedStyle(r.querySelector('.wb__veil')).opacity === '0';
+    }, null, { timeout: 5000 });
+    await ctx.close();
+  }
+});
+
+test('the way out sinks and fades into the hall, which is usable at once', { skip }, async () => {
+  const ctx = await hall();
+  const { page } = await open(ctx);
+  await signIn(page);
+  await page.click('[data-wb-skip]');
+  await done(page);
+  const before = await page.evaluate(() => getComputedStyle(document.querySelector('#welcome-boot .wb__art')).transform);
+  await page.click('[data-wb-home]');
+  const mid = await page.evaluate(() => ({
+    leaving: document.getElementById('welcome-boot').classList.contains('wb--leaving'),
+    locked: document.documentElement.classList.contains('wb-open'),
+    clicks: getComputedStyle(document.getElementById('welcome-boot')).pointerEvents,
+  }));
+  assert.deepEqual(mid, { leaving: true, locked: false, clicks: 'none' }, 'it leaves slowly, and the hall scrolls and clicks from the first moment');
+  const moved = await page.waitForFunction((b) => getComputedStyle(document.querySelector('#welcome-boot .wb__art')).transform !== b, before, { timeout: 3000 }).then(() => true, () => false);
+  assert.equal(moved, true, 'the view sinks past the rooftops');
+  await page.waitForSelector('#welcome-boot', { state: 'detached', timeout: 6000 });
+  assert.deepEqual(await state(page), { welcome: false, picker: false, craft: null, asked: '1' });
+  await ctx.close();
+});
+
+test('the banner names the project, the motion is laid on, and the drawn tower and city are gone', { skip }, async () => {
+  const ctx = await hall();
+  const { page } = await open(ctx);
+  await signIn(page);
+  await page.waitForSelector('#welcome-boot .wb-motion');
+  const s = await page.evaluate(() => ({
+    banner: document.querySelector('.wb__banner .wb__eyebrow').textContent,
+    pulses: document.querySelectorAll('#wb-fx .wb-pulse').length,
+    cars: document.querySelectorAll('#wb-fx .wb-car').length,
+    old: document.querySelectorAll('.wb-floor, .wb-bldg, .wb-person, #wb-scene, #wb-beam, #wb-city').length,
+  }));
+  assert.deepEqual(s, { banner: 'Working on the core of Harbor', pulses: 21, cars: 3, old: 0 });
+  await ctx.close();
+});

package/tests/wizard_born_first_board.mjs

@@ -4,7 +4,7 @@
 //
 // WHY THIS FILE EXISTS. The fix spans two files that never import each other:
 //
-//   scripts/gds/provision-repo.js   seedFirstVersionCmd()  — seeds the instance's ONE
+//   scripts/bongos/provision-repo.js   seedFirstVersionCmd()  — seeds the instance's ONE
 //                                   version at standup, status 'building'
 //   modules/lifecycle/kickoff-seed.js  seedKickoffIfEmpty() — at the founder's first
 //                                   sign-in, files the checklist UNDER that version
@@ -25,10 +25,10 @@ import { test } from 'node:test';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const P = require('../scripts/gds/provision.js');
+const P = require('../scripts/bongos/provision.js');
 const { seedKickoffIfEmpty, FIRST_VERSION_SQL } = require('../modules/lifecycle/kickoff-seed.js');
 const { kickoffChecklist } = require('../modules/lifecycle/kickoff-checklist.js');
-const { kickoffTasks } = require('../scripts/gds/init.js');
+const { kickoffTasks } = require('../scripts/bongos/init.js');
 
 // The control plane's own fixture shape (mirrors tests/provision.mjs).
 const coTenant = { id: 1, slug: 'mercury', hosting_shape: 'co-tenant', status: 'requested', owner_builder_id: 7, port: 3003, db_name: 'mercury', domain: null };