@bongos/core 1.19.504 → 1.19.506

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

@@ -64,11 +64,11 @@
             </thead>
             <tbody id="sessions-body"></tbody>
           </table>
-          <nav class="pager" id="ledger-pager" hidden aria-label="Session pages">
-            <button type="button" class="btn-ghost" id="pager-prev">← Newer</button>
-            <span class="pager__range" id="pager-pos"></span>
-            <button type="button" class="btn-ghost" id="pager-next">Older →</button>
-          </nav>
+          <!-- 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>
       </main>
@@ -88,7 +88,11 @@
 <!-- shared frontend toolkit (window.OTB) — loaded BEFORE sessions.js so it can pull from it. -->
 <script src="/builders/dom-utils.js?v=2026-06-14-domutils"></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-06-19-r56"></script>
+<script src="/builders/sessions.js?v=2026-08-28-kitpager"></script>
 </body>
 </html>

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

@@ -121,91 +121,146 @@
     $('#sessions-scroll').hidden = true;
   }
 
-  // ---- paging state --------------------------------------------------------
+  // ---- paging --------------------------------------------------------------
+  //
+  // This page used to hand-roll its own server-offset pager, and hall-ui/CLAUDE.md
+  // carried it as the ONE sanctioned exception to "no bespoke pager" (audited task
+  // 2179) — because the kit could only slice an array the browser already held, and
+  // this corpus cannot be held. Task 1003281 added the server-offset mode to the kit
+  // and left the migration as its own task; this is it. The exception is gone, so
+  // there is one pager contract in the hall again rather than one-plus-a-footnote.
+  //
+  // What the reader gains: a per-page control that remembers their choice, and a
+  // clamp — if the corpus shrinks under an open page, renderServerPage() says so and
+  // we re-ask, instead of showing an empty page under a range that claims rows.
+  //
+  // The one thing NOT taken from the kit is makeLedger: it stamps table+pager into a
+  // single mount, and the CARD is this page's scroll container (hall-ui/CLAUDE.md, the
+  // sideways-scroll rule), so a pager stamped into the table's mount would slide with
+  // the columns. Keeping it a separate sibling below the ledger is what holds it still.
+  // (This page used to carry a .ledger-table-wrap scrollport; task 1003470 removed it
+  // because the wrapper broke the shell's sticky th. The separate mount outlived it.)
+  // Table markup stays in sessions.html; the PAGER is the kit's.
 
-  const PAGE_SIZE = 50;
-  const state = { offset: 0, total: 0 };
+  // Guarded the way every other kit consumer guards it (profile.js): the kit is a
+  // separate <script>, so a cache miss or a load-order slip must degrade to a named
+  // failure rather than an uncaught throw at parse time that also kills load().
+  const kit = window.OTBKit;
+  const PAGER_PREFIX = 'sessions';
+  // 50 was this page's fixed page size before the per-page control existed; keeping it
+  // as the default means a returning reader's first page looks exactly as it did.
+  const pager = kit ? kit.makePager(PAGER_PREFIX, 'otb.sessions.perPage', { defaultPerPage: 50 }) : null;
+  // `page`/`perPage` here are the last values that actually PAINTED. The kit moves the
+  // pager first and calls back second, so a failed fetch has to put it back to these —
+  // otherwise the bar goes on claiming a page whose rows never arrived. Keeping both
+  // (not just the page) means a failed per-page change rolls back cleanly too.
+  const state = { total: 0, shown: 0, page: 1, perPage: pager?.perPage ?? 0 };
   let loading = false;
+  // Two clicks can be in flight at once; only the newest may paint (the profile
+  // activity-log idiom, task 1003281).
+  let inFlight = 0;
 
