@bongos/core 1.21.175 → 1.21.176

package/tests/hall_home_ships_bounded.mjs

@@ -0,0 +1,160 @@
+// tests/hall_home_ships_bounded.mjs — task 1004854.
+//
+// The hall home page used to ask for /me/recent-ships?limit=all on every load AND
+// on every live refresh (any write to tasks/claims/credit_log/… nudges every open
+// tab). Each row carries a per-session credits subquery, so for a builder with
+// 3,000 ships that one request took ~3.4 s of database time, to fill a five-row
+// table and a count. This pins the bounded shape:
+//
+//   1. the route answers a small page plus `total`, counting only when it must;
+//   2. hall-render.js keeps Home on that small page, and fetches the full ledger
+//      only when the Accomplishments view is open — and again only when the
+//      newest ships or the count moved.
+//
+// (builders.js's own request is pinned in tests/hall_landing_boot.mjs, which
+// already boots the real page.) DB-free: vm + stubs.
+//
+// Run:  node --test tests/hall_home_ships_bounded.mjs
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import fs from 'node:fs';
+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 { recentShipsPayload } = require('../src/bongos/routes/me.js');
+
+const ship = (id, extra = {}) => ({ id, title: `t${id}`, version_id: 'V1', shipped_at: '2026-10-01T00:00:00Z', credits_awarded: 3, ...extra });
+
+// A lifecycle port holding `n` ships, recording what it was asked.
+function fakeLifecycle(n) {
+  const asked = { limits: [], counts: 0 };
+  return {
+    asked,
+    async recentShippedTasksByBuilder(_b, limit) {
+      asked.limits.push(limit);
+      return Array.from({ length: Math.min(n, limit) }, (_, i) => ship(i + 1));
+    },
+    async countListedShipsByBuilder() { asked.counts += 1; return n; },
+  };
+}
+
+test('route: a small page comes back with the whole count', async () => {
+  const lc = fakeLifecycle(3000);
+  const out = await recentShipsPayload(lc, 1, '5');
+  assert.equal(out.ships.length, 5);
+  assert.equal(out.total, 3000);
+  assert.deepEqual(lc.asked.limits, [5], 'only five rows were read');
+  assert.equal(lc.asked.counts, 1);
+});
+
+test('route: a page shorter than the limit is the whole list, so no count query', async () => {
+  const lc = fakeLifecycle(3);
+  const out = await recentShipsPayload(lc, 1, '5');
+  assert.equal(out.total, 3);
+  assert.equal(lc.asked.counts, 0);
+});
+
+test('route: limit=all still answers every ship, and clamps and defaults hold', async () => {
+  const lc = fakeLifecycle(40);
+  const all = await recentShipsPayload(lc, 1, 'all');
+  assert.equal(all.ships.length, 40);
+  assert.equal(all.total, 40);
+  assert.equal(lc.asked.counts, 0, 'all rows already counted');
+  await recentShipsPayload(lc, 1, '9999');
+  await recentShipsPayload(lc, 1, undefined);
+  assert.deepEqual(lc.asked.limits.slice(1), [500, 10]);
+});
+
+// ---- hall-render.js -----------------------------------------------------------
+
+function loadRender({ view = 'home' } = {}) {
+  const els = new Map();
+  const el = (id) => {
+    if (!els.has(id)) {
+      els.set(id, {
+        id, hidden: true, textContent: '', innerHTML: '', value: '', options: [], dataset: {}, style: {},
+        classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
+        addEventListener() {}, setAttribute() {}, querySelector() { return null; }, querySelectorAll() { return []; },
+        remove(i) { this.options.splice(i, 1); }, appendChild(o) { this.options.push(o); },
+      });
+    }
+    return els.get(id);
+  };
+  // `$('#recent-ships tbody')` / `querySelector('#home-recent-table tbody')` → one element per selector.
+  const bySelector = (sel) => el(sel.replace(/^#/, ''));
+  const listeners = {};
+  const document = {
+    getElementById: el,
+    querySelector: bySelector,
+    querySelectorAll: () => [],
+    createElement: () => ({ value: '', textContent: '', title: '' }),
+    addEventListener(type, fn) { (listeners[type] || (listeners[type] = [])).push(fn); },
+  };
+  const fetched = [];
+  const shell = { view };
+  const window = {
+    OTB: { escapeHtml: (s) => String(s ?? ''), $: bySelector, fmtNum: (n) => String(n), moduleOn: () => true },
+    OTBKit: { makePager: () => ({ page: 1, perPage: 10 }), paginate: (rows) => rows },
+    OTBShell: { currentView: () => shell.view },
+  };
+  const sandbox = { window, document, console, setTimeout, clearTimeout };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/hall-render.js'), 'utf8'), sandbox);
+  const ledger = Array.from({ length: 3000 }, (_, i) => ship(i + 1));
+  const r = window.OTBHallRender({
+    API: '/api/bongos', RANK_ORDER: [], api: {}, brandWorld: () => 'W', curLabel: () => 'credits',
+    emptyRow: (_n, msg) => `<empty>${msg}`, fmtDate: () => '', loadNextUp() {}, mins: () => '', normalizeRank: (x) => x,
+    pct: () => '', postJSON() {}, rankLabel: (x) => x, rankWeight: () => 0, signClasses: () => '', toast() {}, usd: () => '',
+    getJSON: async (url) => { fetched.push(url); return { ships: ledger, total: ledger.length }; },
+    newcomerGated: false,
+  });
+  const showView = (name) => {
+    shell.view = name;
+    for (const fn of listeners['otbshell:view'] || []) fn({ detail: { view: name } });
+  };
+  return { r, el, fetched, showView };
+}
+
+const homePage = (total, firstId = 3000) => ({ ships: [ship(firstId), ship(firstId - 1)], total });
+
+test('Home: the count and the five-row table come from the small page, with no ledger fetch', async () => {
+  const { r, el, fetched } = loadRender();
+  assert.equal(r.HOME_SHIPS_LIMIT, 5);
+  r.setRecentShips(homePage(3000));
+  await new Promise((done) => setTimeout(done, 0));
+  assert.deepEqual(fetched, [], 'Home never asks for the full history');
+  assert.equal(el('stat-shipped').textContent, '3000', 'the Shipped tile shows the server total, not rows held');
+  assert.match(el('home-recent-table tbody').innerHTML, /#3000[\s\S]*#2999/);
+  assert.equal(el('recent-ships tbody').innerHTML, '', 'the ledger is untouched until its view opens');
+});
+
+test('Accomplishments: the full ledger loads when the view opens, once', async () => {
+  const { r, el, fetched, showView } = loadRender();
+  r.setRecentShips(homePage(3000));
+  showView('standing');
+  await r.loadShipLedger();
+  assert.deepEqual(fetched, ['/api/bongos/me/recent-ships?limit=all']);
+  assert.match(el('ships-count').textContent, /3000 works shipped/);
+  showView('home');
+  showView('standing');
+  await r.loadShipLedger();
+  assert.equal(fetched.length, 1, 'reopening the view with nothing new does not refetch');
+});
+
+test('a live refresh refetches the open ledger only when the newest ships or the count moved', async () => {
+  const { r, fetched } = loadRender({ view: 'standing' });
+  r.setRecentShips(homePage(3000));
+  await r.loadShipLedger();
+  assert.equal(fetched.length, 1, 'opening straight onto Accomplishments loads the ledger');
+  r.setRecentShips(homePage(3000)); // a nudge from someone else's write
+  await r.loadShipLedger();
+  assert.equal(fetched.length, 1, 'an unrelated write does not re-download the history');
+  r.setRecentShips(homePage(3001, 3001)); // this builder shipped
+  await r.loadShipLedger();
+  assert.equal(fetched.length, 2, 'a new ship does');
+});

package/tests/hall_landing_boot.mjs

@@ -25,7 +25,7 @@ const SRC = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/builders.js'
 
 // Boot builders.js against a /me that answers `meStatus`, then fire
 // DOMContentLoaded and let the microtasks drain. Returns what the page DID.
-async function boot({ meStatus }) {
+async function boot({ meStatus, settle = false }) {
   const calls = { assign: [], requests: [], rendered: [] };
 
   const makeEl = () => ({
@@ -92,7 +92,9 @@ async function boot({ meStatus }) {
     },
     OTBHallRender: () => ({
       analyticsState: {}, lbState: {},
-      shipState: {}, shipsPager: { page: 1 }, welcomeDismissalKey: () => 'k',
+      shipsPager: { page: 1 }, welcomeDismissalKey: () => 'k',
+      // task 1004854: Home asks for this many ships; the ledger's full read lives in hall-render.js.
+      HOME_SHIPS_LIMIT: 5, setRecentShips: spy('setRecentShips'), populateShipVersionFilter: spy('populateShipVersionFilter'),
       mountHallWidgets: spy('mountHallWidgets'),
       renderLanding: spy('renderLanding'),
       renderCurveBody: spy('renderCurveBody'), renderGreeting: spy('renderGreeting'),
@@ -120,6 +122,7 @@ async function boot({ meStatus }) {
   for (const fn of documentObj.listeners.DOMContentLoaded || []) fn();
   // Drain the boot promise chain (a handful of awaits, no timers).
   for (let i = 0; i < 25; i += 1) await Promise.resolve();
+  if (settle) for (let i = 0; i < 10; i += 1) await new Promise((done) => setTimeout(done, 0));
   return calls;
 }
 
@@ -149,3 +152,13 @@ test('a signed-in builder still gets the hall', async () => {
   assert.equal(calls.requests.filter((r) => /\/me$/.test(r)).length, 1,
     'boot asked for /me more than once — the resolved payload is handed to loadAll, not re-fetched');
 });
+
+// task 1004854: Home used to download the builder's WHOLE ship history here, on
+// every load and every live refresh — ~3.4 s of database time for 3,000 ships, to
+// fill a five-row table and a count. It asks for the small page only.
+test('Home asks for its few newest ships, never the full history', async () => {
+  const calls = await boot({ meStatus: 200, settle: true });
+  const ships = calls.requests.filter((r) => r.includes('/me/recent-ships'));
+  assert.deepEqual(ships, ['GET /api/bongos/me/recent-ships?limit=5'], `ship requests were: ${ships.join(', ') || 'none'}`);
+  assert.ok(calls.rendered.includes('setRecentShips'), 'the small page is handed to the renderer');
+});

package/tests/hall_nav.mjs

@@ -828,3 +828,36 @@ test('My agents draws its own glyph and lands on a real page', () => {
   assert.equal(item.gate, 'signed');
   assert.ok(hrefResolves(item), 'my-agents.html exists');
 });
+
+// task 1004826 (owner, 2026-10-23): Standing is called Accomplishments
+// everywhere a reader sees it. The view keeps its internal key, and every old
+// #standing link still lands on it.
+test('Standing is Accomplishments to the reader, and old #standing links still land', () => {
+  const sidebar = boot().sidebarHtml;
+  const item = parseNav(sidebar).flatMap((g) => g.items).find((i) => i.id === 'standing');
+  assert.ok(item, 'the nav item is still there');
+  assert.equal(item.href, '/#accomplishments');
+  const anchor = sidebar.slice(sidebar.indexOf('id="nav-standing"'), sidebar.indexOf('</a>', sidebar.indexOf('id="nav-standing"')));
+  assert.match(anchor, />Accomplishments</, 'labelled Accomplishments');
+  assert.ok(!/>Standing</.test(sidebar), 'nothing in the nav is called Standing');
+
+  for (const hash of ['#accomplishments', '#accomplishments-karma', '#standing', '#standing-work']) {
+    const idx = boot({ page: 'home', pathname: '/', hash });
+    assert.equal(idx.shell.currentView(), 'standing', `${hash} opens the Accomplishments view`);
+    assert.equal(idx.viewHidden('home'), true, `${hash} hides Home`);
+  }
+  const html = fs.readFileSync(path.join(HALL, 'index.html'), 'utf8');
+  assert.match(html, /id="view-standing" data-view-title="Accomplishments"/, 'the top bar names it Accomplishments');
+  assert.ok(!/href="#standing/.test(fs.readFileSync(path.join(HALL, 'hall-widgets.js'), 'utf8')), 'Home links use the new name');
+});
+
+test('the Accomplishments band carries no notices — Home\'s attention cards own them (task 1004826)', () => {
+  const src = fs.readFileSync(path.join(HALL, 'hall-render.js'), 'utf8');
+  const fn = src.slice(src.indexOf('  function renderProfile(builder) {'), src.indexOf('  function renderSystemNotices('));
+  const band = fn.slice(fn.indexOf("$('#profile-body').innerHTML"), fn.indexOf("const welcomeLine"));
+  assert.ok(band.length > 100, 'sanity: found the band template');
+  for (const cls of ['profile__rebase', 'profile__needs', 'profile__budget']) {
+    assert.ok(!band.includes(cls), `${cls} no longer renders on the band`);
+  }
+  assert.match(fn, /renderSystemNotices\(\{ rebaseTasks, need, actionNeeds, cost \}\)/, 'Home still gets every notice');
+});

package/tests/hall_onboarding_bongos_setup.mjs

@@ -97,5 +97,5 @@ test('the npx paste command Settings hands out is pre-approved for a Claude sess
   for (const tool of ['Bash', 'PowerShell']) {
     assert.ok(settings.permissions.allow.includes(`${tool}(npx bongos paste-token:*)`), `${tool} twin`);
   }
-  assert.match(read('scripts/gds/claude-materialize.js'), /^\s*'npx bongos paste-token:\*',$/m);
+  assert.match(read('scripts/bongos/claude-materialize.js'), /^\s*'npx bongos paste-token:\*',$/m);
 });

package/tests/hall_oversight_world.mjs

@@ -91,10 +91,10 @@ test('the shared confirm modal sits on --z-modal, closed by one hairline and no
   const modal = css.slice(css.indexOf('.ov-modal {'), css.indexOf('.ov-modal .scroll__h'));
   assert.ok(!/box-shadow/.test(modal), 'no shadow under the dialog');
   assert.match(modal, /border: var\(--line\) solid var\(--rule\)/, 'one rule hairline');
-  for (const p of ['gate']) {
-    assert.match(read(`${p}.js`), /className = 'ov-modal-bg'/, `${p}.js opens the family modal`);
-    assert.ok(!/-modal-bg/.test(read(`${p}.css`)), `${p}.css no longer styles a modal of its own`);
-  }
+  // task 1004829: the Gate's approve is the ask card now, and the card is its own
+  // confirmation, so the page opens no modal at all — and styles none.
+  assert.ok(!/ov-modal-bg/.test(read('gate.js')), 'gate.js opens no modal: the ask card is the confirmation');
+  assert.ok(!/-modal-bg/.test(read('gate.css')), 'gate.css styles no modal of its own');
 });
 
 test('a number input inside a family field clears the 24px floor', () => {
@@ -275,3 +275,43 @@ test('RUN: a metric its snapshots never carried is skipped, not drawn as a cliff
   const figures = [...html.matchAll(/id="ledger-trend-([a-z_]+)"/g)].map((m) => m[1]);
   assert.deepEqual(figures, ['total_loc', 'stale_branches', 'confirmed_unshipped']);
 });
+
+// ---- task 1004829: the government pages read like the rebuilt Home ----------
+
+const GOV_PAGES = ['watch', 'gate', 'sessions', 'project-settings', 'deploy', 'fleet', 'government'];
+
+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
+  // reads, and a script writing "Restricted." or "Could not load" into one is a
+  // message nobody gets — those now land in the sealed panel or the ledger.
+  for (const page of GOV_PAGES) {
+    const html = read(`${page}.html`).replace(/<!--[\s\S]*?-->/g, '');
+    const head = html.match(/<div class="page-head[^"]*">([\s\S]*?)<\/div>/);
+    assert.ok(head, `${page}.html keeps its head for the h1`);
+    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) {
+    const js = read(`${page}.js`);
+    for (const id of subIds) assert.ok(!js.includes(id), `${page}.js no longer writes into #${id}`);
+  }
+});
+
+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');
+});
+
+test('the Gate draws a held PR as the ask card only for a viewer the approve route admits', () => {
+  const js = read('gate.js');
+  // the server's own answer, never a rank guess on the client
+  assert.match(js, /renderRow\(pr, resp\.viewer_may_approve === true\)/);
+  assert.match(js, /if \(mayApprove && !pr\.already_approved && window\.OTBAsk\)/);
+  assert.match(js, /q: `Let PR #\$\{pr\.number\} through\?`/, 'a question, not a label');
+  assert.match(js, /'data-act': 'approve'/);
+  assert.match(js, /Waiting for approval/, 'everyone else reads the facts as a plain row');
+  const html = read('gate.html');
+  assert.ok(html.indexOf('hall-ask.js') > 0 && html.indexOf('hall-ask.js') < html.indexOf('gate.js?'), 'the card script loads before the page');
+  assert.match(html, /hall-ask\.css/);
+});

package/tests/hall_palette.mjs

@@ -113,7 +113,7 @@ async function settleSearch() { await tick(400); }
 const NAV_FIXTURE = [
   { label: 'Home', href: '/' },
   { label: 'Tasks', href: '/work' },
-  { label: 'Standing', href: '/#standing' },
+  { label: 'Accomplishments', href: '/#accomplishments' },
   { label: 'Economy', href: '/drachmae' },
   { label: 'API docs', href: '/docs', external: true },
   { label: 'Watch', href: '/watch', hidden: true },   // Archon-only, gated off
@@ -126,17 +126,20 @@ function declaredHrefs(prefixTest) {
   return [...PALETTE_SRC.matchAll(/href:\s*'([^']+)'/g)].map((m) => m[1]).filter(prefixTest);
 }
 
-test('Standing section anchors exist in builders.js and are routable in shell.js', () => {
+// task 1004826: Standing is Accomplishments to the reader; the sections are
+// #accomplishments-<group>, aliased onto the 'standing' view's anchors.
+test('Accomplishments section anchors exist in builders.js and are routable in shell.js', () => {
   // task 1003206: STANDING_GROUPS moved to hall-render.js — read the family.
   const groups = [...hallSource().matchAll(/\{ key: '([a-z]+)', label: '[^']+' \}/g)].map((m) => m[1]);
   assert.ok(groups.length >= 4, `sanity: found STANDING_GROUPS (${groups})`);
-  const declared = declaredHrefs((h) => h.startsWith('/#standing-')).map((h) => h.replace('/#', ''));
-  assert.ok(declared.length, 'palette declares Standing sections');
+  assert.ok(!declaredHrefs((h) => h.startsWith('/#standing')).length, 'the palette names the page by its new name');
+  const declared = declaredHrefs((h) => h.startsWith('/#accomplishments-')).map((h) => h.replace('/#', ''));
+  assert.ok(declared.length, 'palette declares Accomplishments sections');
   for (const id of declared) {
-    const key = id.replace('standing-', '');
+    const key = id.replace('accomplishments-', '');
     assert.ok(groups.includes(key), `${id} must be a real STANDING_GROUPS key (builders.js)`);
     // shell.js must alias it, or route() ignores the hash and the jump goes nowhere.
-    assert.match(SHELL_SRC, new RegExp(`'${id}':\\s*\\{ view: 'standing', anchor: '${id}' \\}`),
+    assert.match(SHELL_SRC, new RegExp(`'${id}':\\s*\\{ view: 'standing', anchor: 'standing-${key}' \\}`),
       `${id} must have a VIEW_ALIASES entry in shell.js`);
   }
 });
@@ -190,17 +193,17 @@ test('the anchor guard actually CATCHES a declared id that does not exist', () =
 test('pages come from the sidebar, and a gated-off nav item is not a destination', () => {
   const P = bootPalette({ navItems: NAV_FIXTURE });
   const labels = P.compute('').filter((r) => r.group === 'Pages').map((r) => r.label);
-  assert.deepEqual(labels, ['Home', 'Tasks', 'Standing', 'Economy', 'API docs']);
+  assert.deepEqual(labels, ['Home', 'Tasks', 'Accomplishments', 'Economy', 'API docs']);
   assert.ok(!labels.includes('Watch'), 'a hidden (rank-gated) nav item must not be jumpable');
 });
 
 test('section groups appear only when their owning nav item is visible', () => {
   const all = bootPalette({ navItems: NAV_FIXTURE }).compute('');
-  assert.ok(all.some((r) => r.group === 'Standing'), 'Standing sections offered when nav-standing shows');
+  assert.ok(all.some((r) => r.group === 'Accomplishments'), 'Accomplishments sections offered when nav-standing shows');
   assert.ok(all.some((r) => r.group === 'Settings'), 'Settings panels offered when the profile chip shows');
 
   const gatedOut = bootPalette({ navItems: NAV_FIXTURE, visibleIds: [] }).compute('');
-  assert.ok(!gatedOut.some((r) => ['Standing', 'Tasks', 'Settings'].includes(r.group)),
+  assert.ok(!gatedOut.some((r) => ['Accomplishments', 'Tasks', 'Settings'].includes(r.group)),
     'no sub-destinations when their owners are hidden');
 });
 

package/tests/hall_preview_security.mjs

@@ -40,7 +40,7 @@ const load = () => FILES.map((f) => ({ file: f, data: JSON.parse(fs.readFileSync
 // itself; resolving it from the floor keeps the check and the scan in step (task 1004722).
 // It is the floor's one-word token; the multi-word one is the module authorship credit,
 // which modules.json legitimately carries and which this check never named.
-const { PRIOR_INSTANCE_FLOOR } = require('../scripts/gds/package-core.js');
+const { PRIOR_INSTANCE_FLOOR } = require('../scripts/bongos/package-core.js');
 const PRIOR_BRAND = PRIOR_INSTANCE_FLOOR.tokens.find((t) => /^[a-z0-9]+$/i.test(t));
 assert.ok(PRIOR_BRAND, 'PRIOR_INSTANCE_FLOOR must name a one-word brand, or the brand checks below are vacuous');
 const LEAKED = [/committed_files/i, /auth-idp/i, /verifyHubAssertion/i, /serverSideGuards/i, new RegExp(PRIOR_BRAND, 'i'), /frame-ancestors/i,

package/tests/hall_profile_world.mjs

@@ -532,3 +532,20 @@ test('the out state says out loud that it only renders empty against the kit stu
   assert.ok(/fixture-me/.test(out._),
     'and names --fixture-me as the thing that hides the empty state');
 });
+
+// task 1004827 (owner, 2026-10-23): no top block. The head is hidden on every
+// page (task 1004836), so the profile carries no eyebrow and no sub-line, and a
+// page with no profile to draw says so in the BODY — a message written into the
+// hidden head would reach nobody.
+test('the profile has no top block, and its "no profile" messages land in the body', () => {
+  const html = read('profile.html');
+  const head = html.slice(html.indexOf('<div class="page-head'), html.indexOf('</div>', html.indexOf('<div class="page-head')));
+  assert.ok(!/page-head__eyebrow|page-head__sub|id="profile-sub"/.test(head), 'only the screen-reader h1 is left in the head');
+  const js = read('profile.js');
+  assert.ok(!js.includes("$('#profile-sub')"), 'nothing writes the old sub-line');
+  const fn = js.slice(js.indexOf('  function showMessage(text) {'), js.indexOf('  function renderProfile('));
+  const $ = (sel) => (sel === '#profile-head' ? el : null);
+  const el = { innerHTML: '' };
+  new Function('$', 'escapeHtml', `${fn}\nshowMessage('No builder found with that id.');`)($, (s) => String(s));
+  assert.match(el.innerHTML, /profile__placeholder">No builder found with that id\./, 'the message is drawn where the profile would be');
+});

package/tests/hall_reading_world.mjs

@@ -360,7 +360,6 @@ test('every reading room renders exactly one h1, and it is the page head\'s', ()
 test('the three DOCS rooms take the room voice; the deck takes the board\'s', () => {
   for (const [name, html] of [['primer.html', primerHtml], ['diagrams.html', diagramsHtml], ['ranks.html', ranksHtml]]) {
     assert.match(html, /class="page-head page-head--room"/, `${name} is a reading room`);
-    assert.match(html, /class="page-head__eyebrow"/, `${name} carries the room's eyebrow`);
   }
   assert.match(roadmapHtml, /class="page-head page-head--board"/,
     'the roadmap is a working surface whose figures are the thing to look at, so its own name stays quiet');
@@ -717,3 +716,19 @@ test('the timeline module is a pure builder, so it is testable and cannot boot i
     assert.doesNotMatch(src, forbidden, `roadmap-timeline.js touches ${forbidden} — it is a builder, not a page`);
   }
 });
+
+// task 1004828: no page shows its head (task 1004836), so every Docs page's head
+// holds its one h1 and nothing else — an eyebrow or sub-line there is a line no
+// reader sees, and a script writing into one is a message nobody gets.
+test('every Docs page head holds only its h1, and no script writes into it', () => {
+  const pub = path.join(ROOT, 'modules/hall-ui/public');
+  for (const page of ['primer', 'ranks', 'drachmae', 'commands', 'diagrams', 'atlas', 'modules']) {
+    const html = dehtmlcomment(fs.readFileSync(path.join(pub, `${page}.html`), 'utf8'));
+    const head = html.match(/<div class="page-head[^"]*">([\s\S]*?)<\/div>/);
+    assert.ok(head, `${page}.html keeps its head for the h1`);
+    assert.doesNotMatch(head[1], /page-head__eyebrow|page-head__sub/, `${page}.html's hidden head holds no eyebrow or sub-line`);
+  }
+  for (const [file, id] of [['ranks.js', 'ranks-sub'], ['modules.js', 'modules-sub']]) {
+    assert.ok(!fs.readFileSync(path.join(pub, file), 'utf8').includes(id), `${file} no longer writes into #${id}`);
+  }
+});

package/tests/hall_roster_world.mjs

@@ -267,7 +267,8 @@ test('sessions: the floor is written from the pack\'s rank label, never a hardco
   const src = read('sessions.js');
   const sealed = src.slice(src.indexOf('function showSealed'), src.indexOf('// ---- paging state'));
   assert.match(sealed, /const floor = rankLabel\('metic'\)/);
-  assert.match(sealed, /\$\('#gate-h'\)\.textContent = `\$\{floor\} and up`/);
+  // 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.doesNotMatch(decomment(src), /Archons only|Metic rank up|Archon-only/);
   assert.doesNotMatch(read('sessions.html'), /Archon/);
 });

package/tests/hall_studio_world.mjs

@@ -61,6 +61,9 @@ test('the Studio writes ONLY the artist\'s verdict on their own review queue', (
     // approved tweak.
     /^POST \$\{API\}\/copy-desk\/pages\/\$\{pageId\}\/claim$/,
     /^PUT \$\{API\}\/copy-desk\/pages\/\$\{pageId\}\/draft$/,
+    // Release a round the reads cannot name (task 1004837): back to /tweak or
+    // closed, with a note, Metic and up. It moves a round, never a string.
+    /^POST \$\{API\}\/copy-desk\/pages\/\$\{pageId\}\/release$/,
   ];
   // Every write site, as "<VERB> <route expression>" — the verb from the
   // request call, the route from the WRITE_ROUTES entry it names.
@@ -75,7 +78,7 @@ test('the Studio writes ONLY the artist\'s verdict on their own review queue', (
       const named = /^WRITE_ROUTES\.(\w+)\(/.exec(arg.trim());
       return { verb, arg: arg.trim(), route: named ? routes.get(named[1]) : null };
     });
-  assert.equal(sites.length, 6, `the four verdict writes, one page claim and one draft save; found ${sites.length}`);
+  assert.equal(sites.length, 7, `the four verdict writes, one page claim, one draft save and one release; found ${sites.length}`);
   for (const s of sites) {
     assert.ok(s.route, `every write names a WRITE_ROUTES entry, never an inline URL: ${s.verb} ${s.arg}`);
     const site = `${s.verb} ${s.route}`;

package/tests/hall_work_history_id.mjs

@@ -0,0 +1,39 @@
+// tests/hall_work_history_id.mjs — a work-board row's task id never overflows
+// its box (task 1004832).
+//
+// .history__row is a flex row. The id had only min-width: 3.2em, so as a flex
+// item it shrank to 3.2em while a seven-digit id ("#1004577", eight mono
+// glyphs) needs about 4.8em: the render check measured it 20px past its box on
+// backlog and completed rows at 1440 and 390. The rule that keeps it fitting is
+// that the id does not shrink and does not wrap; the title beside it (min-width
+// 0, overflow-wrap anywhere) is the item that gives way.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const css = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/work.css'), 'utf8')
+  .replace(/\/\*[\s\S]*?\*\//g, '');
+const rule = (sel) => {
+  // the block whose selector is exactly sel (not .history__id inside a longer selector)
+  const re = new RegExp('(^|\\n)\\s*' + sel.replace(/[.]/g, '\\.') + '\\s*\\{([^}]*)\\}');
+  const m = css.match(re);
+  assert.ok(m, `${sel} rule exists`);
+  return m[2];
+};
+
+test('the id is a rigid flex item: it never shrinks below its digits', () => {
+  assert.match(rule('.history__id'), /flex:\s*none/);
+});
+
+test('the id never wraps inside its box', () => {
+  assert.match(rule('.history__id'), /white-space:\s*nowrap/);
+});
+
+test('the title is the item that gives way', () => {
+  const t = rule('.history__title');
+  assert.match(t, /min-width:\s*0/);
+  assert.match(t, /overflow-wrap:\s*anywhere/);
+});

package/tests/held_tweak_reporting.mjs

@@ -21,9 +21,9 @@ const require = createRequire(import.meta.url);
 const { test, summary } = makeRunner();
 
 const shipCard = require('../modules/lifecycle/ship-card.js');
-const shipFinish = require('../scripts/gds/ship-finish.js');
-const shipLand = require('../scripts/gds/ship-land.js');
-const { printCreditsAndAchievements } = require('../scripts/gds/ship-grade-steps.js');
+const shipFinish = require('../scripts/bongos/ship-finish.js');
+const shipLand = require('../scripts/bongos/ship-land.js');
+const { printCreditsAndAchievements } = require('../scripts/bongos/ship-grade-steps.js');
 
 const capture = async (fn) => {
   const out = [];
@@ -155,7 +155,7 @@ await test('a real failed grade at completed still says the grade did not pass',
 
 await test('both grade paths (ship and --regrade) hand the hold to the credits line', () => {
   const fs = require('node:fs');
-  const src = fs.readFileSync(new URL('../scripts/gds/ship-flow.js', import.meta.url), 'utf8');
+  const src = fs.readFileSync(new URL('../scripts/bongos/ship-flow.js', import.meta.url), 'utf8');
   const calls = src.split('printCreditsAndAchievements({').slice(1).map((c) => c.slice(0, c.indexOf('});')));
   const withHold = calls.filter((c) => /\bheld\b/.test(c));
   assert.equal(withHold.length, 2, 'the ship grade and the re-grade both pass held');

package/tests/helpers.mjs

@@ -133,7 +133,7 @@ export function requireHostModule(require, spec, note) {
 // ── carved-family source readers (tasks 1003204–1003206, goal 1000079) ────────
 //
 // The de-monolith work split four big files into a facade plus siblings:
-// modules/lifecycle/db.js, scripts/gds/ship.js, scripts/gds/fitness.js and
+// modules/lifecycle/db.js, scripts/bongos/ship.js, scripts/bongos/fitness.js and
 // modules/lifecycle/routes/tasks.js. A pile of tests assert things about one of
 // those SUBJECTS by regexing its source — that every claim path gates on
 // requires_rank, that a literal appears in exactly one place, that a gate
@@ -183,7 +183,7 @@ export function assertCannotSwallow(assert, paths, literal, paramPath, label = p
 }
 
 // The SHIP CLI: ship.js (facade + entry point) + the ship-*.js phase modules.
-export function shipCliSource(scriptsDir = path.join(ROOT, 'scripts', 'gds')) {
+export function shipCliSource(scriptsDir = path.join(ROOT, 'scripts', 'bongos')) {
   return familySource(scriptsDir,
     (f) => f === 'ship.js' || (f.startsWith('ship-') && f.endsWith('.js')));
 }
@@ -191,7 +191,7 @@ export function shipCliSource(scriptsDir = path.join(ROOT, 'scripts', 'gds')) {
 // The architecture-fitness GATE: fitness.js (registry + runner), fitness-lib.js
 // and the fitness-checks-*.js clusters. fitness-ratchets.js is deliberately in —
 // it has always been a registered check module of the same gate.
-export function fitnessSource(scriptsDir = path.join(ROOT, 'scripts', 'gds')) {
+export function fitnessSource(scriptsDir = path.join(ROOT, 'scripts', 'bongos')) {
   return familySource(scriptsDir,
     (f) => f === 'fitness.js' || (f.startsWith('fitness-') && f.endsWith('.js')));
 }

package/tests/home_bounded_reads.mjs

@@ -33,7 +33,7 @@ const ROUTE = read('modules/lifecycle/routes/tasks.js');
 const DB_TASKS = read('modules/lifecycle/db-tasks.js');
 
 // Comments stripped before any "is the bad pattern gone" assertion — the same rule
-// scripts/gds/category-advisory-guard.js applies. A comment EXPLAINING the pattern that
+// scripts/bongos/category-advisory-guard.js applies. A comment EXPLAINING the pattern that
 // was removed is documentation; matching it would make the fix un-documentable.
 const noComments = (src) => src.replace(/^\s*\/\/.*$/gm, '');
 

package/tests/home_isolation_guard.mjs

@@ -19,7 +19,7 @@ import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
 const { checkHomeIsolation, offendingLines, stripComments, ALLOW } =
-  require('../scripts/gds/home-isolation-guard.js');
+  require('../scripts/bongos/home-isolation-guard.js');
 
 const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 

package/tests/hook_core_resolve.mjs

@@ -1,7 +1,7 @@
 // tests/hook_core_resolve.mjs
 //
 // Task 2139 — the materialized .claude/hooks resolve CORE modules (src/bongos/*,
-// scripts/gds/*) in BOTH layouts: the repo root today, and the pinned @bongos/core
+// scripts/bongos/*) in BOTH layouts: the repo root today, and the pinned @bongos/core
 // package post-split (ADR 0108). Before this, conductor.js's UNGUARDED
 // require('../../src/bongos/…') MODULE_NOT_FOUND'd on EVERY UserPromptSubmit once
 // src/ left the instance root; the guarded hooks silently killed their feature.
@@ -63,10 +63,10 @@ t('resolves a core module inside node_modules/@bongos/core (post-split layout)',
 // 2. Priority: repo root wins when present in both (today's single checkout — unchanged).
 t('prefers the repo root when a core file exists at both root and node_modules', () => {
   const root = makeTree({
-    'scripts/gds/cli-lib.js': 'module.exports={root:true};',
-    'node_modules/@bongos/core/scripts/gds/cli-lib.js': 'module.exports={pkg:true};',
+    'scripts/bongos/cli-lib.js': 'module.exports={root:true};',
+    'node_modules/@bongos/core/scripts/bongos/cli-lib.js': 'module.exports={pkg:true};',
   });
-  const p = resolver.coreModulePathFrom(root, 'scripts/gds/cli-lib');
+  const p = resolver.coreModulePathFrom(root, 'scripts/bongos/cli-lib');
   assert.ok(p && !p.includes('node_modules'), `expected the root copy, got ${p}`);
 });
 
@@ -79,8 +79,8 @@ t('returns null when the core file exists in no layout', () => {
 // 4. Every published core package name is honored (scoped-private, scoped-public, bare).
 for (const pkg of resolver.CORE_PKG_NAMES) {
   t(`resolves via published package name "${pkg}"`, () => {
-    const root = makeTree({ [`node_modules/${pkg}/scripts/gds/x.js`]: 'module.exports={};' });
-    const p = resolver.coreModulePathFrom(root, 'scripts/gds/x.js');
+    const root = makeTree({ [`node_modules/${pkg}/scripts/bongos/x.js`]: 'module.exports={};' });
+    const p = resolver.coreModulePathFrom(root, 'scripts/bongos/x.js');
     const frag = join('node_modules', ...pkg.split('/'));
     assert.ok(p && p.includes(frag), `expected "${frag}" in ${p}`);
   });
@@ -88,7 +88,7 @@ for (const pkg of resolver.CORE_PKG_NAMES) {
 
 // 5. requireCore: loads a real core module at the repo root today; throws tagged when absent.
 t('requireCore loads a real core module at the repo root today', () => {
-  const cli = resolver.requireCore('scripts/gds/cli-lib');
+  const cli = resolver.requireCore('scripts/bongos/cli-lib');
   assert.equal(typeof cli.apiCall, 'function', 'expected cli-lib.apiCall');
 });
 t('requireCore throws CORE_MODULE_NOT_FOUND when the core module is absent', () => {

package/tests/hook_user_agents.mjs

@@ -37,7 +37,7 @@ const hookFiles = fs.existsSync(HOOKS_DIR)
   : [];
 
 // The neutral core does NOT carry .claude/hooks/ — it's instance-materialized and
-// package-excluded (PROTECTED_TOPOLOGY_EXCLUDE in scripts/gds/publish-manifest.js),
+// package-excluded (PROTECTED_TOPOLOGY_EXCLUDE in scripts/bongos/publish-manifest.js),
 // so a clean core checkout has no hooks to scan. Skip cleanly rather than fail the
 // assertions below (task 1002234, same class as tests/stop_refcheck.mjs's absent-hook
 // crash); this UA invariant is enforced on an instance whose hooks are materialized.