@bongos/core 1.24.39 → 1.24.41

package/tests/hall_oversight_tabs.mjs

@@ -0,0 +1,162 @@
+// tests/hall_oversight_tabs.mjs — one oversight page (task 1005049, owner decision
+// 2026-11-03, idea 1001315 item 1).
+//
+// Watch, Sessions and Autobongos (/gate) were three oversight pages in the same
+// sidebar group. Sessions and Autobongos are tabs on Watch now:
+//
+//   * OLD URLS LAND ON THE RIGHT TAB. /sessions and /gate 302 to /watch#sessions
+//     and /watch#autobongos (serve-internal.js RETIRED_TO_SECTION), with any query
+//     string kept; the real middleware runs here, on a bare app.
+//   * EVERYTHING THE TWO PAGES SHOWED IS ON WATCH. The tabs exist, their panes hold
+//     the ledger, the transcript reader and the runner panel, and the scripts that
+//     drew the pages still draw them.
+//   * A TAB LOADS WHEN IT OPENS. Each session-ledger load is an audited read on the
+//     server, so sessions.js and gate.js ask for nothing until Watch first opens
+//     their tab, and only once.
+//   * THE PALETTE STILL FINDS THEM: its Watch jumps are real tab ids.
+//
+// Run:  node tests/hall_oversight_tabs.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import vm from 'node:vm';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const read = (f) => fs.readFileSync(path.join(HALL, f), 'utf8');
+const WATCH_HTML = read('watch.html');
+const WATCH_JS = read('watch.js');
+
+async function withHall(fn) {
+  const express = require('express');
+  const { mountInternalSurfaces } = require('../src/bongos/serve-internal.js');
+  const app = express();
+  mountInternalSurfaces(app);
+  const server = app.listen(0, '127.0.0.1');
+  await new Promise((r) => server.once('listening', r));
+  const { port } = server.address();
+  const get = (p, host) => new Promise((resolve, reject) => {
+    http.get({ host: '127.0.0.1', port, path: p, headers: { host } }, (res) => {
+      res.resume();
+      res.on('end', () => resolve({ status: res.statusCode, location: res.headers.location || '' }));
+    }).on('error', reject);
+  });
+  try { await fn(get); } finally { server.close(); }
+}
+
+const TAB_OF = { sessions: 'sessions', gate: 'autobongos' };
+
+test('RUN: /sessions and /gate each 302 to their tab on Watch', async () => {
+  await withHall(async (get) => {
+    for (const [page, tab] of Object.entries(TAB_OF)) {
+      for (const form of [`/${page}`, `/${page}/`, `/${page}.html`]) {
+        const r = await get(form, 'builders.127.0.0.1');
+        assert.equal(r.status, 302, `${form} is a temporary redirect`);
+        assert.equal(r.location, `/watch#${tab}`, `${form} lands on #${tab}`);
+      }
+    }
+    const q = await get('/sessions?from=mail', 'builders.127.0.0.1');
+    assert.equal(q.location, '/watch?from=mail#sessions', 'a query string rides along; the tab is the fragment');
+    // The map the two joined still carries the page it was built for (task 1005047).
+    assert.equal((await get('/fleet', 'builders.127.0.0.1')).location, '/money#hosting');
+  });
+});
+
+test('Watch has a Sessions and an Autobongos tab, each with its pane', () => {
+  assert.match(WATCH_JS, /\{ id: 'sessions', label: 'Sessions', panel: 'pane-sessions' \}/);
+  assert.match(WATCH_JS, /\{ id: 'autobongos', label: 'Autobongos', panel: 'pane-autobongos' \}/);
+  for (const pane of ['pane-sessions', 'pane-autobongos']) {
+    assert.match(WATCH_HTML, new RegExp(`<div id="${pane}" role="tabpanel" aria-labelledby="tab-${pane.slice(5)}" hidden>`));
+  }
+});
+
+test('everything the two pages showed is in those panes', () => {
+  const sessions = WATCH_HTML.slice(WATCH_HTML.indexOf('<div id="pane-sessions"'), WATCH_HTML.indexOf('<div id="pane-autobongos"'));
+  for (const id of ['sess-sealed', 'stats-scroll', 'sess-ledger-scroll', 'session-type-filter', 'sessions-table', 'sessions-pager-mount', 'transcript-scroll']) {
+    assert.match(sessions, new RegExp(`id="${id}"`), `the Sessions tab holds #${id}`);
+  }
+  const runner = WATCH_HTML.slice(WATCH_HTML.indexOf('<div id="pane-autobongos"'));
+  for (const id of ['gate-sealed', 'runner-body', 'gate-archon-only', 'fence-panel', 'fence-body', 'fence-builders']) {
+    assert.match(runner, new RegExp(`id="${id}"`), `the Autobongos tab holds #${id}`);
+  }
+  // Their scripts load before watch.js, which boots them.
+  const i = (s) => WATCH_HTML.indexOf(s);
+  assert.ok(i('/builders/sessions.js') > 0 && i('/builders/sessions.js') < i('/builders/watch.js'));
+  assert.ok(i('/builders/gate.js') > 0 && i('/builders/gate.js') < i('/builders/watch.js'));
+  // No element id on the page is used twice: three pages' markup now share one document.
+  const ids = [...WATCH_HTML.replace(/<!--[\s\S]*?-->/g, '').matchAll(/\sid="([^"]+)"/g)].map((m) => m[1]);
+  assert.deepEqual(ids.filter((x, k) => ids.indexOf(x) !== k), [], 'every id on Watch is said once');
+});
+
+test('the pages are gone, and nothing in the sidebar points at them', () => {
+  assert.ok(!fs.existsSync(path.join(HALL, 'sessions.html')));
+  assert.ok(!fs.existsSync(path.join(HALL, 'gate.html')));
+  assert.ok(!/href: '\/(sessions|gate)'/.test(read('shell.js')));
+  assert.ok(!/'gate', 'sessions'/.test(read('craft-mode.js')), 'Governing mode no longer lists them');
+});
+
+function bootTab(file, { sharedMe = false } = {}) {
+  const requests = [];
+  const el = () => ({ hidden: true, textContent: '', innerHTML: '', value: '', dataset: {}, style: {}, addEventListener() {}, querySelector: () => null, querySelectorAll: () => [], appendChild() {} });
+  const els = {};
+  const getEl = (id) => (els[id] = els[id] || el());
+  const document = { getElementById: getEl, querySelector: (s) => getEl(String(s).replace(/^#/, '')), querySelectorAll: () => [], createElement: el, addEventListener() {} };
+  const window = {
+    BongosClient: { createClient: () => ({ request: async (m, p) => { requests.push(p); return { status: 200, ok: true, data: { builder: { id: 1, rank: 'xenos' } } }; } }) },
+    OTB: { escapeHtml: (s) => String(s), $: document.querySelector, num: Number, fmtInt: String, fmtCompact: String, fmtDate: String, rankLabel: (r) => r, toast() {} },
+    OTBKit: { emptyStateHtml: (m) => m, makePager: () => ({ page: 1, perPage: 25 }) },
+    location: { assign() {} },
+    localStorage: { getItem: () => null, setItem() {} },
+    addEventListener() {},
+  };
+  // The shell's own /me read (shell.js probeMe shares it on window.__hallReads).
+  // A viewer below the floor, so each tab stops at its own sealed notice after /me.
+  if (sharedMe) window.__hallReads = { '/me': Promise.resolve({ builder: { id: 1, rank: 'xenos' } }) };
+  const sandbox = { window, document, console: { log() {}, warn() {}, error() {} }, setTimeout, clearTimeout, Promise, URLSearchParams };
+  vm.createContext(sandbox);
+  vm.runInContext(read(file), sandbox, { filename: file });
+  return { window, requests, getEl };
+}
+
+for (const [file, tab] of [['sessions.js', 'sessions'], ['gate.js', 'autobongos']]) {
+  test(`${file} asks for nothing until Watch opens its tab, then boots once`, async () => {
+    const t = bootTab(file);
+    await new Promise((r) => setImmediate(r));
+    assert.equal(t.requests.length, 0, `${file} read the server before its tab opened`);
+    assert.equal(typeof t.window.OTBWatchTabs[tab], 'function', `${file} hands Watch a boot for #${tab}`);
+    t.window.OTBWatchTabs[tab]();
+    await new Promise((r) => setImmediate(r));
+    const first = t.requests.length;
+    assert.ok(first >= 1, 'opening the tab loads it');
+    t.window.OTBWatchTabs[tab]();
+    await new Promise((r) => setImmediate(r));
+    assert.equal(t.requests.length, first, 'opening it again does not load it twice');
+  });
+}
+
+for (const [file, tab] of [['sessions.js', 'sessions'], ['gate.js', 'autobongos']]) {
+  test(`${file} adopts the shell's /me read rather than asking again`, async () => {
+    const t = bootTab(file, { sharedMe: true });
+    t.window.OTBWatchTabs[tab]();
+    for (let i = 0; i < 5; i++) await new Promise((r) => setImmediate(r));
+    assert.ok(!t.requests.some((p) => /\/me$/.test(p)), `${file} asked /me although the shell had`);
+    assert.equal(t.getEl(file === 'gate.js' ? 'gate-sealed' : 'sess-sealed').hidden, false, 'and still acts on the answer');
+  });
+}
+
+test('watch.js boots a tab from its own change hook', () => {
+  assert.match(WATCH_JS, /onChange: \(id\) => \{\s*const boot = window\.OTBWatchTabs && window\.OTBWatchTabs\[id\];\s*if \(boot\) boot\(\);/);
+});
+
+test('the palette\'s Watch jumps are real watch.js tab ids', () => {
+  const ids = [...WATCH_JS.matchAll(/\{ id: '([a-z-]+)', label: '[^']*', panel:/g)].map((m) => m[1]);
+  const declared = [...read('palette.js').matchAll(/href:\s*'\/watch#([a-z-]+)'/g)].map((m) => m[1]);
+  assert.deepEqual(declared, ids, 'one jump per Watch tab, in order');
+  assert.ok(declared.includes('sessions') && declared.includes('autobongos'));
+});

package/tests/hall_oversight_world.mjs

@@ -17,7 +17,8 @@ import { fileURLToPath } from 'node:url';
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const PUB = path.join(ROOT, 'modules', 'hall-ui', 'public');
 const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8').replace(/\r\n/g, '\n');
-const PAGES = ['government', 'watch', 'gate'];
+// task 1005049: the /gate page is Watch's Autobongos tab; its script and sheet stay.
+const PAGES = ['government', 'watch'];
 
 test('every oversight page links the family sheet, before its own', () => {
   for (const p of PAGES) {
@@ -27,6 +28,11 @@ test('every oversight page links the family sheet, before its own', () => {
     assert.ok(fam > 0, `${p}.html links oversight.css`);
     assert.ok(own > fam, `${p}.html links its own sheet after the family's`);
   }
+  // Watch's two folded-in tabs bring their sheets, after the family's too.
+  const watch = read('watch.html');
+  for (const sheet of ['sessions', 'gate']) {
+    assert.ok(watch.indexOf(`/builders/${sheet}.css`) > watch.indexOf('/builders/oversight.css'), `watch.html links ${sheet}.css after the family's`);
+  }
 });
 
 test('the family sheet spends only the fifteen: no literal colour', () => {
@@ -110,6 +116,10 @@ test('the sealed state is a panel with the floor written from the pack, on all f
     assert.match(read(`${p}.html`), /class="scroll" id="[a-z-]*sealed(-scroll)?" /, `${p}.html seals with a .scroll panel`);
     assert.match(read(`${p}.js`), /rankLabel\('metic'\)/, `${p}.js writes the floor from the pack's rank label`);
   }
+  // The Autobongos and Sessions tabs keep their own sealed panels inside Watch.
+  assert.match(read('watch.html'), /class="scroll" id="gate-sealed" /);
+  assert.match(read('watch.html'), /class="scroll" id="sess-sealed" /);
+  assert.match(read('gate.js'), /rankLabel\('metic'\)/);
 });
 
 test('the vocabulary wall holds: the family is named oversight on the government surface', () => {
@@ -278,7 +288,9 @@ test('RUN: a metric its snapshots never carried is skipped, not drawn as a cliff
 
 // ---- task 1004829: the government pages read like the rebuilt Home ----------
 
-const GOV_PAGES = ['watch', 'gate', 'sessions', 'project-settings', 'money', 'deploy', 'government'];
+const GOV_PAGES = ['watch', 'project-settings', 'money', 'deploy', 'government'];
+// task 1005049: gate.js and sessions.js draw Watch's tabs now; their scripts still must not.
+const GOV_SCRIPTS = [...GOV_PAGES, 'gate', 'sessions'];
 
 test('every government page head holds only its h1, and no script writes into it', () => {
   // No page shows its head (task 1004836). A sub-line there is a line nobody
@@ -291,7 +303,7 @@ test('every government page head holds only its h1, and no script writes into it
     assert.doesNotMatch(head[1], /page-head__eyebrow|page-head__sub/, `${page}.html's hidden head holds only the h1`);
   }
   const subIds = ['watch-sub', 'gate-sub', 'ledger-sub', 'ps-sub', 'dp-sub', 'fl-sub', 'gov-sub'];
-  for (const page of GOV_PAGES) {
+  for (const page of GOV_SCRIPTS) {
     const js = read(`${page}.js`);
     for (const id of subIds) assert.ok(!js.includes(id), `${page}.js no longer writes into #${id}`);
   }
@@ -300,7 +312,7 @@ test('every government page head holds only its h1, and no script writes into it
 test('a failed load on Watch and Sessions is said in the page body', () => {
   assert.match(read('watch.js'), /showSealed\('Could not check your access\. Reload to try again\.', 'Could not load'\)/);
   assert.match(read('sessions.js'), /showSealed\('Could not check your access\. Reload to try again\.', 'Could not load'\)/);
-  assert.match(read('sessions.html'), /id="ledger-status" role="status"/, 'the count and a failed page load sit on the ledger itself');
+  assert.match(read('watch.html'), /id="ledger-status" role="status"/, 'the count and a failed page load sit on the ledger itself');
 });
 
 test('the page at /gate is the Autobongos panel: no held-PR list, and a Metic is told the controls are the Archon\'s', () => {
@@ -312,10 +324,12 @@ test('the page at /gate is the Autobongos panel: no held-PR list, and a Metic is
   assert.ok(!/renderRow\(pr|OTBAsk/.test(js), 'no held-PR row or ask card is drawn');
   assert.match(js, /if \(rank !== 'archon'\) \{ showArchonOnly\(\); return; \}/, 'a Metic gets the note, not an empty page');
   assert.match(js, /The Autobongos controls are for the \$\{rankLabel\('archon'\)\}/, 'the rank is named from the pack');
-  const html = read('gate.html');
-  assert.match(html, /<title>Autobongos — /, 'the page says what it is');
-  assert.match(html, /data-page-title="Autobongos"/);
-  assert.match(html, /id="gate-archon-only"/);
+  // task 1005049: the panel is Watch's Autobongos tab, and /gate lands there.
+  const html = read('watch.html');
+  const pane = html.slice(html.indexOf('<div id="pane-autobongos"'));
+  assert.match(pane, /id="gate-archon-only"/);
   assert.ok(!/gate-list|hall-ask\.js/.test(html), 'the list mount and the ask-card script are gone');
-  assert.match(read('shell.js'), /\{ id: 'gate', label: 'Autobongos', icon: 'gate', href: '\/gate'/, 'the nav names it, at the same URL');
+  assert.match(read('watch.js'), /\{ id: 'autobongos', label: 'Autobongos', panel: 'pane-autobongos' \}/, 'the tab says what it is');
+  assert.ok(!/href: '\/gate'/.test(read('shell.js')), 'the sidebar no longer lists it');
+  assert.match(fs.readFileSync(path.join(ROOT, 'src/bongos/serve-internal.js'), 'utf8'), /gate: 'watch#autobongos'/, 'and the old URL lands on the tab');
 });

package/tests/hall_page_gate_map.mjs

@@ -120,8 +120,10 @@ const ORACLE = {
 
   // Metic+ operator surfaces (the Governance nav group).
   '/builders/watch': 'requireGovernmentPage',
-  '/builders/gate': 'requireGovernmentPage',
-  '/builders/sessions': 'requireGovernmentPage',
+  // Gone (task 1005049, owner decision 2026-11-03): Sessions and Autobongos are tabs
+  // on Watch, behind Watch's gate, and both URLs 302 to their tab before any gate runs.
+  '/builders/gate': null,
+  '/builders/sessions': null,
   // The five fundamentals of the project (task 1003280, goal 1000072). Same tier as
   // its neighbours: a steering surface, metic+ per ADR 0157. Its two WRITES gate
   // independently on `project.settings.manage`, so this row is only about the shell.
@@ -360,6 +362,9 @@ const GONE_PAGES = {
   '/builders/ranks': 'task 1005046 — the rank ladder is a Primer chapter; /ranks redirects there',
   '/builders/drachmae': 'task 1005046 — credits and karma is a Primer chapter; /drachmae redirects there',
   '/builders/diagrams': 'task 1005046 — each diagram sits in its Primer chapter; /diagrams redirects there',
+  // Task 1005049 — one oversight page: each is a tab on Watch, and the old URL 302s to it.
+  '/builders/sessions': 'task 1005049 — the session log is Watch\'s Sessions tab; /sessions redirects there',
+  '/builders/gate': 'task 1005049 — the runner panel is Watch\'s Autobongos tab; /gate redirects there',
 };
 
 test('a row that is null because the page left the hall serves no page', () => {

package/tests/hall_roster_world.mjs

@@ -230,12 +230,15 @@ test('sessions: the nowrap + wrapper pair is gone, and with it the sticky-header
   const css = decomment(read('sessions.css'));
   assert.doesNotMatch(css, /white-space:\s*nowrap/, 'no blanket nowrap on every cell');
   assert.doesNotMatch(css, /ledger-table-wrap/, 'no wrapper — the shell\'s card strip handles a phone');
-  assert.doesNotMatch(read('sessions.html'), /ledger-table-wrap/);
+  assert.doesNotMatch(sessionsPane(), /ledger-table-wrap/);
   assert.doesNotMatch(css, /var\(--info\)|ledger-sid/, 'the session id is no longer painted in the info colour');
   noAlias(css, 'sessions.css');
   tokensDefined(css, 'sessions.css');
 });
 
+// task 1005049: the session ledger is Watch's Sessions tab; its markup is that pane.
+const sessionsPane = () => { const w = read('watch.html'); return w.slice(w.indexOf('<div id="pane-sessions"'), w.indexOf('<div id="pane-autobongos"')); };
+
 test('sessions: every id on a row is a door, the earned figure is shown, the totals ride the top strip', () => {
   const src = read('sessions.js');
   assert.match(src, /<a class="fact-chip" href="\/builders\/task\/\$\{encodeURIComponent\(String\(t\)\)\}">task \$\{escapeHtml\(String\(t\)\)\}<\/a>/,
@@ -244,8 +247,8 @@ test('sessions: every id on a row is a door, the earned figure is shown, the tot
   assert.match(src, /<span class="ov-mono" title="\$\{escapeHtml\(s\.session_id\)\}">/, 'the session id is a mono fact with the full id on hover');
   assert.match(src, /fmtInt\(s\.drachmae_earned\)/, 'what the session earned is on the row');
   assert.doesNotMatch(src, /`#\$\{escapeHtml\(t\)\}`/, 'no bare hash-prefixed task text');
-  const html = read('sessions.html');
-  assert.match(html, /<section class="ov-summary" id="stats-scroll"/, 'the totals are the top-of-page strip');
+  const html = sessionsPane();
+  assert.match(html, /<section class="ov-summary" id="stats-scroll"/, 'the totals are the top-of-tab strip');
   assert.match(html, /<div class="stat-row" id="stats-body"><\/div>/);
   const ths = (html.match(/<th[ >]/g) || []).length;
   // task 1002516: a tenth column, "Plain speech" — the transcript accessibility
@@ -259,8 +262,9 @@ test('sessions: every id on a row is a door, the earned figure is shown, the tot
   // empty state short by a column, which no screenshot pass would catch.
   assert.equal(ths, 11, 'eleven columns: session, builder, kind, tasks, earned, turns, tokens, tool errors, duration, plain speech, recorded');
   assert.match(src, new RegExp(`colspan="${ths}"`), 'the empty row spans them all');
-  const fam = html.indexOf('/builders/oversight.css');
-  assert.ok(fam > 0 && html.indexOf('/builders/sessions.css') > fam, 'sessions.html links the family sheet before its own');
+  const page = read('watch.html');
+  const fam = page.indexOf('/builders/oversight.css');
+  assert.ok(fam > 0 && page.indexOf('/builders/sessions.css') > fam, 'watch.html links the family sheet before the sessions sheet');
 });
 
 test('sessions: the floor is written from the pack\'s rank label, never a hardcoded rank', () => {
@@ -268,9 +272,9 @@ test('sessions: the floor is written from the pack\'s rank label, never a hardco
   const sealed = src.slice(src.indexOf('function showSealed'), src.indexOf('// ---- paging state'));
   assert.match(sealed, /const floor = rankLabel\('metic'\)/);
   // a failed load names its own heading; the rank floor is the default (task 1004829)
-  assert.match(sealed, /\$\('#gate-h'\)\.textContent = heading \|\| `\$\{floor\} and up`/);
+  assert.match(sealed, /\$\('#sess-sealed-h'\)\.textContent = heading \|\| `\$\{floor\} and up`/);
   assert.doesNotMatch(decomment(src), /Archons only|Metic rank up|Archon-only/);
-  assert.doesNotMatch(read('sessions.html'), /Archon/);
+  assert.doesNotMatch(sessionsPane(), /Archon/);
 });
 
 // =========================================================================
@@ -299,8 +303,9 @@ test('the states files exercise the redesign\'s new states', () => {
   const goals = JSON.parse(read('goals.states.json'));
   assert.ok(goals.states.filters && goals.states.cards, 'goals: the Filters disclosure and the cards view are measured');
   assert.deepEqual(goals.states.cards.expect.value, [['#f-goal-view', 'cards']]);
-  const sessions = JSON.parse(read('sessions.states.json'));
-  assert.deepEqual(sessions.states.ledger.expect.visible, ['#stats-scroll', '#sessions-scroll']);
+  // task 1005049: the ledger is Watch's Sessions tab, measured as that page's state.
+  const watch = JSON.parse(read('watch.states.json'));
+  assert.deepEqual(watch.states.sessions.expect.visible, ['#pane-sessions', '#stats-scroll', '#sess-ledger-scroll']);
 });
 
 test('the roster draws the circuit divider in CSS, on the first row\'s cell and not the row', () => {

package/tests/hall_sessions_ledger.mjs

@@ -19,7 +19,8 @@ const PUB = path.join(ROOT, 'modules', 'hall-ui', 'public');
 const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8').replace(/\r\n/g, '\n');
 
 const JS = read('sessions.js');
-const HTML = read('sessions.html');
+// task 1005049: the ledger is Watch's Sessions tab; its markup lives in watch.html.
+const HTML = (() => { const w = read('watch.html'); return w.slice(w.indexOf('<div id="pane-sessions"'), w.indexOf('<div id="pane-autobongos"')); })();
 
 // Slice `const ACCESSIBILITY_TITLE = {...}` through the end of accessibilityCell
 // and run it with the one helper it closes over.

package/tests/nav_permission_atoms.mjs

@@ -95,8 +95,9 @@ test('the hall-preview fixture carries every atom /me resolves', () => {
 // task 1004846: the new logo (its bump landed late, in task 1004852); task 1004938: the
 // Market Watch settings nav item and its fuel glyph; task 1005041: the Update pill replaced the
 // core-update banner; task 1005045: the Market Watch settings item left (one sidebar item);
-// task 1005046: Ranks, Economy and Diagrams left Docs (one reading room, the Primer).
-const SHELL_SHA = 'baf8a15f025eba68';
+// task 1005046: Ranks, Economy and Diagrams left Docs (one reading room, the Primer);
+// task 1005049: Sessions and Autobongos left the sidebar (tabs on Watch).
+const SHELL_SHA = 'bb0abbadab2508ca';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);

package/tests/rank_tier_single_source.mjs

@@ -93,7 +93,9 @@ const STATIC_LADDER_FILES = [
   'modules/discord/discord-channels.js',
   'modules/memory/search.js',
   'modules/hall-ui/public/profile.js',
-  'modules/hall-ui/public/watch.js',
+  // task 1005048: the rank <select> on each roster row moved from watch.js to the
+  // Builders page with the roster itself; the copy moved with it.
+  'modules/hall-ui/public/roster.js',
   // task 1003094: the Constitution panel and the Board Room's sitting card both
   // expand the `rank:<key>+` membership form ("that rank and above") to render
   // who governs in plain language, so both need the ladder to expand against.