@bongos/core 1.24.40 → 1.24.42

package/tests/setup_flow.mjs

@@ -0,0 +1,242 @@
+// tests/setup_flow.mjs — the setup flow a new builder finishes once (task 1005076).
+//
+// Owner, 2026-11-05: a new builder is held on one setup screen until every step is done,
+// and once set up they are in for good — no setup banner on Home. Three halves, each run
+// for real: the claimable route ticks first_start only for a Claude (CLI) session; the
+// shell loads setup-gate.js and draws nothing else over it while setup is incomplete; and
+// the screen draws the steps, saves a craft, and lets the builder in once /me says done.
+// The rule itself (which steps, who goes straight in) is in tests/onboarding_state.mjs.
+//
+// Run:  node tests/setup_flow.mjs
+
+import { strict as assert } from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import { makeEl, realOTB, settle } from './helpers.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const read = (rel) => fs.readFileSync(path.join(ROOT, rel), 'utf8');
+const ROUTE = read('modules/lifecycle/routes/tasks.js');
+const SHELL = read('modules/hall-ui/public/shell.js');
+const GATE = read('modules/hall-ui/public/setup-gate.js');
+
+let passed = 0;
+let failed = 0;
+const t = async (name, fn) => {
+  try { await fn(); passed += 1; console.log(`  PASS  ${name}`); }
+  catch (e) { failed += 1; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+};
+
+const STEPS = (cleared) => ['signed_in', 'cli_setup', 'pick_disciplines', 'first_start']
+  .map((id) => ({ id, label: `Label ${id}`, hint: `Hint ${id}`, cleared: cleared.includes(id) }));
+
+console.log('the setup flow (task 1005076)');
+
+// ---- the claimable route: first_start only from Claude --------------------
+
+// The real guarded statement, run against each kind of session.
+const from = ROUTE.indexOf("if (req.gdsSession && req.gdsSession.source === 'cli')");
+const guard = ROUTE.slice(from, ROUTE.indexOf('\n', from));
+const runGuard = (gdsSession) => {
+  const marks = [];
+  const seams = { resolveOptional: () => ({ safeMarkStage: (_pool, id, stage) => marks.push([id, stage]) }) };
+  vm.runInNewContext(guard, { req: { gdsSession, builder: { id: 7 } }, seams, pool: {} });
+  return marks;
+};
+
+await t('GET /tasks/claimable marks first_start for a Claude (CLI) session, never for the browser', () => {
+  assert.ok(from > 0, 'the guard is in the claimable handler');
+  assert.match(guard, /safeMarkStage\(pool, req\.builder\.id, 'first_start', req\.builder\)/);
+  assert.deepEqual(runGuard({ source: 'cli' }), [[7, 'first_start']]);
+  assert.deepEqual(runGuard({ source: 'web' }), [], 'the hall pages read this feed from the browser');
+  assert.deepEqual(runGuard(null), []);
+  assert.equal((ROUTE.match(/'first_start'/g) || []).length, 1, 'no unguarded mark elsewhere in the routes');
+});
+
+// ---- the screen ------------------------------------------------------------
+
+function bootGate({ patchOk = true } = {}) {
+  const body = makeEl('body');
+  const htmlClasses = new Set();
+  const requests = [];
+  let reloaded = 0;
+  let me = null;
+  const api = { request: (method, p, opts) => {
+    requests.push({ method, p, body: opts && opts.body });
+    if (method === 'PATCH') return Promise.resolve({ ok: patchOk, status: patchOk ? 200 : 422, data: {} });
+    return Promise.resolve({ ok: true, status: 200, data: me });
+  } };
+  const intervals = [];
+  const document = {
+    body,
+    documentElement: { classList: { add: (c) => htmlClasses.add(c), remove: (c) => htmlClasses.delete(c) } },
+    createElement: (tag) => makeEl(tag),
+    getElementById: (id) => body.querySelector('#' + id),
+    activeElement: null,
+  };
+  // the crafts this project offers (dom-utils.js reads them off __MODULES__)
+  const window = { OTB: { ...realOTB(), disciplines: () => ['engineer', 'artist', 'ui'] }, location: { reload: () => { reloaded += 1; } } };
+  const sandbox = { window, document, setInterval: (fn) => { intervals.push(fn); return intervals.length; }, clearInterval() {} };
+  vm.createContext(sandbox);
+  vm.runInContext(GATE, sandbox, { filename: 'setup-gate.js' });
+  return {
+    show: (setup, builder) => window.OTBSetupGate.show(setup, { api, builder }),
+    gate: () => body.querySelector('#setup-gate'),
+    htmlClasses, requests, intervals,
+    setMe: (v) => { me = v; },
+    reloaded: () => reloaded,
+    click: (target) => body.querySelector('#setup-gate').fire('click', { target }),
+  };
+}
+
+await t('the screen lists every step in order, ticks the cleared ones, and opens the first gap', () => {
+  const g = bootGate();
+  g.show({ complete: false, steps: STEPS(['signed_in', 'cli_setup']) }, { display_name: 'Sam' });
+  const gate = g.gate();
+  assert.ok(gate, 'drawn');
+  assert.equal(gate.getAttribute('aria-modal'), 'true');
+  assert.ok(g.htmlClasses.has('setup-gate-open'), 'the hall behind it does not scroll');
+  assert.match(gate.querySelector('#setup-gate-h').textContent, /Welcome, Sam/);
+  assert.equal(gate.querySelector('.setup-gate__count').textContent, '2 of 4 done');
+  const steps = gate.querySelectorAll('.setup-gate__step');
+  assert.deepEqual(steps.map((s) => s.className), ['setup-gate__step is-done', 'setup-gate__step is-done', 'setup-gate__step is-current', 'setup-gate__step']);
+  assert.match(steps[2].textContent, /Hint pick_disciplines/, 'only the current step shows its hint');
+  assert.doesNotMatch(steps[3].textContent, /Hint first_start/);
+  assert.deepEqual(gate.querySelectorAll('[data-craft]').map((b) => b.textContent), ['Engineer', 'Artist', 'UI'],
+    'the crafts this project offers');
+});
+
+await t('choosing a craft saves it through PATCH /me/disciplines, the route every picker uses', async () => {
+  const g = bootGate();
+  g.show({ complete: false, steps: STEPS(['signed_in', 'cli_setup']) });
+  const save = () => g.gate().querySelector('[data-save-crafts]');
+  assert.equal(save().disabled, true, 'nothing picked, nothing to save');
+  g.click(g.gate().querySelector('[data-craft="artist"]'));
+  assert.equal(g.gate().querySelector('[data-craft="artist"]').getAttribute('aria-pressed'), 'true');
+  assert.equal(save().disabled, false);
+  g.setMe({ onboarding: { setup: { complete: false, steps: STEPS(['signed_in', 'cli_setup', 'pick_disciplines']) } } });
+  g.click(save());
+  await settle(); await settle();
+  const patch = g.requests.find((r) => r.method === 'PATCH');
+  assert.equal(patch.p, '/api/bongos/me/disciplines');
+  assert.deepEqual(JSON.parse(JSON.stringify(patch.body)), { preferred_disciplines: ['artist'] });
+  assert.equal(g.gate().querySelector('.setup-gate__count').textContent, '3 of 4 done', 're-read /me and ticked');
+});
+
+await t('a craft that does not save says so and can be tried again', async () => {
+  const g = bootGate({ patchOk: false });
+  g.show({ complete: false, steps: STEPS(['signed_in', 'cli_setup']) });
+  g.click(g.gate().querySelector('[data-craft="engineer"]'));
+  g.click(g.gate().querySelector('[data-save-crafts]'));
+  await settle();
+  const err = g.gate().querySelector('[data-craft-err]');
+  assert.equal(err.hidden, false);
+  assert.match(err.textContent, /did not save/);
+  assert.equal(g.gate().querySelector('[data-save-crafts]').disabled, false);
+});
+
+await t('it checks /me while it is up, and lets the builder in the moment setup is complete', async () => {
+  const g = bootGate();
+  g.show({ complete: false, steps: STEPS(['signed_in', 'cli_setup', 'pick_disciplines']) });
+  assert.equal(g.intervals.length, 1, 'it polls');
+  g.setMe({ onboarding: { setup: { complete: true, steps: STEPS(['signed_in', 'cli_setup', 'pick_disciplines', 'first_start']) } } });
+  g.intervals[0]();
+  await settle();
+  assert.equal(g.gate(), null, 'the screen is gone');
+  assert.ok(!g.htmlClasses.has('setup-gate-open'));
+  assert.equal(g.reloaded(), 1, 'the page reloads into the hall');
+});
+
+await t('a complete setup draws nothing', () => {
+  const g = bootGate();
+  g.show({ complete: true, steps: STEPS(['signed_in', 'cli_setup', 'pick_disciplines', 'first_start']) });
+  assert.equal(g.gate(), null);
+});
+
+// ---- the shell: loads the screen, and nothing else is drawn over it ---------
+
+function bootShell({ deferLoad = false } = {}) {
+  const loaded = [];
+  const pending = [];
+  const asked = [];
+  let sandbox = null;
+  const stubEl = () => ({
+    dataset: {}, style: {}, textContent: '', hidden: false, innerHTML: '',
+    classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
+    setAttribute() {}, getAttribute() { return null; }, removeAttribute() {}, addEventListener() {},
+    querySelector() { return null; }, querySelectorAll() { return []; }, appendChild() {}, focus() {},
+  });
+  const els = new Map();
+  const document = {
+    body: { dataset: { page: 'work' }, appendChild() {} },
+    documentElement: { dataset: {}, style: {}, classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } } },
+    getElementById(id) { if (!els.has(id)) els.set(id, stubEl()); return els.get(id); },
+    querySelectorAll() { return []; }, createElement: () => stubEl(),
+    addEventListener() {}, dispatchEvent() {}, get cookie() { return ''; }, set cookie(_v) {},
+    head: { appendChild(tag) {
+      loaded.push(tag.src);
+      const land = () => {
+        if (/setup-gate/.test(tag.src)) sandbox.window.OTBSetupGate = { show: (setup) => asked.push(['gate', setup.complete]) };
+        if (tag.onload) tag.onload();
+      };
+      if (deferLoad && /setup-gate/.test(tag.src)) pending.push(land); else land();
+    } },
+  };
+  const location = { hostname: 'h', origin: 'https://h', pathname: '/work', hash: '', assign() {}, replace() {} };
+  const window = {
+    OTB: realOTB(), __BRANDING__: {}, __MODULES__: { enabled: {} },
+    BongosClient: { createClient: () => ({ request: () => new Promise(() => {}) }) },
+    // the boot pass runs before anyone is signed in, when neither draws anything: count signed-in asks only
+    OTBWelcome: { onAccess: (access) => { if (access.authed === true) asked.push(['welcome']); return false; } },
+    OTBCraftMode: { onAccess: (access) => { if (access.authed === true) asked.push(['craft']); }, applyNav() {}, mount() {}, setPositions() {}, switchHtml: () => '' },
+    matchMedia: () => ({ matches: false, addEventListener() {} }),
+    localStorage: { getItem: () => null, setItem() {} },
+    requestAnimationFrame() {}, scrollTo() {}, location, addEventListener() {},
+  };
+  sandbox = { window, document, location, console, setTimeout, clearTimeout, queueMicrotask,
+    CustomEvent: class { constructor(tp, i) { this.type = tp; Object.assign(this, i); } } };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(SHELL, sandbox, { filename: 'shell.js' });
+  return { apply: (state) => window.OTBShell.applyAccess(state), land: () => pending.splice(0).forEach((f) => f()), loaded, asked };
+}
+
+await t('the shell holds an unfinished builder on the setup screen, with no welcome or craft picker over it', () => {
+  const s = bootShell();
+  s.apply({ authed: true, rank: 'xenos', builder: { id: 9 }, setup: { complete: false, steps: STEPS(['signed_in']) } });
+  assert.equal(s.loaded.filter((u) => /^\/builders\/setup-gate\.js/.test(u)).length, 1, 'its file is loaded');
+  assert.deepEqual(s.asked, [['gate', false]], 'the screen, and nothing over it');
+});
+
+await t('the setup screen loads once, however often the shell re-checks access before it lands', () => {
+  const s = bootShell({ deferLoad: true });
+  const held = { authed: true, rank: 'xenos', builder: { id: 9 }, setup: { complete: false, steps: STEPS(['signed_in']) } };
+  s.apply(held);
+  s.apply(held);
+  s.apply(held);
+  assert.equal(s.loaded.filter((u) => /setup-gate\.js/.test(u)).length, 1, 'one script tag, so one screen');
+  s.land();
+  assert.deepEqual(s.asked, [['gate', false]]);
+});
+
+await t('a set-up builder loads no setup file and gets the hall as before', () => {
+  const s = bootShell();
+  s.apply({ authed: true, rank: 'xenos', builder: { id: 9 }, setup: { complete: true, steps: [] } });
+  assert.equal(s.loaded.filter((u) => /setup-gate/.test(u)).length, 0);
+  assert.ok(!s.asked.some(([k]) => k === 'gate'), 'no setup screen');
+  assert.deepEqual(s.asked.slice(0, 2), [['welcome'], ['craft']], 'the daily welcome and craft picker as before');
+  const unknown = bootShell();
+  unknown.apply({ authed: true, rank: 'xenos', builder: { id: 9 }, setup: null });
+  assert.equal(unknown.loaded.filter((u) => /setup-gate/.test(u)).length, 0, 'an older server that sends no setup holds nobody');
+});
+
+await t('Home carries no setup banner: the Welcome and Getting started panels are gone', () => {
+  const widgets = read('modules/hall-ui/public/hall-widgets.js');
+  assert.doesNotMatch(widgets, /w\('welcome-scroll'|w\('onboarding-scroll'/);
+  assert.doesNotMatch(read('modules/hall-ui/public/index.html'), /welcome-reopen|Show the setup guide again/);
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);

package/tests/welcome_boot.mjs

@@ -122,6 +122,7 @@ test('Home loads the welcome before the shell, and the shell asks it before the
     'welcome-boot.js, then the shell trio');
   assert.ok(at('welcome-boot.css') > 0, 'and its sheet');
   const shell = fs.readFileSync(path.join(HALL, 'shell.js'), 'utf8');
-  assert.match(shell, /if \(!\(window\.OTBWelcome && window\.OTBWelcome\.onAccess\(access, state && state\.builder\)\) && CRAFT\) CRAFT\.onAccess\(/,
-    'the picker is asked only when the welcome did not show');
+  // task 1005076: and neither is asked while the setup screen holds the builder (tests/setup_flow.mjs).
+  assert.match(shell, /if \(!holdForSetup\(state && state\.builder\) && !\(window\.OTBWelcome && window\.OTBWelcome\.onAccess\(access, state && state\.builder\)\) && CRAFT\) CRAFT\.onAccess\(/,
+    'the picker is asked only when setup is done and the welcome did not show');
 });

package/modules/hall-ui/public/gate.html

@@ -1,76 +0,0 @@
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>Autobongos — {{worldName}}</title>
-  <meta name="description" content="The Autobongos runner: switch unattended building on or off, choose the goals it may work, and pause any builder's runner.">
-  <link rel="icon" href="data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'><text x='16' y='24' font-size='24' text-anchor='middle' font-family='sans-serif'>⌂</text></svg>">
-  <link rel="preconnect" href="https://fonts.googleapis.com">
-  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-  <link rel="stylesheet" href="/builders/style.css?v=2026-07-02-shell1">
-  <link rel="stylesheet" href="/builders/oversight.css">
-  <link rel="stylesheet" href="/builders/gate.css">
-</head>
-<body data-page="gate" data-page-title="Autobongos">
-
-<div class="app">
-  <aside class="app-sidebar" id="app-sidebar" aria-label="Primary"></aside>
-  <div class="app-scrim" id="app-scrim" hidden></div>
-  <div class="app-body">
-    <header class="app-topbar" id="app-topbar"></header>
-    <div class="app-content">
-      <!-- The page's one h1, for screen readers: no page shows its head (task
-           1004836), so its sub-line went in task 1004829. -->
-      <div class="page-head page-head--board">
-        <h1 class="page-head__h">Autobongos</h1>
-      </div>
-
-      <main id="hall-main">
-        <!-- task 1005043: the page loader, shown until any section below is revealed. -->
-        <p class="hall-loading hall-loading--page hall-loading--wait" role="status">Loading…</p>
-        <!-- task 1003469: the sealed state is a panel with a heading, not a bare
-             line on the ground. gate.js writes the real floor into the lede from
-             the pack's rank label, so the copy cannot drift from ADR 0157. -->
-        <section class="scroll" id="gate-sealed" aria-labelledby="gate-sealed-h" hidden>
-          <h2 class="scroll__h" id="gate-sealed-h">Restricted</h2>
-          <p class="scroll__lede" id="gate-sealed-body">This page opens at a higher rank.</p>
-        </section>
-
-        <section id="gate-body" hidden>
-          <!-- The Autobongos fence (task 1003908, ADR 0307 §6): what is allowed to
-               reach main unattended. This page held the held-PR list too until task
-               1004859 removed it; the URL stays /gate so bookmarks keep working.
-               Archon-only — a Metic gets the note below instead, and the routes
-               behind the panel are system:true/archon server-side regardless. -->
-          <p class="scroll__lede" id="gate-archon-only" hidden></p>
-          <section class="scroll" id="fence-panel" aria-labelledby="fence-h" hidden>
-            <h2 class="scroll__h" id="fence-h">Autobongos runner</h2>
-            <!-- One panel (task 1004509): a checklist while anything the runner
-                 needs is missing, one status line with the switch once it is all
-                 ticked. Drawn from /autonomy/runners + /autonomy/fence together. -->
-            <div id="fence-body"><span class="kit-skel"></span></div>
-            <!-- Every builder's runner (task 1004501): what each one picked to
-                 work, whether you paused it, and whether it is checking in. -->
-            <div id="fence-builders"></div>
-          </section>
-        </section>
-      </main>
-
-      <footer class="app-foot" id="app-foot"></footer>
-    </div>
-  </div>
-</div>
-
-<div id="toast" class="toast" role="status" aria-live="polite" data-visible="0"></div>
-
-<script src="/builders/dom-utils.js?v=2026-10-25-escape"></script>
-<script src="/builders/shell-trail.js?v=2026-10-08-city-tab"></script>
-<script src="/builders/craft-mode.js?v=2026-11-05-sections"></script>
-<script src="/builders/shell.js?v=2026-11-05-sections"></script>
-<!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
-<script src="/builders/palette.js" defer></script>
-<script src="/builders/hall-kit.js"></script>
-<script src="/builders/gate.js?v=2026-10-25-autobongos"></script>
-</body>
-</html>

package/modules/hall-ui/public/gate.states.json

@@ -1,60 +0,0 @@
-{
-  "_": "Autobongos — the owner's runner panel behind requireGovernmentPage, still served at /gate (task 1004859 removed the held-PR list). Measured at three widths in both modes rather than looked at once.",
-  "page": "/builders/gate",
-  "surface": "hall-ui",
-  "stub": {
-    "prefix": "/builders/"
-  },
-  "modeQuery": false,
-  "_feeds": "The kit's own stub carries no feed for this page, so against it the page renders its EMPTY and SKELETON states — which is the point: those are states the floors must hold in. Against the hall-preview harness the same states render populated. Every declared 404 below is a fixture the harness does not carry, named rather than hidden.",
-  "ignoreRequests": [
-    "/api/(gds|bongos)/me$",
-    "/api/(gds|bongos)/me/",
-    "/api/(gds|bongos)/goals",
-    "/api/(gds|bongos)/inbox/",
-    "/api/(gds|bongos)/versions",
-    "/api/(gds|bongos)/builders",
-    "/api/(gds|bongos)/access-requests",
-    "/api/(gds|bongos)/autonomy/"
-  ],
-  "ignoreConsole": [
-    "/api/(gds|bongos)/",
-    "\\b401\\b",
-    "\\b403\\b",
-    "\\b404\\b",
-    "\\b501\\b",
-    "Unauthorized",
-    "Forbidden",
-    "Not Found",
-    "Not Implemented",
-    "load failed"
-  ],
-  "states": {
-    "queue": {
-      "auth": true,
-      "actions": [
-        [
-          "wait",
-          700
-        ]
-      ],
-      "expect": {
-        "visible": [
-          "#gate-body"
-        ]
-      }
-    },
-    "out": {
-      "auth": false
-    }
-  },
-  "reducedMotion": {
-    "auth": true,
-    "actions": [
-      [
-        "wait",
-        600
-      ]
-    ]
-  }
-}

package/modules/hall-ui/public/sessions.html

@@ -1,128 +0,0 @@
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>Sessions — {{worldName}}</title>
-  <meta name="description" content="The record of every work session — who built, what it touched, what it cost.">
-  <link rel="icon" href="data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'><text x='16' y='24' font-size='24' text-anchor='middle' font-family='sans-serif'>⌂</text></svg>">
-  <link rel="preconnect" href="https://fonts.googleapis.com">
-  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-  <link rel="stylesheet" href="/builders/style.css?v=2026-06-04-sessions">
-  <!-- task 1003470: the family sheet (the top-of-page strip, the mono fact,
-       the chip that is a door), linked before the page's own. -->
-  <link rel="stylesheet" href="/builders/oversight.css">
-  <link rel="stylesheet" href="/builders/sessions.css">
-</head>
-<body data-page="sessions" data-page-title="Sessions">
-
-<div class="app">
-  <aside class="app-sidebar" id="app-sidebar" aria-label="Primary"></aside>
-  <div class="app-scrim" id="app-scrim" hidden></div>
-  <div class="app-body">
-    <header class="app-topbar" id="app-topbar"></header>
-    <div class="app-content">
-      <!-- The page's one h1, for screen readers: no page shows its head (task
-           1004836), so its sub-line went in task 1004829. -->
-      <div class="page-head page-head--board">
-        <h1 class="page-head__h">Sessions</h1>
-      </div>
-
-      <main id="hall-main">
-        <!-- task 1005043: the page loader, shown until any section below is revealed. -->
-        <p class="hall-loading hall-loading--page hall-loading--wait" role="status">Loading…</p>
-        <!-- Access notice — shown by sessions.js when the viewer is below the
-             floor. The heading and the line are written from the pack's rank
-             label (ADR 0157: metic and up), so the static text never renders. -->
-        <section class="scroll" id="gate-scroll" aria-labelledby="gate-h" hidden>
-          <h2 id="gate-h" class="scroll__h">Higher ranks only</h2>
-          <p class="scroll__lede" id="gate-body">The session log opens from a higher rank.</p>
-        </section>
-
-        <!-- Totals — the shell's glass strip at the top of the page (the way
-             Watch and Gate carry theirs), not a strip inside a panel. -->
-        <section class="ov-summary" id="stats-scroll" aria-labelledby="stats-h" hidden>
-          <h2 id="stats-h" class="sr-only">Totals</h2>
-          <div class="stat-row" id="stats-body"></div>
-        </section>
-
-        <!-- Every recorded session — the corpus table. No wrapper: the shell's
-             card strip scrolls a wide ledger on a phone, and the old wrapper
-             turned the sticky header into a scrollport overlay on desktop. -->
-        <section class="scroll" id="sessions-scroll" aria-labelledby="sessions-h" hidden>
-          <h2 id="sessions-h" class="scroll__h">Recorded sessions</h2>
-          <!-- The count, and a failed load, sit here: the page head that used to carry
-               them is hidden (task 1004829). -->
-          <p class="scroll__lede" id="ledger-status" role="status" aria-live="polite">Loading sessions…</p>
-          <!-- task 1003975: the ledger's first filter. It LOOKS like the pager's
-               per-page control on purpose (one control grammar per page) but wears
-               its own class — the hall_audit guard reads `class="pager…"` as a
-               hand-rolled pager, and it is right to: borrowing that family is how a
-               second pager implementation starts. Its options are filled from the
-               server's vocabulary in sessions.js, never hardcoded here, where they
-               would drift from what the route accepts. -->
-          <div class="ledger-filters">
-            <label class="ledger-filter">
-              <span>Kind</span>
-              <select id="session-type-filter" aria-label="Filter sessions by kind"></select>
-            </label>
-          </div>
-          <table class="ledger" id="sessions-table">
-            <thead>
-              <tr>
-                <th>Session</th><th>Builder</th>
-                <th title="What the session did, derived from its own transcript: whether it wrote files, used tools, and how many prompts a person actually sent.">Kind</th>
-                <th>Tasks</th>
-                <th class="ledger__num">Earned</th><th class="ledger__num">Turns</th><th class="ledger__num">Tokens</th><th class="ledger__num">Tool errors</th>
-                <th class="ledger__num">Duration</th>
-                <th class="ledger__num" title="How the session read to this builder, scored against their own interaction profile. Advisory — it gates nothing.">Plain speech</th>
-                <th>Recorded</th>
-              </tr>
-            </thead>
-            <tbody id="sessions-body"></tbody>
-          </table>
-          <!-- The kit stamps the pager bar here (sessions.js, OTBKit.pagerBarHtml).
-               makeLedger is deliberately NOT used: it stamps table + pager into one
-               mount, and this page keeps them separate so the bar sits below the
-               ledger rather than inside whatever scrollport the table is in. -->
-          <div id="sessions-pager-mount"></div>
-          <p class="ledger__note" id="ledger-foot"></p>
-        </section>
-
-        <!-- task 1002830: the narrative. Opened from a row's Read door; the SAME page
-             and the same gate as the ledger above (ADR 0051 — no second page). The
-             server decides who may read a transcript and records an administrator's
-             cross-builder read BEFORE serving it; this panel only displays. -->
-        <section class="scroll" id="transcript-scroll" aria-labelledby="transcript-h" hidden>
-          <h2 id="transcript-h" class="scroll__h">Transcript</h2>
-          <p class="scroll__lede" id="transcript-sub"></p>
-          <p><button type="button" class="btn" id="transcript-close">Close transcript</button></p>
-          <div id="transcript-body" class="transcript"></div>
-          <p><button type="button" class="btn" id="transcript-more" hidden>Load more turns</button></p>
-        </section>
-      </main>
-
-      <footer class="app-foot" id="app-foot"></footer>
-    </div>
-  </div>
-</div>
-
-<div id="toast" class="toast" role="status" aria-live="polite" data-visible="0"></div>
-
-<!-- The app shell (sidebar + top bar). Dependency-free; loaded FIRST so the
-     chrome exists before the page script runs. -->
-<script src="/builders/dom-utils.js?v=2026-10-25-escape"></script>
-<script src="/builders/shell-trail.js?v=2026-10-08-city-tab"></script>
-<script src="/builders/craft-mode.js?v=2026-11-05-sections"></script>
-<script src="/builders/shell.js?v=2026-11-05-sections"></script>
-<!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
-<script src="/builders/palette.js" defer></script>
-<script src="/builders/task-detail.js?v=2026-07-03-taskdetail"></script>
-<!-- The shared component kit — the pager contract this page now uses instead of
-     its own (task 1003279-sibling follow-up of 1003281). Must load BEFORE
-     sessions.js, which reads window.OTBKit at boot. -->
-<script src="/builders/hall-kit.js"></script>
-<script src="/builders/brand-apply.js?v=2026-06-19-r56"></script>
-<script src="/builders/sessions.js?v=2026-10-02-transcript"></script>
-</body>
-</html>