+  // Paint the kit's bar, then apply the one thing the kit deliberately does not model:
+  // a fetch is in flight, so nothing may be pressed again until it lands. Only the
+  // DISABLING is ours — re-enabling the arrows is left to the kit, which knows whether
+  // there is a page on either side; re-enabling them here would light up "Prev" on
+  // page 1. Returns the kit's clamped flag: true = the page outran a shrunken corpus.
   function renderPager() {
-    const pager = $('#ledger-pager');
-    const total = state.total;
-    if (total <= PAGE_SIZE) {
-      // Everything fits on one page — no pager needed.
-      pager.hidden = true;
-      return;
+    const clamped = kit.renderServerPage(pager, state.total, state.shown);
+    const perPage = $(`#${PAGER_PREFIX}-per-page`);
+    if (perPage) perPage.disabled = loading;
+    if (loading) {
+      for (const id of ['prev', 'next']) {
+        const el = $(`#${PAGER_PREFIX}-${id}`);
+        if (el) el.disabled = true;
+      }
     }
-    pager.hidden = false;
-    const page = Math.floor(state.offset / PAGE_SIZE) + 1;
-    const pages = Math.max(1, Math.ceil(total / PAGE_SIZE));
-    const from = state.offset + 1;
-    const to = Math.min(state.offset + PAGE_SIZE, total);
-    $('#pager-pos').textContent = `Page ${fmtInt(page)} of ${fmtInt(pages)} · ${fmtInt(from)}–${fmtInt(to)} of ${fmtInt(total)}`;
-    $('#pager-prev').disabled = loading || state.offset <= 0;
-    $('#pager-next').disabled = loading || state.offset + PAGE_SIZE >= total;
+    return clamped;
   }
 
+  // Paint one page. Returns true when the pager clamped — the corpus shrank under an
+  // open page, so the caller must re-ask rather than leave a range that lies.
   function showData(data) {
     const sessions = Array.isArray(data.sessions) ? data.sessions : [];
     const totals = data.totals || { total: data.total || sessions.length };
     state.total = num(totals.total);
+    state.shown = sessions.length;
     $('#gate-scroll').hidden = true;
     $('#stats-scroll').hidden = false;
     $('#sessions-scroll').hidden = false;
     renderStats(totals);
     renderTable(sessions);
-    renderPager();
+    const clamped = renderPager();
     $('#ledger-sub').textContent =
       `${fmtInt(totals.total)} session${num(totals.total) === 1 ? '' : 's'} across ${fmtInt(totals.builders)} builder${num(totals.builders) === 1 ? '' : 's'}.`;
     $('#ledger-foot').textContent =
       'Most recent first. Each load of this page is itself recorded in the audit log.';
+    return clamped;
   }
 
   // ---- load ----------------------------------------------------------------
 
-  // Fetch one page at the current offset. Returns true on success.
-  async function fetchPage() {
+  // Fetch the page the pager currently points at. Returns true on success.
+  //
+  // `pager.page` has ALREADY moved by the time this runs — wirePager advances it and
+  // then calls back — so a failure restores `state.page`/`state.perPage`, the last
+  // values that painted. That roll-back is what the old hand-roll did with
+  // `state.offset`, and it is the one piece of it worth carrying over.
+  async function fetchPage({ reclamps = 0 } = {}) {
+    const seq = ++inFlight;
     loading = true;
     renderPager();
     try {
       const res = await api.request(
         'GET',
-        `${API}/sessions/search?order=recent&limit=${PAGE_SIZE}&offset=${state.offset}`
+        `${API}/sessions/search?order=recent&limit=${pager.perPage}&offset=${kit.pageOffset(pager)}`
       );
+      // A newer click already went out; painting this answer would show a page nobody
+      // is on any more.
+      if (seq !== inFlight) return true;
       if (res.status === 401) { window.location.assign(`${API}/auth/web/start`); return false; }
       if (res.status === 403) {
         showSealed('You do not have access to the session log.');
         return false;
       }
       if (!res.ok) throw new Error(`search → ${res.status}`);
-      const data = res.data;
-      showData(data);
+      const clamped = showData(res.data);
+      // The corpus shrank under this page (sessions pruned between loads):
+      // renderServerPage pulled the page back into range, so go get the rows that page
+      // actually holds rather than leaving a range that disagrees with the table.
+      // One re-ask, never a loop: a corpus shrinking on every round-trip would
+      // otherwise spin here, and a stale range for one paint is the smaller harm.
+      if (clamped && reclamps < 1) { loading = false; return fetchPage({ reclamps: reclamps + 1 }); }
+      state.page = pager.page;
+      state.perPage = pager.perPage;
       return true;
     } catch (err) {
+      if (seq !== inFlight) return true;
       console.error('[sessions] failed to load corpus', err);
+      pager.page = state.page;
+      pager.perPage = state.perPage;
       $('#ledger-sub').textContent = 'The session log could not be loaded. Try again.';
       toast('Could not load sessions.');
       return false;
     } finally {
-      loading = false;
-      renderPager();
+      if (seq === inFlight) {
+        loading = false;
+        renderPager();
+      }
     }
   }
 
-  async function goTo(offset) {
-    if (loading) return;
-    const next = Math.max(0, offset);
-    if (next === state.offset) return;
-    const prev = state.offset;
-    state.offset = next;
-    const ok = await fetchPage();
-    if (!ok) state.offset = prev; // roll back on failure so the pager stays honest
-    else window.scrollTo({ top: 0, behavior: 'smooth' });
-  }
-
-  function wirePager() {
-    $('#pager-prev').addEventListener('click', () => goTo(state.offset - PAGE_SIZE));
-    $('#pager-next').addEventListener('click', () => goTo(state.offset + PAGE_SIZE));
+  function mountPager() {
+    const mount = $('#sessions-pager-mount');
+    if (!mount) return;
+    mount.innerHTML = kit.pagerBarHtml(PAGER_PREFIX, { label: 'sessions' });
+    // The kit has already updated `pager` by the time this fires; go get the rows that
+    // match it. Scrolling up only on success keeps a failed page from yanking the
+    // reader away from the table they were still looking at.
+    kit.wirePager(pager, async () => {
+      const ok = await fetchPage();
+      if (ok) window.scrollTo({ top: 0, behavior: 'smooth' });
+    });
   }
 
   async function load() {
@@ -234,8 +289,14 @@
       return;
     }
 
+    if (!kit) {
+      console.error('[sessions] OTBKit did not load — the pager cannot be built');
+      $('#ledger-sub').textContent = 'The session log could not be loaded. Try again.';
+      return;
+    }
+
     // 2. Fetch the first page (Archon-gated + audited server-side).
-    wirePager();
+    mountPager();
     await fetchPage();
   }
 

package/modules/hall-ui/public/task-detail.js

@@ -271,11 +271,16 @@
     // triage path: the STORED hint (idea.suggested_goal_id, written by
     // inbox.captureIdea precisely so triage inherits the guess) wins; the R07
     // suggester only fills in when there is no hint. Returns option HTML.
-    async function goalOptionsFor(versionId) {
+    // `allowHint` scopes the stored hint to the version it was filed against. A
+    // goal belongs to exactly ONE version and POST /tasks 400s `bad_goal_id` on a
+    // goal from another one, so carrying the hint across a version change offered
+    // — pre-selected — the single option guaranteed to fail (found by
+    // tests/task_detail_ui.mjs, task 1003516).
+    async function goalOptionsFor(versionId, allowHint) {
       // Number() so a junk stored value cannot reach the DOM as value="NaN" and
       // then be POSTed as a goal id.
       var raw = Number(idea.suggested_goal_id);
-      var hint = Number.isFinite(raw) && raw > 0 ? raw : null;
+      var hint = allowHint && Number.isFinite(raw) && raw > 0 ? raw : null;
       var suggestions = [];
       // The suggester is a convenience, so an outage degrades to "no suggestions"
       // and must not stop a triage verdict — the hint and the opt-out below are
@@ -348,7 +353,7 @@
       // Fetched for the PREFERRED version; the change listener below re-fetches,
       // because goals belong to a version and showing another version's goals
       // would offer a home the server would reject.
-      var goalOptions = await goalOptionsFor(preferred);
+      var goalOptions = await goalOptionsFor(preferred, true);
       var priOptions = [1, 2, 3, 4, 5].map(function (p) {
         return '<option value="' + p + '"' + (p === pri ? ' selected' : '') + '>P' + p + '</option>';
       }).join('');
@@ -382,7 +387,7 @@
           var mine = ++goalFetch;
           gsel.disabled = true;
           gsel.innerHTML = '<option value="">loading goals…</option>';
-          var html = await goalOptionsFor(vsel.value);
+          var html = await goalOptionsFor(vsel.value, vsel.value === preferred);
           if (mine !== goalFetch) return;
           gsel.innerHTML = html;
           gsel.disabled = false;

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.504",
+  "version": "1.19.506",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.19.504",
+      "version": "1.19.506",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.504",
+  "version": "1.19.506",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/src/module-api.js

@@ -45,7 +45,7 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.504'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.506'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/hall_audit.mjs

@@ -198,6 +198,44 @@ test('the sidebar scrolls its nav list, not the whole column', () => {
 
 // ---- 6. every hall list is paged through the kit (task 1002446) -----------
 
+test('the kit is the ONLY thing in the hall that emits pager markup', () => {
+  // hall-ui/CLAUDE.md's "no bespoke pager" rule had one sanctioned exception for two
+  // releases — sessions.js, which paged server-side by offset, a thing the kit could
+  // not express (audited task 2179). Task 1003281 added `makeLedger({ serverPager })`
+  // and left the migration as its own task; it has now landed, so the hall is back to
+  // ONE pager contract with no footnote.
+  //
+  // A rule that only lives in prose is a rule that comes back as an eleventh pager.
+  // This is the machine-checkable half: the kit STAMPS every bar at runtime, so any
+  // .pager markup written by hand — in a page's HTML or in another script's template —
+  // is by construction a second implementation. Adding an exception here is where the
+  // conversation happens, exactly like the budgets above.
+  const OWNER = 'hall-kit.js';
+  const offenders = [];
+  for (const f of fs.readdirSync(HALL)) {
+    if (!/\.(html|js)$/.test(f) || f === OWNER) continue;
+    const src = read(f);
+    // `class="pager…"` in a template string or in static markup. The kit's own callers
+    // pass a PREFIX and get the markup back; they never write the class themselves.
+    if (/class="pager[\s"_-]/.test(src)) offenders.push(f);
+  }
+  assert.deepEqual(offenders, [],
+    `${offenders.join(', ')} writes pager markup by hand — call OTBKit.pagerBarHtml(prefix) `
+    + '(or makeLedger, which stamps it for you) instead of a second copy.');
+});
+
+test('the session log pages on the kit — the last hand-roll is gone', () => {
+  // The specific exception this rule carried, pinned by name so its removal cannot be
+  // quietly undone. Behaviour is exercised for real in tests/sessions_kit_pager.mjs;
+  // this is the structural half.
+  const js = read('sessions.js');
+  for (const fn of ['makePager', 'pagerBarHtml', 'wirePager', 'pageOffset', 'renderServerPage']) {
+    assert.match(js, new RegExp(`kit\\.${fn}\\(`), `sessions.js must page through the kit's ${fn}`);
+  }
+  assert.doesNotMatch(js, /const PAGE_SIZE\b/, 'its fixed page size is gone — per-page is the kit\'s now');
+  assert.match(read('sessions.html'), /hall-kit\.js/, 'and the page has to load the kit');
+});
+
 test('the peer-recognition feed is paged through OTBKit, not by hand', () => {
   assert.match(read('hall-widgets.js'), /pagerBarHtml\('acclaim'/, 'the acclaim card stamps the kit pager bar');
   const js = read('builders.js');

package/tests/promote_goal_id.mjs

@@ -294,7 +294,10 @@ await test('DEGRADES: the hall re-fetches goals when the version changes, newest
   // Goals belong to a version; keeping stale options would offer a home the
   // server would reject.
   assert.match(HALL, /vsel\.addEventListener\('change'/);
-  assert.match(HALL, /await goalOptionsFor\(vsel\.value\)/);
+  // The second argument (task 1003516) scopes the filed goal hint to the version
+  // it was filed against — matched loosely so this pins the re-fetch, not the
+  // argument list.
+  assert.match(HALL, /await goalOptionsFor\(vsel\.value/);
 });
 
 await test('the CLI uses the GENERATED typed client method, not the raw escape hatch', () => {