@bongos/core 1.24.40 → 1.24.42

package/tests/hall_landing_boot.mjs

@@ -92,15 +92,14 @@ async function boot({ meStatus, settle = false }) {
     },
     OTBHallRender: () => ({
       analyticsState: {}, lbState: {},
-      shipsPager: { page: 1 }, welcomeDismissalKey: () => 'k',
+      shipsPager: { page: 1 },
       // 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'),
-      renderNav: spy('renderNav'), renderOnboarding: spy('renderOnboarding'),
+      renderNav: spy('renderNav'),
       renderProfile: spy('renderProfile'), renderRecentShips: spy('renderRecentShips'),
-      renderWelcomeCore: spy('renderWelcomeCore'),
       // task 1003459 — wireEvents() calls this unconditionally now (the Home
       // Next-up Claim button), so an incomplete stub throws mid-wire.
       wireNextUpClaim: spy('wireNextUpClaim'),

package/tests/hall_loading.mjs

@@ -83,7 +83,7 @@ test('the page loaders step aside by themselves, and never show without :has()',
   assert.match(STYLE, /\.hall-loading--wait, \.hall-loading--zones \{ display: none; \}/);
   assert.match(STYLE, /@supports selector\(:has\(a\)\) \{\s*\.hall-loading--wait:not\(:has\(~ :not\(\[hidden\], script, template, style\)\)\) \{ display: flex; \}\s*\.hall-loading--zones:not\(:has\(~ :not\(\[hidden\]\) > :not\(\[hidden\], script, template, style\)\)\) \{ display: flex; \}\s*\}/);
   // A page whose sections all start [hidden] carries the --wait loader FIRST in its main.
-  for (const page of ['board-room', 'deploy', 'gate', 'government', 'money', 'project-settings', 'sessions']) {
+  for (const page of ['board-room', 'deploy', 'government', 'money', 'project-settings']) {
     const html = read(`${page}.html`);
     const main = html.slice(html.indexOf('<main id="hall-main">'));
     const first = main.replace(/<main id="hall-main">\s*(<!--[\s\S]*?-->\s*)*/, '');
@@ -95,6 +95,17 @@ test('the page loaders step aside by themselves, and never show without :has()',
   }
   assert.match(read('index.html'), /<section class="view" id="view-home"[^>]*>\s*<!--[^>]*-->\s*<p class="hall-loading hall-loading--page hall-loading--zones" role="status">Loading…<\/p>/, 'Home waits on its zones');
   assert.match(read('watch.html'), /<main id="hall-main">\s*<!--[^>]*-->\s*<p class="hall-loading hall-loading--page hall-loading--zones" role="status">Loading…<\/p>/, 'Watch waits on its panes');
+  // task 1005049: the Sessions and Autobongos tabs (once their own pages) open on the
+  // --wait loader, so a tab whose sections are all still hidden says it is loading.
+  for (const pane of ['pane-sessions', 'pane-autobongos']) {
+    const html = read('watch.html');
+    const inner = html.slice(html.indexOf(`<div id="${pane}"`));
+    const body = inner.slice(inner.indexOf('>') + 1).replace(/^\s*(<!--[\s\S]*?-->\s*)*/, '');
+    assert.match(body, /^<p class="hall-loading hall-loading--page hall-loading--wait" role="status">Loading…<\/p>/, `${pane} opens on the page loader`);
+    const kids = [...body.slice(body.indexOf('</p>') + 4, body.indexOf('\n        </div>')).matchAll(/^ {10}<(section|div|p|nav)\b([^>]*)>/gm)];
+    assert.ok(kids.length >= 1, `${pane} has sections after the loader`);
+    for (const [, tag, attrs] of kids) assert.match(attrs, /\bhidden\b/, `${pane}: a <${tag}> after the loader starts hidden`);
+  }
   // Settings' layout is never [hidden] while it loads, so its loader is put away by hideLayout().
   assert.match(read('settings.html'), /id="settings-groups"[^>]*>\s*<!--[^>]*-->\s*<p class="hall-loading hall-loading--page" id="settings-loading" role="status">/);
   assert.match(read('settings.js'), /function hideLayout\(hide\) \{[\s\S]*?getElementById\('settings-loading'\)[\s\S]*?loading\.hidden = true;/);
@@ -105,7 +116,7 @@ test('no hall page waits on a bare line of text any more', () => {
   // the class would stay behind on the finished sentence. Each is named with why.
   const IN_PLACE = new Set([
     'atlas.html#caption',             // the map's caption, rewritten by atlas.js
-    'sessions.html#ledger-status',    // the ledger's status line, rewritten by sessions.js
+    'watch.html#ledger-status',       // the Sessions tab's status line, rewritten by sessions.js
     'goals.html#goal-deps-card-lede', // the dependency card's lede, rewritten by goals-page.js
     'goals.html#goal-deps-lede',
     'profile.html#activity-placeholder', // reused for the signed-out notice by profile.js

package/tests/hall_nav.mjs

@@ -335,7 +335,10 @@ test('sidebar groups read by audience, in order', () => {
   // 'market-watch-settings' (task 1004938) LEFT the group in task 1005045: the owner saw
   // "Market Watch" twice and had to guess which was which (owner decision 2026-11-03,
   // idea 1001310). The settings are an owner-only Settings tab on /market-watch now.
-  assert.deepEqual(nav[5].items.map((i) => i.id), ['watch', 'gate', 'sessions', 'project-settings', 'money', 'deploy', 'government']);
+  // 'gate' (Autobongos) and 'sessions' LEFT the group in task 1005049 (owner decision
+  // 2026-11-03, idea 1001315): they are tabs on Watch, and /gate + /sessions redirect there.
+  assert.deepEqual(nav[5].items.map((i) => i.id), ['watch', 'project-settings', 'money', 'deploy', 'government']);
+  assert.ok(!nav.flatMap((g) => g.items).some((i) => i.href === '/gate' || i.href === '/sessions'), 'no item points at a page that became a Watch tab');
   // task 1005045: and no label is left twice anywhere in the sidebar, so the next pair
   // fails here instead of in front of the owner.
   const labels = [...boot().sidebarHtml.matchAll(/<a class="nav-item" [^>]*>[\s\S]*?<span class="nav-item__label">([^<]*)<\/span>/g)].map((m) => m[1]);
@@ -787,7 +790,7 @@ test('no glyph path data reads as an IP address to the release leak scan', () =>
 // block (task 1004713). These drive the real shell and the real gov-positions.js.
 
 const tick = () => new Promise((resolve) => setImmediate(resolve));
-const GOVERNING = ['city', 'board-room', 'watch', 'gate', 'sessions', 'project-settings', 'money', 'deploy', 'government'];
+const GOVERNING = ['city', 'board-room', 'watch', 'project-settings', 'money', 'deploy', 'government'];
 const lead = (building, title) => ({ kind: 'lead', seat: 'lead:' + building, building, title });
 const block = (held) => ({ held, title: held.length ? held[0].title : null, has_position: held.length > 0 });
 

package/tests/hall_onboarding_bongos_setup.mjs

@@ -14,20 +14,20 @@ const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const read = (p) => fs.readFileSync(path.join(ROOT, p), 'utf8');
 const OLD = /\/builder-setup|setup-builder\.(sh|js)/;
 
-// The welcome panel's markup, from the setupSteps literal to the panel's innerHTML.
-function welcomeMarkup() {
-  const src = read('modules/hall-ui/public/hall-render.js');
-  const start = src.indexOf('const setupSteps = `');
-  const end = src.indexOf('body.innerHTML = `', start);
-  assert.ok(start > 0 && end > start, 'welcome panel markup located');
+// The setup screen's machine-linking step (task 1005076 replaced the Home welcome panel).
+function setupStepMarkup() {
+  const src = read('modules/hall-ui/public/setup-gate.js');
+  const start = src.indexOf("if (step.id === 'cli_setup') {");
+  const end = src.indexOf("if (step.id === 'pick_disciplines')", start);
+  assert.ok(start > 0 && end > start, 'the setup screen\'s cli_setup step located');
   return src.slice(start, end).split('\n').filter((l) => !/^\s*\/\//.test(l)).join('\n');
 }
 
-test('welcome panel: the steps and the clone block say npx bongos setup', () => {
-  const w = welcomeMarkup();
-  assert.match(w, /Run <code>npx bongos setup<\/code>/);
-  assert.match(w, /\\nnpm install\\nnpx bongos setup`/, 'clone block ends npm install + npx bongos setup');
-  assert.doesNotMatch(w, OLD, 'no legacy setup command on the welcome panel');
+test('setup screen: the steps and the clone block say npx bongos setup', () => {
+  const w = setupStepMarkup();
+  assert.match(w, /run <code>npx bongos setup<\/code>/);
+  assert.match(w, /\\nnpm install\\nnpx bongos setup<\/pre>/, 'clone block ends npm install + npx bongos setup');
+  assert.doesNotMatch(w, OLD, 'no legacy setup command on the setup screen');
   assert.doesNotMatch(w, /On Windows, run/, 'one command on every OS — no Windows-only line');
   assert.match(w, /nodejs\.org/, 'the tooling list names Node, which npm install needs');
 });
@@ -51,7 +51,7 @@ test('primer: both routes sign in with npx bongos setup', () => {
 
 test('the get-the-code block keeps one command per line (screen and copy)', () => {
   const css = read('modules/hall-ui/public/style.css');
-  const m = /\.setup__getcode \.welcome__paste\s*\{([^}]*)\}/.exec(css);
+  const m = /\.setup-gate__code\s*\{([^}]*)\}/.exec(css);
   assert.ok(m, 'scoped rule present');
   assert.match(m[1], /white-space:\s*pre/, 'copy-on-click reads innerText, so pre is what keeps the line breaks');
   assert.match(m[1], /overflow-y:\s*hidden/, 'a one-axis strip names both axes');
@@ -66,8 +66,8 @@ test('bin/bongos.js is committed executable, so npx leaves a fresh clone clean',
   assert.match(entry, /^100755 /, `expected mode 100755, got: ${entry.trim()}`);
 });
 
-test('welcome intro and checklist lead ask only for what a builder needs', () => {
-  const src = read('modules/hall-ui/public/hall-render.js');
+test('the setup screen and checklist lead ask only for what a builder needs', () => {
+  const src = read('modules/hall-ui/public/setup-gate.js');
   assert.doesNotMatch(src, /run the platform locally/, 'a builder does not run the platform');
   assert.match(src, /Clone the project to your machine and run <code>npm install<\/code> in it\./);
   const st = read('modules/onboarding/onboarding-state.js');

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/module_contributions.mjs

@@ -228,7 +228,8 @@ test('the role axis has exactly one user-facing word, and no surface types it',
     'modules/hall-ui/public/work.js',
     'modules/hall-ui/public/goals-page.js',
     'modules/hall-ui/public/profile.js',
-    'modules/hall-ui/public/builders.js',
+    // task 1005076: the setup screen's role step replaced builders.js's checklist picker.
+    'modules/hall-ui/public/setup-gate.js',
   ];
   for (const p of SURFACES) {
     const s = readSrc(p);
@@ -266,7 +267,8 @@ test('craft picker options: neither picker hardcodes the craft list any more', (
   // silently dropped a module-contributed craft. Whichever picker is edited next
   // must keep reading the server list.
   const read = (p) => readFileSync(path.join(ROOT, p), 'utf8');
-  for (const p of ['modules/hall-ui/public/settings.js', 'modules/hall-ui/public/hall-render.js']) {
+  // task 1005076: the second picker is the setup screen's role step (it was the Home checklist's).
+  for (const p of ['modules/hall-ui/public/settings.js', 'modules/hall-ui/public/setup-gate.js']) {
     const src = read(p);
     assert.ok(/OTB\.disciplines\(\)/.test(src), `${p} builds its options from OTB.disciplines()`);
     assert.ok(!/\['engineer',\s*'artist',\s*'ideator'\]/.test(src), `${p} no longer hardcodes the craft triple`);

package/tests/nav_permission_atoms.mjs

@@ -95,8 +95,10 @@ 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);
+// task 1005076: the setup flow's holdForSetup.
+const SHELL_SHA = '248d104831bae0de';
 
 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/onboarding_state.mjs

@@ -322,6 +322,39 @@ test('graduation is engine-only (display signals never gate it)', async () => {
   assert.ok(shaped.stages.every((s) => s.cleared === true));
 });
 
+// ---- the setup flow (task 1005076) -----------------------------------------
+
+const SETUP_IDS = ['signed_in', 'cli_setup', 'pick_disciplines', 'first_start'];
+const setupOf = (state, opts) => onboarding.shapeForApi(state, opts).setup;
+const clearedIds = (setup) => setup.steps.filter((s) => s.cleared).map((s) => s.id);
+
+test('setup: a brand-new xenos is held, with only signed_in cleared', () => {
+  const setup = setupOf(null, { rank: 'xenos' });
+  assert.equal(setup.complete, false);
+  assert.deepEqual(setup.steps.map((s) => s.id), SETUP_IDS);
+  assert.deepEqual(clearedIds(setup), ['signed_in']);
+  assert.ok(setup.steps.every((s) => s.label && s.hint), 'every step says what to do');
+});
+
+test('setup: each step ticks from its own signal, and all four complete it', () => {
+  const state = { current_stage: 'pick_disciplines', completed_stages: ['auth_complete'] };
+  assert.deepEqual(clearedIds(setupOf(state, { rank: 'xenos', cliAuthed: true })), ['signed_in', 'cli_setup']);
+  const picked = { current_stage: 'first_start', completed_stages: ['auth_complete', 'pick_disciplines'] };
+  const almost = setupOf(picked, { rank: 'xenos', cliAuthed: true });
+  assert.equal(almost.complete, false, 'first_start not yet run from Claude');
+  const started = { current_stage: 'first_claim', completed_stages: ['auth_complete', 'pick_disciplines', 'first_start'] };
+  assert.equal(setupOf(started, { rank: 'xenos', cliAuthed: true }).complete, true);
+  assert.equal(setupOf(started, { rank: 'xenos', cliAuthed: false }).complete, false, 'no linked machine, not set up');
+});
+
+test('setup: anyone already past it goes straight in', () => {
+  const fresh = { current_stage: 'auth_complete', completed_stages: [] };
+  for (const rank of ['thetes', 'metic', 'archon']) assert.equal(setupOf(fresh, { rank }).complete, true, rank);
+  assert.equal(setupOf({ current_stage: 'graduated', completed_stages: [] }, { rank: 'xenos' }).complete, true, 'graduated');
+  assert.equal(setupOf({ current_stage: 'ship_three', completed_stages: ['first_claim'] }, { rank: 'xenos' }).complete, true, 'claimed a task');
+  assert.equal(setupOf(fresh, {}).complete, false, 'an unknown rank is not a pass');
+});
+
 // ---- wrap-up --------------------------------------------------------------
 
 Promise.resolve().then(async () => {

package/tests/sessions_kit_pager.mjs

@@ -33,7 +33,8 @@ const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const read = (rel) => fs.readFileSync(path.join(ROOT, rel), 'utf8');
 const KIT_JS = read('modules/hall-ui/public/hall-kit.js');
 const SESSIONS_JS = read('modules/hall-ui/public/sessions.js');
-const SESSIONS_HTML = read('modules/hall-ui/public/sessions.html');
+// task 1005049: the ledger is Watch's Sessions tab, so its markup lives in watch.html.
+const SESSIONS_HTML = read('modules/hall-ui/public/watch.html');
 
 const { test, summary } = makeRunner();
 const tick = () => new Promise((r) => setTimeout(r, 0));
@@ -147,6 +148,9 @@ function harness({ total = 320, failAfter = null, viewerRank = 'metic', perPageP
   vm.runInContext(KIT_JS, sandbox, { filename: 'hall-kit.js' });
   if (dropKit) delete sandbox.window.OTBKit;
   vm.runInContext(SESSIONS_JS, sandbox, { filename: 'sessions.js' });
+  // The tab boots when Watch first opens it (task 1005049); a second open is a no-op.
+  sandbox.window.OTBWatchTabs.sessions();
+  sandbox.window.OTBWatchTabs.sessions();
 
   const searches = () => requests.filter((u) => u.includes('/sessions/search'));
   const q = (n) => {
@@ -161,7 +165,7 @@ function harness({ total = 320, failAfter = null, viewerRank = 'metic', perPageP
 // 1. the page markup no longer carries a pager of its own
 // ---------------------------------------------------------------------------
 
-await test('sessions.html carries a mount, not a hand-rolled pager', () => {
+await test('the Sessions tab carries a mount, not a hand-rolled pager', () => {
   assert.ok(!/id="ledger-pager"/.test(SESSIONS_HTML), 'the bespoke <nav class="pager"> is gone');
   assert.ok(!/id="pager-(prev|next|pos)"/.test(SESSIONS_HTML), 'its bespoke button ids are gone');
   assert.match(SESSIONS_HTML, /id="sessions-pager-mount"/);
@@ -307,14 +311,14 @@ await test('a missing kit degrades to a named failure, not a blank page', async
   await tick(); await tick();
   assert.equal(h.searches().length, 0, 'no corpus request without a pager to place it');
   // in the page body: the head that used to carry it is hidden (task 1004829)
-  assert.match(h.getEl('gate-body').textContent, /could not be loaded/);
+  assert.match(h.getEl('sess-sealed-body').textContent, /could not be loaded/);
 });
 
 await test('the rank gate still runs before any corpus request', async () => {
   const h = harness({ total: 320, viewerRank: 'xenos' });
   await tick(); await tick();
   assert.equal(h.searches().length, 0, 'a xenos must not even ask');
-  assert.equal(h.getEl('gate-scroll').hidden, false, 'they get the sealed notice');
+  assert.equal(h.getEl('sess-sealed').hidden, false, 'they get the sealed notice');
 });
 
 summary();