package/modules/hall-ui/public/sessions.states.json

@@ -1,59 +0,0 @@
-{
-  "_": "Sessions — the session ledger behind requireGovernmentPage. sessions.js pages SERVER-SIDE by offset and is the one sanctioned hand-rolled pager in the hall; this file measures it, it does not ask it to change. Written with the re-skin (task 1003307); the redesign (task 1003470) put the totals on the shell's top-of-page strip, dropped the nowrap + wrapper pair that broke the sticky header, and made every id on a row a door. Populated look: the hall-preview harness (five rows in sessions__search.json).",
-  "page": "/builders/sessions",
-  "surface": "hall-ui",
-  "stub": {
-    "prefix": "/builders/"
-  },
-  "modeQuery": false,
-  "_feeds": "The kit's own stub carries no feed for this page, so against it the page renders its EMPTY and SKELETON states — which is the point: those are states the floors must hold in. Against the hall-preview harness the same states render populated. Every declared 404 below is a fixture the harness does not carry, named rather than hidden.",
-  "ignoreRequests": [
-    "/api/(gds|bongos)/me$",
-    "/api/(gds|bongos)/me/",
-    "/api/(gds|bongos)/goals",
-    "/api/(gds|bongos)/inbox/",
-    "/api/(gds|bongos)/versions",
-    "/api/(gds|bongos)/sessions"
-  ],
-  "ignoreConsole": [
-    "/api/(gds|bongos)/",
-    "\\b401\\b",
-    "\\b403\\b",
-    "\\b404\\b",
-    "\\b501\\b",
-    "Unauthorized",
-    "Forbidden",
-    "Not Found",
-    "Not Implemented",
-    "load failed"
-  ],
-  "states": {
-    "ledger": {
-      "auth": true,
-      "actions": [
-        [
-          "wait",
-          700
-        ]
-      ],
-      "expect": {
-        "visible": [
-          "#stats-scroll",
-          "#sessions-scroll"
-        ]
-      }
-    },
-    "out": {
-      "auth": false
-    }
-  },
-  "reducedMotion": {
-    "auth": true,
-    "actions": [
-      [
-        "wait",
-        600
-      ]
-    ]
-  }
-}