@bongos/core 1.21.19 → 1.21.21

package/tests/hall_audit.mjs

@@ -375,18 +375,13 @@ test('the module doc still records where the 2179 density pass landed', () => {
 // else is on the page but the wordmark, a sun/moon switch, start governing and
 // one line. It still loads style.css (the hall's tokens, so no private palette:
 // city.css spends var(--bg), var(--ink), var(--accent) …), and reads and writes
-// the hall's own 'hall-theme' preference. Whether it should join the chrome
-// behind the full-screen switch, as the sky did in task 1004327, is the
-// owner's call, named in that task's ship notes.
-// THE STREET (task 1004525) follows the city, for the same reason: the
-// reference design's street view shows nothing on the page but its own header
-// (the wordmark back to the city, needs you, moving, your share, the switch),
-// the street and the six readings. Same terms as the city: style.css and the
-// hall's tokens, the hall's own 'hall-theme' preference, no private palette.
-const STANDALONE_EXEMPT = {
-  'city.html': 'the governor city home: nothing on the page but the prototype home (task 1004524)',
-  'street.html': 'the governor street: nothing on the page but the prototype street view (task 1004525)',
-};
+// the hall's own 'hall-theme' preference. THE STREET (task 1004525) followed
+// it for the same reason. Both left this list in task 1004544 (owner decision
+// 2026-10-02): they sit in the hall chrome now, behind the shell's full-screen
+// switch, exactly as the sky did in task 1004327, so the list is empty again.
+// Neither has a sidebar link (the owner's call): the city is reached by URL and
+// the street from the city's start governing.
+const STANDALONE_EXEMPT = {};
 
 test('every hall page loads style.css and shell.js', () => {
   const missing = [];

package/tests/hall_city.mjs

@@ -241,10 +241,27 @@ test('the page holds only the wordmark, the switch, the city, one button and one
   assert.equal((html.match(/<a\b/g) || []).length, 1, 'one door');
   assert.equal((html.match(/<button\b/g) || []).length, 1, 'one switch');
   assert.match(html, /class="city-mark">\{\{productName\}\}</);
-  assert.doesNotMatch(html, /app-sidebar|shell\.js/, 'no hall chrome on the city');
   assert.equal(City.STREET_HREF, '/builders/street');
 });
 
+// task 1004544 (owner decision 2026-10-02): the city sits in the hall chrome
+// behind the shell's full-screen switch, the sky's mechanism (task 1004327),
+// and still has no sidebar link.
+test('the city sits in the hall chrome, behind the shell\'s full-screen switch', () => {
+  const html = read('city.html').replace(/<!--[\s\S]*?-->/g, '');
+  assert.match(html, /<body data-page="city"[^>]*\sdata-fullscreen-switch>/, 'the bare attribute: the page lays itself out for full screen');
+  for (const id of ['app-sidebar', 'app-scrim', 'app-topbar']) assert.match(html, new RegExp(`id="${id}"`), id);
+  assert.match(html, /<main id="hall-main" class="city-main">\s*<div class="city-top">/, 'the stage is the one <main>, the strip inside it');
+  const scripts = [...html.matchAll(/<script src="\/builders\/([a-z-]+)\.js/g)].map((m) => m[1]);
+  assert.deepEqual(scripts, ['shell', 'palette', 'city-draw', 'city'], 'the shell first, as on every hall page');
+  const css = read('city.css').replace(/\/\*[\s\S]*?\*\//g, '');
+  assert.match(css, /\.city-main \{ position: fixed; top: var\(--topbar-h, 56px\); left: var\(--sidebar-w-rail, 64px\);[^}]*contain: layout paint;/);
+  assert.match(css, /html\[data-fullscreen="on"\] \.city-main \{ top: 0; left: 0; \}/);
+  assert.match(css, /html\[data-fullscreen="on"\] \.city-top \{ right: 184px; \}/, 'the strip steps clear of the corner exit');
+  const shell = read('shell.js');
+  assert.doesNotMatch(shell, /href:\s*'(\/builders)?\/(city|street)'/, 'no sidebar link (owner: leave it off the sidebar)');
+});
+
 test('motion is CSS only and dies under reduced motion; no page :root; no innerHTML', () => {
   const css = read('city.css').replace(/\/\*[\s\S]*?\*\//g, '');
   assert.doesNotMatch(css, /:root/);
@@ -293,7 +310,7 @@ function fakeDom() {
   return { document, byId, html };
 }
 
-async function bootPage({ feeds = {}, stored = null, osDark = true } = {}) {
+async function bootPage({ feeds = {}, stored = null, osDark = true, shell = undefined, stage = null } = {}) {
   const { document, byId, html } = fakeDom();
   const store = new Map(stored ? [['hall-theme', stored]] : []);
   const calls = [];
@@ -308,14 +325,18 @@ async function bootPage({ feeds = {}, stored = null, osDark = true } = {}) {
     const body = feeds[url];
     return Promise.resolve(body === undefined ? { ok: false, json: async () => ({}) } : { ok: true, json: async () => body });
   };
-  const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, console });
+  const observers = [];
+  class MutationObserver { constructor(fn) { this.fn = fn; observers.push(this); } observe() {} }
+  window.OTBShell = shell;
+  if (stage) { const m = document.createElement('main'); m.setAttribute('id', 'hall-main'); Object.assign(m, stage); }
+  const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, console, MutationObserver });
   ctx.globalThis = ctx;
   window.GovCity = undefined;
   vm.runInContext(read('city-draw.js'), ctx);
   window.GovCity = ctx.GovCity || ctx.window.GovCity;
   vm.runInContext(read('city.js'), ctx);
   await window.GovCityPage.ready;
-  return { window, byId, html, store, calls };
+  return { window, byId, html, store, calls, observers };
 }
 
 const FEEDS = (ms, goals = [goal(1)], rollups = [rollup(1, { done: 2, active: 1 })]) => ({
@@ -363,6 +384,25 @@ test('the switch reads and writes the hall\'s own theme preference', async () =>
   assert.equal(q.html.attrs['data-theme'], 'dark', 'no stored choice follows the OS');
 });
 
+test('in the hall, the city and the top bar\'s theme switch never disagree (task 1004544)', async () => {
+  let shellPaints = 0;
+  const p = await bootPage({ feeds: FEEDS([]), stored: 'light', osDark: true, shell: { applyTheme() { shellPaints++; } } });
+  assert.equal(p.observers.length, 1, 'the page watches html[data-theme]');
+  p.byId.get('cityMode').fire('click');
+  assert.equal(shellPaints, 1, 'this switch repaints the shell\'s');
+  const before = JSON.stringify(p.byId.get('cityFlat').children[0].attrs);
+  p.store.set('hall-theme', 'light'); p.html.setAttribute('data-theme', 'light'); // the shell's switch
+  p.observers[0].fn();
+  assert.equal(p.byId.get('cityMode').attrs['aria-label'], 'Switch to dark mode', 'this switch follows the shell\'s');
+  assert.notEqual(JSON.stringify(p.byId.get('cityFlat').children[0].attrs), before, 'and the city redraws in that mode');
+  assert.equal(shellPaints, 1, 'following the shell does not echo back to it');
+});
+
+test('the artboard fits the stage the hall chrome leaves, not the window (task 1004544)', async () => {
+  const p = await bootPage({ feeds: FEEDS([]), stage: { clientWidth: 688, clientHeight: 900 } });
+  assert.equal(p.byId.get('cityStage').style['--city-scale'], '0.688');
+});
+
 test('docket text lands as text: a title with markup is never parsed', async () => {
   const p = await bootPage({ feeds: FEEDS([matter({ title: '<img src=x onerror=alert(1)>', short: '<b>x</b>' })]) });
   assert.equal(p.byId.get('cityPins').children.length, 1);

package/tests/hall_street.mjs

@@ -375,12 +375,27 @@ test('the page holds the prototype\'s header, the street, the readings and the c
   assert.equal((html.match(/<h1\b/g) || []).length, 1);
   assert.match(html, /<a class="street-mark" id="streetHome" href="\/builders\/city"[^>]*>\{\{productName\}\}</);
   for (const id of ['hudNeeds', 'hudMoving', 'hudShare', 'streetMode', 'streetSigns', 'streetPins', 'streetDoors', 'streetCard']) assert.match(html, new RegExp(`id="${id}"`), id);
-  assert.doesNotMatch(html, /app-sidebar|shell\.js/, 'no hall chrome, as the city');
   const scripts = [...html.matchAll(/<script src="\/builders\/([a-z-]+)\.js/g)].map((m) => m[1]);
-  assert.deepEqual(scripts, ['city-draw', 'street-draw', 'street-card', 'street-inside', 'street-amend', 'street'], 'the shared kit loads first, then the card (task 1004528), the interiors (task 1004526) and the drafted amendment (task 1004530)');
+  assert.deepEqual(scripts, ['shell', 'palette', 'city-draw', 'street-draw', 'street-card', 'street-inside', 'street-amend', 'street'], 'the hall shell (task 1004544), the shared kit, then the card (task 1004528), the interiors (task 1004526) and the drafted amendment (task 1004530)');
   assert.equal(City.STREET_HREF, '/builders/street', 'the city\'s door is this page');
 });
 
+// task 1004544 (owner decision 2026-10-02): the street sits in the hall chrome
+// behind the shell's full-screen switch, as the city and the sky (task 1004327),
+// and still has no sidebar link.
+test('the street sits in the hall chrome, behind the shell\'s full-screen switch', () => {
+  const html = read('street.html').replace(/<!--[\s\S]*?-->/g, '');
+  assert.match(html, /<body data-page="street"[^>]*\sdata-fullscreen-switch>/, 'the bare attribute: the page lays itself out for full screen');
+  for (const id of ['app-sidebar', 'app-scrim', 'app-topbar']) assert.match(html, new RegExp(`id="${id}"`), id);
+  assert.match(html, /<main id="hall-main" class="street-stage">\s*<div class="street-top">/, 'the stage is the one <main>, the strip inside it');
+  assert.match(html, /<div class="street-window" id="streetWindow">/, 'the street band is a <div> inside the stage');
+  const css = read('street.css').replace(/\/\*[\s\S]*?\*\//g, '');
+  assert.match(css, /\.street-stage \{ position: fixed; top: var\(--topbar-h, 56px\); left: var\(--sidebar-w-rail, 64px\);[^}]*contain: layout paint;/);
+  assert.match(css, /html\[data-fullscreen="on"\] \.street-stage \{ top: 0; left: 0; \}/);
+  assert.match(css, /html\[data-fullscreen="on"\] \.street-top \{ padding-right: 184px; \}/, 'the strip steps clear of the corner exit');
+  assert.doesNotMatch(read('shell.js'), /href:\s*'(\/builders)?\/(city|street)'/, 'no sidebar link (owner: leave it off the sidebar)');
+});
+
 test('motion is CSS only and dies under reduced motion; no page :root; no innerHTML', () => {
   const css = read('street.css').replace(/\/\*[\s\S]*?\*\//g, '');
   assert.doesNotMatch(css, /:root/);
@@ -428,7 +443,7 @@ function fakeDom() {
   return { document, byId, html, focused };
 }
 
-async function bootPage({ feeds = {}, stored = null, osDark = true, hash = '' } = {}) {
+async function bootPage({ feeds = {}, stored = null, osDark = true, hash = '', shell = undefined } = {}) {
   const { document, byId, html, focused } = fakeDom();
   const store = new Map(stored ? [['hall-theme', stored]] : []);
   const calls = [];
@@ -444,7 +459,10 @@ async function bootPage({ feeds = {}, stored = null, osDark = true, hash = '' }
     const body = feeds[url];
     return Promise.resolve(body === undefined ? { ok: false, json: async () => ({}) } : { ok: true, json: async () => body });
   };
-  const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, Date, console, encodeURIComponent, decodeURIComponent, isNaN });
+  const observers = [];
+  class MutationObserver { constructor(fn) { this.fn = fn; observers.push(this); } observe() {} }
+  window.OTBShell = shell;
+  const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, Date, console, encodeURIComponent, decodeURIComponent, isNaN, MutationObserver });
   ctx.globalThis = ctx;
   // each file hangs its api on `window`, as the browser loads them
   vm.runInContext(read('city-draw.js'), ctx);
@@ -453,7 +471,7 @@ async function bootPage({ feeds = {}, stored = null, osDark = true, hash = '' }
   vm.runInContext(read('street.js'), ctx);
   await window.GovStreetPage.ready;
   const key = (t, e) => (listeners[t] || []).forEach((fn) => fn(e));
-  return { window, byId, html, store, calls, key, focused };
+  return { window, byId, html, store, calls, key, focused, observers };
 }
 
 const FEEDS = (ms, goals = [goal(1)], rollups = [rollup(1, { done: 2, active: 1 })]) => ({
@@ -509,6 +527,20 @@ test('the switch reads and writes the hall\'s own theme preference and redraws t
   assert.notEqual(JSON.stringify(p.byId.get('streetBlds').children[0].children[0].attrs), before, 'the street redraws in the new mode');
 });
 
+test('in the hall, the street and the top bar\'s theme switch never disagree (task 1004544)', async () => {
+  let shellPaints = 0;
+  const p = await bootPage({ feeds: FEEDS([]), stored: 'light', osDark: true, shell: { applyTheme() { shellPaints++; } } });
+  assert.equal(p.observers.length, 1, 'the page watches html[data-theme]');
+  p.byId.get('streetMode').fire('click');
+  assert.equal(shellPaints, 1, 'this switch repaints the shell\'s');
+  const before = JSON.stringify(p.byId.get('streetBlds').children[0].children[0].attrs);
+  p.store.set('hall-theme', 'light'); p.html.setAttribute('data-theme', 'light'); // the shell's switch
+  p.observers[0].fn();
+  assert.equal(p.byId.get('streetModeWord').textContent, 'dark', 'this switch follows the shell\'s');
+  assert.notEqual(JSON.stringify(p.byId.get('streetBlds').children[0].children[0].attrs), before, 'and the street redraws in that mode');
+  assert.equal(shellPaints, 1, 'following the shell does not echo back to it');
+});
+
 test('arriving through a door marks that building, and a failed docket says so', async () => {
   const p = await bootPage({ feeds: FEEDS([]), hash: '#building=treasury' });
   const here = p.byId.get('streetDoors').children.filter((a) => a.attrs['aria-current'] === 'location');

package/tests/hall_street_inside.mjs

@@ -68,6 +68,8 @@ function docket(matters = [], over = {}) {
   };
 }
 const goal = (id, status = 'open', title = `Goal ${id}`) => ({ id: String(id), title, status });
+// a docket floor row in the route's shape (docket.js buildDocket `floors`)
+const floorRow = (key, over = {}) => ({ key, building: key.split('.')[0], status: 'live', count: '3', line: 'three things', lines: [['One thing.', 'today']], hot: false, reason: null, ...over });
 
 // ── the drawing is the prototype's ───────────────────────────────────────────
 
@@ -176,10 +178,12 @@ test('each building keeps the prototype\'s capacity, words and floor order', ()
 
 // ── what a floor says comes from the docket, and only from it ───────────────
 
-test('a floor no feed reads stands as not recorded yet: faint, no number, and says so', () => {
-  const b = I.civicInfo('charter', { docket: docket(), goals: [], now: NOW });
+test('a floor whose engine is coming stands as not recorded yet: faint, no number, and says so', () => {
+  const coming = docket([], { floors: I.PLAN.charter.floors.map((f) => floorRow(f[2].floor, { status: 'coming', count: '', lines: [], reason: 'Not yet.' })) });
+  const b = I.civicInfo('charter', { docket: coming, goals: [], now: NOW });
   assert.ok(b.floors.every((f) => f.status === 'coming' && f.count === ''), 'nothing on the charter is read yet');
-  const bv = I.buildingModel({ key: 'charter', docket: docket(), mode: 'dark', now: NOW });
+  assert.deepEqual(b.floors[1].lines, [['Not yet.', 'coming']], 'it says why, in the docket\'s words');
+  const bv = I.buildingModel({ key: 'charter', docket: coming, mode: 'dark', now: NOW });
   const quiet = bv.texts.filter((t) => t.v === 'not recorded yet');
   assert.equal(quiet.length, 8, 'every used floor says it on the wall');
   assert.ok(bv.texts.filter((t) => t.s === 14.5).every((t) => t.c === '#8e8e93'), 'its name lettered faint, like a proposed floor');
@@ -265,6 +269,96 @@ test('who holds it: the docket\'s holders when it names them, else an empty seat
   assert.deepEqual([held.seats, held.who, held.how], [['M'], 'Mira, treasurer', 'more than half must say yes']);
 });
 
+// ── real data on every floor (task 1004527) ─────────────────────────────────
+
+test('every floor of every building is bound to a docket feed: none is left unwired', () => {
+  for (const key of S.CIVIC_KEYS) {
+    for (const [name, , bind] of I.PLAN[key].floors) {
+      assert.ok(bind && (bind.floor || bind.source || bind.reading || bind.goals), `${key} · ${name} reads something`);
+    }
+  }
+});
+
+test('a live floor shows exactly what the docket says: its count, line and lines; hot is being decided', () => {
+  const d = docket([], { floors: [
+    floorRow('treasury.rewards', { count: '$2,400', line: '$2,400 this month · 6 builders', lines: [['Paid to builders for shipped work.', 'each ship']] }),
+    floorRow('automation.allowed_goals', { count: '2', line: '2 goals it may build', lines: [['goal 7', 'first in line'], ['goal 99', 'since sep 2']] }),
+    floorRow('charter.founding', { count: '', line: '1 of 2 founding steps passed', lines: [['The charter.', 'passed']], hot: true }),
+  ] });
+  const t = I.civicInfo('treasury', { docket: d, now: NOW }).floors.find((f) => f.name === 'Builder rewards');
+  assert.deepEqual([t.count, t.line, t.status, t.lines], ['$2,400', '$2,400 this month · 6 builders', 'ok', [['Paid to builders for shipped work.', 'each ship']]]);
+  const a = I.civicInfo('automation', { docket: d, goals: [goal(7, 'open', 'Onboarding')], now: NOW }).floors.find((f) => f.name === 'Allowed goals');
+  assert.deepEqual(a.lines, [['Onboarding', 'first in line'], ['goal 99', 'since sep 2']], 'a goal it knows is lettered by title; one it does not keeps its id');
+  const c = I.buildingModel({ key: 'charter', docket: d, mode: 'dark', now: NOW });
+  assert.equal(c.selFloor, 0, 'a founding step being decided is the floor chosen first');
+  assert.equal(c.openKicker, 'floor 1 · being decided');
+});
+
+test('Rules in force: each rule and what it settled, from its floor; the reading when the floor is absent', () => {
+  const d = docket([], { floors: [floorRow('rules.in_force', { count: '1', line: '1 rule · settled 18 this month', lines: [['Every filing lands in its goal without a vote.', 'settled 18']] })] });
+  const f = I.civicInfo('rules', { docket: d, now: NOW }).floors[0];
+  assert.deepEqual([f.count, f.line, f.lines[0]], ['1', '1 rule · settled 18 this month', ['Every filing lands in its goal without a vote.', 'settled 18']]);
+  const old = docket();
+  Object.assign(old.readings.find((r) => r.key === 'rules'), { status: 'live', figure: '1 rule', line: 'the landing rule settled 4 filings this month' });
+  assert.deepEqual(I.civicInfo('rules', { docket: old, now: NOW }).floors[0].count, '1', 'an older docket still reads the reading');
+  const h = I.holderOf('people', { decision: { who: 'metic', rule: 'consent' }, holders: [], holder_count: 3 }, []);
+  assert.equal(h.who, 'metic', 'a count with no names never letters undefined');
+});
+
+test('a floor the docket cannot answer never shows a number; Goals falls back to the open goals', () => {
+  const d = docket([], { floors: [floorRow('people.ranks', { status: 'not_yours', count: '9' }), floorRow('people.council', { status: 'off', count: '5', reason: 'Off here.' }), floorRow('people.newcomers', { status: 'unavailable', count: '2' })] });
+  const by = Object.fromEntries(I.civicInfo('people', { docket: d, now: NOW }).floors.map((f) => [f.name, f]));
+  for (const [n, st] of [['Ranks', 'not_yours'], ['The council', 'off'], ['Newcomers', 'unavailable'], ['Testers', 'unavailable']]) {
+    assert.deepEqual([by[n].status, by[n].count], [st, ''], `${n} says ${st} and no number`);
+  }
+  const g = I.civicInfo('planning', { docket: docket(), goals: [goal(1), goal(2)], now: NOW }).floors[0];
+  assert.deepEqual([g.count, g.line], ['2', '2 goals open'], 'an older docket without floors still counts the open goals');
+  const live = I.civicInfo('planning', { docket: docket([], { floors: [floorRow('planning.goals', { count: '1', line: '1 goal open', lines: [['Hall', '5 of 5 kept']] })] }), goals: [goal(1), goal(2)], now: NOW }).floors[0];
+  assert.deepEqual([live.count, live.lines], ['1', [['Hall', '5 of 5 kept']]], 'with the floor, its promises kept of total');
+});
+
+test('no made-up number: every count on every wall is one the docket sent', () => {
+  const ms = [matter({ id: 'access_requests:1', source: 'access_requests', building: 'people' })];
+  const floors = [floorRow('people.ranks', { count: '4' }), floorRow('treasury.hosting', { count: '$120' }), floorRow('release.live_month', { count: '7' })];
+  const d = docket(ms, { floors });
+  Object.assign(d.readings.find((r) => r.key === 'money'), { status: 'live', figure: '$1,100 left', line: 'left' });
+  const sent = new Set(['', ...floors.map((f) => f.count), '1', '0', '$1,100']);
+  for (const key of S.CIVIC_KEYS) {
+    for (const f of I.civicInfo(key, { docket: d, goals: [], now: NOW }).floors) assert.ok(sent.has(f.count), `${key} · ${f.name} shows ${f.count}`);
+  }
+});
+
+test('who holds it reads the decision table: the people it seats, its rule, you, and a vacant seat', () => {
+  const info = { key: 'release', decision: { who: 'whoever may put a release live', rule: 'decide', rule_words: 'decides alone', as_today: true }, holders: [{ id: '95', name: 'Ana' }, { id: '7', login: 'theo' }], holder_count: 2 };
+  const h = I.holderOf('release', info, [], '95');
+  assert.deepEqual([h.seats, h.who, h.rule, h.how], [['you', 'T'], 'Ana and theo · whoever may put a release live', 'decide', 'one person decides']);
+  const many = I.holderOf('people', { decision: { who: 'metic and above', rule: 'consent' }, holders: [{ name: 'A' }, { name: 'B' }, { name: 'C' }], holder_count: 7 }, []);
+  assert.equal(many.who, 'A, B, C and 4 more · metic and above');
+  const vacant = I.holderOf('review', { decision: { who: 'no one yet', rule: 'vacant' }, holders: [] }, []);
+  assert.deepEqual([vacant.seats, vacant.who, vacant.how], [['—'], 'no one holds it yet', 'its matters wait until a seat is filled']);
+  const d = docket();
+  d.buildings.find((b) => b.key === 'review').decision = { who: 'no one yet', rule: 'vacant' };
+  assert.equal(I.civicInfo('review', { docket: d, now: NOW }).vacant, true, 'a vacant row is an unheld Review');
+  const held = I.civicInfo('review', { docket: docket(), now: NOW });
+  assert.deepEqual(held.floors.map((f) => f.name), ['Testers', 'Being tested', 'Signed off'], 'held, its queue is the prototype\'s Being tested');
+});
+
+test('the record drawers read the real history by month, file a sitting once, and cap a full drawer', () => {
+  const history = [
+    { id: 'government:amendment:12', source: 'government', building: 'charter', title: '§6 Review: testers hold the seat', at: '2026-10-01T09:00:00.000Z', outcome: 'passed' },
+    { id: 'government:founding:3', source: 'government', building: 'charter', title: 'Founding: the charter', at: '2026-07-04T09:00:00.000Z', outcome: 'passed' },
+    { id: 'releases:9', source: 'releases', building: 'release', title: 'Invite flow', at: '2026-09-26T09:00:00.000Z', outcome: 'live' },
+  ];
+  const ms = [matter({ id: 'board:12', source: 'board', building: 'charter', state: 'settled', title: '§6 Review: testers hold the seat', ref: { type: 'board_item', id: '12' }, opened_at: '2026-09-28T00:00:00.000Z' })];
+  const m = I.buildingModel({ key: 'charter', docket: docket(ms, { history }), mode: 'dark', now: NOW });
+  assert.deepEqual(m.drawers.map((x) => [x.label, x.count]), [['oct', 1], ['jul', 1]], 'the settled sitting is filed once, by when it closed');
+  assert.deepEqual(m.drawerItems.map((x) => [x.text, x.meta]), [['§6 Review: testers hold the seat', 'passed']]);
+  assert.equal(m.onFile, '1 matter on the docket · 2 on the record');
+  const lots = Array.from({ length: 15 }, (_, i) => ({ id: `releases:${i}`, building: 'release', title: `R${i}`, at: '2026-09-02T00:00:00.000Z', outcome: 'live' }));
+  const r = I.recordOf([], NOW, lots);
+  assert.deepEqual([r[0].count, r[0].items.length, r[0].items[12]], [15, 13, ['and 3 more', '']]);
+});
+
 test('the annex lot stands only when the building is full; an unheld Review is the dashed ghost', () => {
   assert.equal(I.buildingModel({ key: 'charter', docket: docket(), mode: 'dark', now: NOW }).hasAnnex, false, '8 of 9');
   const save = I.PLAN.rules.cap;

package/tests/hall_tweak_editor.mjs

@@ -635,7 +635,7 @@ try {
     assert.match(HTML, /<body data-page="tweak-editor"[^>]*data-fullscreen-switch/);
     assert.equal((HTML.match(/<h1\b/g) || []).length, 1);
     assert.ok(HTML.indexOf('tweak-editor-lib.js') < HTML.indexOf('tweak-editor.js?'), 'the lib loads first');
-    assert.match(HTML, /shell\.js\?v=2026-10-01-look/);
+    assert.match(HTML, /shell\.js\?v=2026-10-02-theme/);
     assert.equal(/fonts\.googleapis\.com\/css/.test(HTML), false);
     for (const id of ['tw-bar', 'tw-counter', 'tw-open', 'tw-open-more', 'tw-divider', 'tw-openwrap', 'tw-open-menu', 'tw-open-tab', 'tw-open-split', 'tw-frame', 'tw-frame-view', 'tw-split-close', 'tw-download', 'tw-upload', 'tw-file', 'tw-submit', 'tw-paper', 'tw-doc', 'tw-notice', 'tw-done', 'tw-take', 'tw-pick', 'tw-picks', 'tw-refused', 'tw-refused-title', 'tw-refused-list', 'tw-refused-next', 'tw-refused-download', 'tw-refused-close']) {
       assert.ok(new RegExp(`id="${id}"`).test(HTML), `#${id} is in the markup`);

package/tests/nav_permission_atoms.mjs

@@ -87,7 +87,7 @@ test('the hall-preview fixture carries every atom /me resolves', () => {
 // the file and left the query alone, so a returning browser kept the cached copy —
 // a fix that reaches nobody looks identical to a fix that does not work.
 
-const SHELL_SHA = '51a13ea563542113';
+const SHELL_SHA = 'a8dc2884930ca19a';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);