@bongos/core 1.21.32 → 1.21.34

package/tests/hall_matter_card.mjs

@@ -258,7 +258,7 @@ async function bootPage({ feeds, posts = {} }) {
   };
   const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, Date, console, encodeURIComponent, decodeURIComponent, isNaN, isFinite });
   ctx.globalThis = ctx;
-  for (const f of ['city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street.js']) vm.runInContext(read(f), ctx);
+  for (const f of ['city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street-desk.js', 'street.js']) vm.runInContext(read(f), ctx);
   await window.GovStreetPage.ready;
   return { window, byId, calls, focused };
 }

package/tests/hall_street.mjs

@@ -376,7 +376,7 @@ test('the page holds the prototype\'s header, the street, the readings and the c
   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);
   const scripts = [...html.matchAll(/<script src="\/builders\/([a-z-]+)\.js/g)].map((m) => m[1]);
-  assert.deepEqual(scripts, ['shell-trail', 'craft-mode', '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.deepEqual(scripts, ['shell-trail', 'craft-mode', 'shell', 'palette', 'city-draw', 'street-draw', 'street-card', 'street-inside', 'street-desk', 'street-amend', 'street'], 'the hall shell (task 1004544), the shared kit, then the card (task 1004528), the interiors (task 1004526), the floor desk (task 1004558) and the drafted amendment (task 1004530)');
   assert.equal(City.STREET_HREF, '/builders/street', 'the city\'s door is this page');
 });
 

package/tests/hall_street_amend.mjs

@@ -253,7 +253,7 @@ async function bootPage({ hash = '#building=review', cons = constitution(), answ
   };
   const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, Date, console, encodeURIComponent, decodeURIComponent, isNaN, isFinite, Map, setTimeout, clearTimeout });
   ctx.globalThis = ctx;
-  for (const f of ['city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street-amend.js', 'street.js']) vm.runInContext(read(f), ctx);
+  for (const f of ['city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street-desk.js', 'street-amend.js', 'street.js']) vm.runInContext(read(f), ctx);
   await window.GovStreetPage.ready;
   await tick();
   return { window, byId, focused, gets, posts, history };

package/tests/hall_street_desk.mjs

@@ -0,0 +1,328 @@
+// tests/hall_street_desk.mjs — THE FLOOR DESK AND THE LINE RULE (task 1004558,
+// goal 1000125; round 2 of the Governor City).
+//
+// WHAT IT GUARDS. The chosen floor of a building is the desk from the round 2
+// board (docs/design/mocks/governor-city/Desks.dc.html), built by
+// GovDesk.deskModel() (street-desk.js) and drawn by street.js. What can go wrong:
+//   * THE LINE RULE breaking on real data: a row name over three words, a
+//     second fact, a third button, a tile that reads zero or carries a
+//     sentence, a status that is orange when nothing needs you, an empty list
+//     where a quiet floor should be one lit line. Pinned by running EVERY
+//     building and EVERY floor of a deliberately long-winded docket through
+//     GovDesk.breaks() — the test that fails when the docket produces a line
+//     the rule does not allow;
+//   * fit() drifting from the board's own fit() (run from the board's
+//     Component class) or the limits drifting from the board's numbers;
+//   * a row's button sending anything but the matter card's own request to
+//     the existing route, or a reason arriving as free text instead of a chip;
+//   * the game layer going quiet: the act that does not clear its row, count a
+//     pip on the today meter, light the cleared floor with a tick, or say a toast.
+//
+// Run:  node --test tests/hall_street_desk.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const PUB = path.join(ROOT, 'modules/hall-ui/public');
+const require = createRequire(import.meta.url);
+require(path.join(PUB, 'city-draw.js'));
+const S = require(path.join(PUB, 'street-draw.js'));
+const I = require(path.join(PUB, 'street-inside.js'));
+const C = require(path.join(PUB, 'street-card.js'));
+const D = require(path.join(PUB, 'street-desk.js'));
+const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8');
+const NOW = Date.parse('2026-10-03T12:00:00.000Z');
+const j = (v) => JSON.parse(JSON.stringify(v));
+
+// the board's own Component class, run beside the desk
+function board() {
+  const src = fs.readFileSync(path.join(ROOT, 'docs/design/mocks/governor-city/Desks.dc.html'), 'utf8');
+  const script = src.split('data-dc-script')[1].split('>').slice(1).join('>').split('</script>')[0];
+  const DCLogic = class { constructor(p) { this.props = p || {}; this.state = {}; } setState(s) { Object.assign(this.state, s); } };
+  const Comp = new Function('DCLogic', 'setTimeout', 'clearTimeout', `${script}\nreturn Component;`)(DCLogic, () => 0, () => {});
+  return new Comp({ mode: 'dark' });
+}
+
+// ── a long-winded docket: every source, long words everywhere ─────────────────
+const LONG = 'The extraordinarily long-winded proposal to reorganise every single floor of the hall before winter';
+const SOURCES = [['board', 'charter'], ['blockers', 'planning'], ['access_requests', 'people'], ['goal_join_requests', 'people'], ['override_requests', 'release'], ['removal_proposals', 'disputes'], ['redteam_reports', 'disputes'], ['criteria_uat', 'review'], ['core_update', 'release'], ['gate_approvals', 'release'], ['autobongos_fence', 'automation'], ['module_rechecks', 'release'], ['grade_appeals', 'disputes'], ['standing_rules', 'rules'], ['treasury_spending', 'treasury']];
+function matter(over = {}) {
+  return { id: 'blockers:1', source: 'blockers', building: 'planning', rule: 'majority', state: 'needs', title: 'A matter', short: 'a matter', where: 'Planning', opened_at: '2026-09-29T10:00:00.000Z', deadline: null, proposer: null, tally: null, href: null, ref: null, ...over };
+}
+function docket(matters, over = {}) {
+  const counts = { needs: 0, moving: 0, settled: 0 };
+  matters.forEach((m) => { counts[m.state] += 1; });
+  return {
+    viewer: { id: '95' }, counts, line: '', matters,
+    buildings: S.CIVIC_KEYS.map((key) => ({ key, name: key[0].toUpperCase() + key.slice(1), group: '', counts: {}, matter_ids: [] })),
+    sources: SOURCES.map(([source, building]) => ({ source, building, label: source, status: 'live', count: 0, reason: null })),
+    readings: ['flow', 'promises', 'money', 'people', 'fairness', 'rules'].map((key) => ({ key, label: key, building: 'people', status: 'live', value: 0, figure: key === 'money' ? '$1,234,567.89 left this month' : '0 people', line: LONG, hot: false, reason: null })),
+    floors: Object.values(I.PLAN).flatMap((p) => p.floors).map((f) => f[2] && f[2].floor).filter(Boolean).map((key, i) => ({ key, building: key.split('.')[0], status: 'live', count: i % 3 === 0 ? '0' : i % 3 === 1 ? '1,204,331' : '', line: i % 2 ? LONG : '12 things that the floor counts', lines: [[LONG, 'today']], hot: i % 4 === 0, reason: null })),
+    history: S.CIVIC_KEYS.flatMap((b) => [0, 1, 2, 3, 4].map((n) => ({ id: `h:${b}:${n}`, source: 'government', building: b, title: LONG, at: '2026-09-2' + n + 'T10:00:00.000Z', outcome: 'passed after a very long sitting' }))),
+    ...over,
+  };
+}
+function longMatters() {
+  const out = [];
+  let n = 0;
+  for (const [source, building] of SOURCES) {
+    for (const state of ['needs', 'moving', 'settled']) {
+      n += 1;
+      out.push(matter({ id: `${source}:${n}`, source, building, state, title: `${LONG} ${n}`, short: 'a matter with a very long short description', where: 'Somewhere far away in the hall, vouched for by everyone', proposer: { name: 'Maximiliana Theodora Alexandrovna-Wellington III', login: 'maxi' }, deadline: '2026-10-05T10:00:00.000Z', opened_at: `2026-0${(n % 9) + 1}-1${n % 9}T10:00:00.000Z`, href: source === 'goal_join_requests' ? '/builders/goal/42' : source === 'core_update' ? '/settings#software-update' : null, tally: source === 'board' ? { open: 3, needs: 'needs 4 of 5' } : null }));
+    }
+  }
+  out.push(matter({ id: 'board:900', source: 'board', building: 'planning', short: 'idea to ratify', title: LONG, state: 'needs' }));
+  return out;
+}
+const ROOM = { open: [{ id: '1', subject_type: 'constitutional_amendment', subject: { title: LONG, author_id: '7' }, votes: [] }, { id: '900', subject_type: 'full_idea', subject: { title: LONG }, votes: [] }], closed: [] };
+
+function everyDesk(dk, extra = {}) {
+  const out = [];
+  for (const key of S.CIVIC_KEYS) {
+    I.PLAN[key].floors.forEach((_f, floor) => out.push(D.deskModel({ key, floor, docket: dk, goals: [{ id: '1', title: LONG, status: 'open' }], now: NOW, room: ROOM, viewerId: '95', ...extra })));
+  }
+  return out;
+}
+
+// ── the line rule ─────────────────────────────────────────────────────────────
+
+test('fit() is the board\'s fit(), with a word cap on top', () => {
+  const b = board();
+  for (const [s, n] of [['Governor city', 20], [LONG, 20], [LONG, 44], ['Ana Ruiz', 18], ['exactly twenty chars', 20], ['  spaced   out  ', 30]]) {
+    assert.equal(D.fit(s, n), b.fit(String(s).replace(/\s+/g, ' ').trim(), n), `${s} @ ${n}`);
+  }
+  assert.equal(D.fit('Raise the hosting limit', 20, 3), 'Raise the hosting…', 'a cut by words says so');
+  assert.equal(D.fit('Ana Ruiz', 20, 3), 'Ana Ruiz', 'nothing cut, nothing marked');
+  for (const n of [5, 12, 20]) for (const w of [1, 2, 3]) assert.ok(D.fit(LONG, n, w).length <= n, 'never longer than its cap');
+});
+
+test('the limits are the board\'s numbers: name 20, fact 26, facts 24 (three), status 44, record 30 (four), three tiles, ten pips', () => {
+  const L = D.LIMITS;
+  assert.deepEqual([L.name, L.nameWords, L.fact, L.factLen, L.facts, L.actions, L.status, L.recordLen, L.record, L.tiles, L.tileWords, L.todayTarget], [20, 3, 26, 24, 3, 2, 44, 30, 4, 3, 2, 10]);
+  const src = fs.readFileSync(path.join(ROOT, 'docs/design/mocks/governor-city/Desks.dc.html'), 'utf8');
+  for (const pin of ['this.fit(r.t, 20)', 'this.fit(r.f, 26)', 'this.fit(t, 24)', '.slice(0, 3)', "this.fit('nothing needs you · ' + F.quiet, 44)", "this.fit(t + ' · now', 30)", '.slice(0, 4)', 'const target = 10']) assert.ok(src.includes(pin), `the board says ${pin}`);
+});
+
+test('THE LINE RULE: no row, tile or status any docket produces breaks it, on every floor of every building', () => {
+  const dk = docket(longMatters());
+  const desks = everyDesk(dk);
+  assert.equal(desks.length, S.CIVIC_KEYS.reduce((a, k) => a + I.PLAN[k].floors.length, 0));
+  const broken = desks.flatMap((d) => D.breaks(d));
+  assert.deepEqual(broken, []);
+  // the stress docket really reaches every part of the rule
+  const rows = desks.flatMap((d) => d.rows);
+  assert.ok(rows.length >= 30, 'rows were drawn');
+  assert.ok(rows.some((r) => r.actions.length === 2) && rows.some((r) => r.chips) && rows.some((r) => r.wait), 'two buttons, chips and a wait pill were all exercised');
+  assert.ok(desks.some((d) => d.quiet), 'a quiet floor was exercised');
+  assert.ok(desks.some((d) => d.tiles.length === 3), 'three tiles were exercised');
+  assert.ok(desks.some((d) => d.hot), 'an orange status was exercised');
+  const moving = everyDesk(docket(longMatters().filter((m) => m.state !== 'needs')));
+  assert.ok(moving.some((d) => !d.hot && d.rows.length), 'a grey status over rows was exercised');
+  assert.deepEqual(moving.flatMap((d) => D.breaks(d)), []);
+  assert.ok(rows.some((r) => r.name.endsWith('…')), 'a long title was cut, and says so');
+  // the same docket with acts done, floors cleared, and with nothing readable
+  assert.deepEqual(everyDesk(dk, { done: Object.fromEntries(dk.matters.map((m) => [m.id, true])), cleared: true, mine: [LONG, 'let in Ana'], today: 123456 }).flatMap((d) => D.breaks(d)), []);
+  assert.deepEqual(everyDesk(null).flatMap((d) => D.breaks(d)), []);
+  assert.deepEqual(everyDesk(docket([])).flatMap((d) => D.breaks(d)), []);
+});
+
+test('breaks() names every way a desk can break the rule (so the rule test can fail)', () => {
+  const dk = docket(longMatters());
+  const good = D.deskModel({ key: 'people', floor: 4, docket: dk, now: NOW });
+  assert.deepEqual(D.breaks(good), []);
+  const bad = j(good);
+  bad.rows[0].name = 'Four words in here';
+  bad.rows[0].fact = 'x'.repeat(27);
+  bad.rows[0].actions = [{ label: 'a' }, { label: 'b' }, { label: 'c' }];
+  bad.rows[0].facts = ['a', 'b', 'c', 'd'];
+  bad.tiles = [{ v: '0', l: 'need you' }, { v: '3', l: 'three whole words' }, { v: '4', l: 'ok' }, { v: '5', l: 'ok' }];
+  bad.status = 'x'.repeat(45);
+  bad.hot = false;
+  const why = D.breaks(bad).join('\n');
+  for (const w of ['row name', 'row fact', 'more than two buttons', 'row facts', 'tile value', 'tile label', 'more than three tiles', 'status too long', 'orange only when']) assert.match(why, new RegExp(w), w);
+  const empty = j(good); empty.rows = []; empty.quiet = false;
+  assert.match(D.breaks(empty).join(), /quiet and rows disagree/, 'never an empty list');
+});
+
+// ── which matters sit on which floor ──────────────────────────────────────────
+
+test('a floor holds its own source; the ideas floor holds the open ideas; the rest sit at the front desk; settled is the record', () => {
+  const ms = [
+    matter({ id: 'access_requests:1', source: 'access_requests', building: 'people', state: 'needs' }),
+    matter({ id: 'access_requests:2', source: 'access_requests', building: 'people', state: 'settled' }),
+    matter({ id: 'board:5', source: 'board', building: 'people', state: 'needs' }),
+    matter({ id: 'board:6', source: 'board', building: 'planning', short: 'idea to ratify', state: 'moving' }),
+  ];
+  const dk = docket(ms);
+  const at = (k, f) => D.floorMatters(k, f, dk).map((m) => m.id);
+  assert.deepEqual(at('people', 4), ['access_requests:1'], 'Waiting to join: the open request only');
+  assert.deepEqual(at('people', 0), ['board:5'], 'a sitting sits at the front desk');
+  assert.deepEqual(at('planning', 2), ['board:6'], 'Ideas to ratify');
+  assert.deepEqual(at('planning', 0), [], 'an idea is not also at the front desk');
+  assert.equal(D.firstNeeds('people', dk), 0);
+  assert.equal(D.firstNeeds('rules', dk), null);
+});
+
+// ── the acts are the card's own requests ──────────────────────────────────────
+
+test('a row\'s buttons are the card\'s acts under the board\'s words, and send the card\'s own request', () => {
+  const ms = [
+    matter({ id: 'access_requests:11', source: 'access_requests', building: 'people', state: 'needs', proposer: { name: 'Ana Ruiz' }, ref: { id: 11 } }),
+    matter({ id: 'goal_join_requests:12', source: 'goal_join_requests', building: 'people', state: 'needs', proposer: { name: 'Kai Mo' }, href: '/builders/goal/42', ref: { id: 12 } }),
+    matter({ id: 'override_requests:13', source: 'override_requests', building: 'release', state: 'needs', ref: { id: 13 } }),
+    matter({ id: 'gate_approvals:14', source: 'gate_approvals', building: 'release', state: 'needs', ref: { id: 14 } }),
+    matter({ id: 'board:1', source: 'board', building: 'charter', state: 'needs', ref: { type: 'board_item', id: '1' } }),
+  ];
+  const dk = docket(ms);
+  const row = (k, f) => D.rowsFor(k, f, dk, { room: ROOM, now: NOW, viewerId: '95' })[0];
+  const ana = row('people', 4);
+  assert.equal(ana.name, 'Ana Ruiz', 'a person is named by their name');
+  assert.deepEqual(ana.actions.map((a) => [a.key, a.label, a.tone]), [['fine', 'let in', 'primary'], ['refuse', 'not now', 'quiet']]);
+  assert.deepEqual(j(C.request(ana.card, 'fine')), { method: 'PATCH', url: '/api/bongos/access-requests/11', body: { status: 'invited' } });
+  assert.deepEqual(j(C.request(row('people', 6).card, 'refuse')), { method: 'POST', url: '/api/bongos/goals/42/requests/12/respond', body: { action: 'deny' } });
+  const rel = D.rowsFor('release', 0, dk, { now: NOW });
+  assert.deepEqual(rel[0].actions.map((a) => a.label), ['release', 'hold']);
+  assert.equal(C.request(rel[0].card, 'release').url, '/api/bongos/override-requests/13/decide');
+  assert.equal(C.request(D.rowsFor('release', 5, dk, { now: NOW })[0].card, 'release').url, '/api/bongos/gate-approvals/14/approve');
+  // a vote: yes and no, and the no's reason is a chip, never free text
+  const vote = row('charter', 0);
+  assert.deepEqual(vote.actions.map((a) => [a.key, a.label]), [['for', 'yes'], ['object', 'no']]);
+  assert.equal(vote.chips.for, 'object');
+  assert.deepEqual(vote.chips.options.map((c) => c.key), C.SECTIONS.map((s) => s.key), 'every chip is a section the server accepts');
+  const chip = vote.chips.options[0];
+  assert.equal(C.check(vote.card, 'object', chip.input), null, 'one tap is a complete objection');
+  assert.deepEqual(j(C.request(vote.card, 'object', chip.input).body), { direction: 'no', reason_md: chip.input.reason, section_key: 'scope' });
+  // before the sitting is read the row waits, never guesses a ballot
+  assert.equal(D.rowsFor('charter', 0, dk, { now: NOW })[0].wait, 'reading…');
+});
+
+// ── the page: the desk acts in place, and the game layer answers ──────────────
+
+function fakeDom() {
+  const byId = new Map();
+  const focused = { el: null };
+  const mk = (tag) => ({
+    tagName: tag, attrs: {}, kids: [], className: '', listeners: {}, _text: '', hidden: false,
+    style: { setProperty(k, v) { this[k] = v; } },
+    clientWidth: 1440, clientHeight: 708, offsetLeft: 0, scrollLeft: 0, parentNode: null,
+    get children() { const a = this.kids.slice(); a[Symbol.isConcatSpreadable] = false; return a; },
+    get firstChild() { return this.kids[0] || null; },
+    setAttribute(k, v) { this.attrs[k] = String(v); if (k === 'id') byId.set(String(v), this); },
+    getAttribute(k) { return k in this.attrs ? this.attrs[k] : null; },
+    appendChild(c) { this.kids.push(c); c.parentNode = this; return c; },
+    removeChild(c) { this.kids = this.kids.filter((x) => x !== c); return c; },
+    addEventListener(t, fn) { (this.listeners[t] = this.listeners[t] || []).push(fn); },
+    fire(t) { (this.listeners[t] || []).forEach((fn) => fn({ type: t, preventDefault() {} })); },
+    focus() { focused.el = this; },
+    set textContent(v) { this._text = String(v); this.kids = []; },
+    get textContent() { return this._text; },
+    get innerHTML() { throw new Error('no innerHTML'); },
+    set innerHTML(v) { throw new Error('no innerHTML'); },
+  });
+  const html = read('street.html').replace(/<!--[\s\S]*?-->/g, '');
+  for (const id of [...html.matchAll(/id="([A-Za-z]+)"/g)].map((m) => m[1])) {
+    const el = mk('x');
+    el.setAttribute('id', id);
+    const tag = new RegExp(`<[^>]*\\bid="${id}"[^>]*>`).exec(html);
+    if (tag && /\shidden(?=[\s>])/.test(tag[0])) el.hidden = true;
+  }
+  return { document: { documentElement: mk('html'), getElementById: (id) => byId.get(id) || null, createElement: (t) => mk(t), createElementNS: (_n, t) => mk(t) }, byId, focused };
+}
+async function bootPage(hash, ms, { refuse = false } = {}) {
+  const { document, byId, focused } = fakeDom();
+  const sent = [];
+  const store = new Map();
+  let matters = ms.slice();
+  const feeds = () => ({ '/api/bongos/government/docket': docket(matters), '/api/bongos/goals': { goals: [] }, '/api/bongos/goals/rollups': { rollups: [] } });
+  const location = { hash, href: '' };
+  const window = {
+    innerWidth: 1440, innerHeight: 900, location,
+    localStorage: { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, String(v)) },
+    matchMedia: () => ({ matches: true, addEventListener() {} }),
+    addEventListener() {}, history: { pushState() {} },
+  };
+  const fetch = (url, init) => {
+    if (init && init.method && init.method !== 'GET') {
+      sent.push({ method: init.method, url, body: JSON.parse(init.body || '{}') });
+      if (refuse) return Promise.resolve({ ok: false, status: 409, json: async () => ({ error: { code: 'not_pending' } }) });
+      matters = matters.filter((m) => !url.includes('/' + String(m.id).split(':')[1]));
+      return Promise.resolve({ ok: true, status: 200, json: async () => ({ ok: 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, Date, console, encodeURIComponent, decodeURIComponent, isNaN, isFinite, Map, Set });
+  ctx.globalThis = ctx;
+  for (const f of ['city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street-desk.js', 'street.js']) vm.runInContext(read(f), ctx);
+  await window.GovStreetPage.ready;
+  await new Promise((r) => setTimeout(r, 0));
+  const deskEl = () => (byId.get('insideOpenA').hidden ? byId.get('insideOpenB') : byId.get('insideOpenA'));
+  const part = (cls) => deskEl().children.find((c) => c.className.split(' ').includes(cls));
+  return { window, byId, focused, sent, store, deskEl, part };
+}
+
+test('the page: the desk acts in place — the row clears, the floor lights with a tick, the meter takes a pip, the toast speaks', async () => {
+  const ms = [matter({ id: 'access_requests:11', source: 'access_requests', building: 'people', state: 'needs', proposer: { name: 'Ana Ruiz' }, ref: { id: 11 }, opened_at: '2026-10-01T12:00:00.000Z' })];
+  const p = await bootPage('#building=people', ms);
+  const html = read('street.html');
+  assert.ok(html.indexOf('/builders/street-desk.js?') > html.indexOf('/builders/street-inside.js?') && html.indexOf('/builders/street-desk.js?') < html.indexOf('/builders/street.js?'), 'the desk loads after the interior and before the page');
+  assert.equal(p.byId.get('insideFloors').children[4].attrs['aria-pressed'], 'true', 'the building opens on the floor that needs you');
+  const head = p.deskEl().children[0].children[1];
+  assert.deepEqual([head.children[1].textContent, head.children[2].textContent, head.children[2].className], ['Waiting to join', '1 waiting · oldest 2 days', 'desk-status desk-status--hot']);
+  assert.deepEqual(p.part('desk-tiles').children.map((t) => [t.children[0].textContent, t.children[1].textContent]), [['1', 'waiting'], ['5', 'on record']], 'the first tile is the count in the floor noun, as on the board; a zero tile (nothing moving) is hidden');
+  const row = p.part('desk-rows').children[0];
+  const name = row.children[0].children[1];
+  assert.equal(name.children[0].textContent, 'Ana Ruiz');
+  name.fire('click');
+  const opened = p.part('desk-rows').children[0];
+  assert.equal(opened.children[0].children[1].attrs['aria-expanded'], 'true');
+  assert.ok(opened.children[1].children.length >= 1 && opened.children[1].children.length <= 3, 'at most three facts open in place');
+  const acts = opened.children[0].children[2].children;
+  assert.deepEqual(acts.map((b) => b.textContent), ['not now', 'let in'], 'the primary sits rightmost');
+  acts[1].fire('click');
+  for (let i = 0; i < 5; i++) await new Promise((r) => setTimeout(r, 0));
+  assert.deepEqual(p.sent, [{ method: 'PATCH', url: '/api/bongos/access-requests/11', body: { status: 'invited' } }], 'the card\'s own route, nothing else');
+  assert.match(p.byId.get('streetToast').textContent, /Ana Ruiz is invited in/);
+  assert.equal(p.byId.get('streetToast').hidden, false);
+  assert.equal(p.byId.get('streetTodayN').textContent, '1 decided');
+  assert.equal(p.byId.get('streetTodayPips').children.filter((x) => x.className.includes('--on')).length, 1, 'one pip per decision');
+  assert.equal(JSON.parse(p.store.get('gov-desk-today')).n, 1, 'the day keeps its count');
+  const quiet = p.part('desk-quiet');
+  assert.ok(quiet && quiet.className.includes('desk-quiet--cleared'), 'a cleared floor is one lit line, never an empty list');
+  assert.deepEqual(quiet.children.slice(1).map((x) => x.textContent), ['Everyone is in', 'lit up · 1 decided today']);
+  assert.equal(p.part('desk-rows'), undefined);
+  assert.equal(p.part('desk-record').children[1].textContent, 'let in Ana Ruiz · now', 'the record line starts with what you did');
+  assert.equal(p.byId.get('insideFloors').children[4].attrs['aria-pressed'], 'true', 'you stay on the floor you cleared');
+  // the drawing: the cleared floor's windows lit and its tick drawn
+  const bv = I.buildingModel({ key: 'people', docket: docket([]), goals: [], mode: 'dark', now: NOW, floor: 4, cleared: [4] });
+  const plain = I.buildingModel({ key: 'people', docket: docket([]), goals: [], mode: 'dark', now: NOW, floor: 0 });
+  assert.ok(bv.shapes.some((s) => /l6 6 12-13$/.test(s.d)), 'a tick on the cleared floor');
+  assert.ok(!plain.shapes.some((s) => /l6 6 12-13$/.test(s.d)), 'no tick on a floor nobody cleared');
+});
+
+test('the page: a refused act keeps the row and says why; no pip is counted', async () => {
+  const ms = [matter({ id: 'access_requests:11', source: 'access_requests', building: 'people', state: 'needs', proposer: { name: 'Ana Ruiz' }, ref: { id: 11 } })];
+  const p = await bootPage('#building=people', ms, { refuse: true });
+  p.part('desk-rows').children[0].children[0].children[2].children[1].fire('click');
+  for (let i = 0; i < 5; i++) await new Promise((r) => setTimeout(r, 0));
+  assert.equal(p.byId.get('streetToast').textContent, 'Someone already decided this.');
+  assert.equal(p.part('desk-rows').children.length, 1);
+  assert.equal(p.byId.get('streetTodayN').textContent, '0 decided');
+});
+
+test('the stylesheet: the desk in tokens only, its motion dies under reduced motion, the chips clear 24px', () => {
+  const css = read('street.css').replace(/\/\*[\s\S]*?\*\//g, '');
+  const desk = css.split('\n').filter((l) => /^\.(desk|street-today)/.test(l)).join('\n');
+  assert.ok(desk.length > 0);
+  assert.doesNotMatch(desk, /#[0-9a-f]{3,8}\b|rgba?\(/i, 'no literal colours on the desk');
+  assert.match(css, /\.desk-chip \{[^}]*height: 34px/);
+  assert.match(css, /\.desk-row--gone \{[^}]*animation: desk-gone/);
+  assert.match(css, /@media \(prefers-reduced-motion: reduce\) \{[^}]*animation: none !important; transition: none !important;/);
+  assert.match(read('street.html'), /id="streetTodayPips"/);
+});

package/tests/hall_street_inside.mjs

@@ -508,7 +508,7 @@ async function bootPage({ hash = '', feeds = {}, innerWidth = 1440 } = {}) {
   };
   const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, Date, console, encodeURIComponent, decodeURIComponent, isNaN, isFinite, Map });
   ctx.globalThis = ctx;
-  for (const f of ['city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street.js']) vm.runInContext(read(f), ctx);
+  for (const f of ['city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street-desk.js', 'street.js']) vm.runInContext(read(f), ctx);
   await window.GovStreetPage.ready;
   await new Promise((r) => setTimeout(r, 0));
   const fireWin = (t, e) => (listeners[t] || []).forEach((fn) => fn(e));

package/tests/module_catalog.mjs

@@ -225,10 +225,11 @@ test('formatCatalog: a search with no hits says so instead of printing an empty
   assert.ok(!/KEY\s+SOURCE/.test(out), 'no header row over an empty result');
 });
 
-test('cmdList: --json emits the rows + summary, and honours --catalog/--search', () => {
+test('cmdList: --json emits the rows + summary, and honours --catalog/--search', async () => {
   const lines = [];
-  const code = mod.cmdList(['--json', '--catalog', '--search', 'example world'], {
+  const code = await mod.cmdList(['--json', '--catalog', '--search', 'example world'], {
     log: (s) => lines.push(s),
+    checkStore: async () => ({ checked: false, reason: 'offline' }),
     gather: () => ({ rows: sample(), skipped: [], errors: [], core: '1.19.0' }),
   });
   assert.equal(code, 0);
@@ -239,17 +240,18 @@ test('cmdList: --json emits the rows + summary, and honours --catalog/--search',
   assert.deepEqual(payload.modules.map((m) => m.key), ['provisioning']);
 });
 
-test('cmdList: --search with no value is a usage error, not a silent empty listing', () => {
+test('cmdList: --search with no value is a usage error, not a silent empty listing', async () => {
   const errs = [];
-  const code = mod.cmdList(['--search'], { log: () => {}, errlog: (s) => errs.push(s), gather: () => { throw new Error('must not gather'); } });
+  const code = await mod.cmdList(['--search'], { log: () => {}, errlog: (s) => errs.push(s), gather: () => { throw new Error('must not gather'); } });
   assert.equal(code, 2);
   assert.match(errs.join('\n'), /usage: bongos module list/);
 });
 
-test('cmdList: a coreVersion-skipped module is surfaced on stderr, not silently dropped', () => {
+test('cmdList: a coreVersion-skipped module is surfaced on stderr, not silently dropped', async () => {
   const errs = [];
-  const code = mod.cmdList([], {
+  const code = await mod.cmdList([], {
     log: () => {},
+    checkStore: async () => ({ checked: false, reason: 'offline' }),
     errlog: (s) => errs.push(s),
     gather: () => ({ rows: sample(), skipped: [{ key: 'rotted', reason: 'coreVersion "^0.1.0" not satisfied by core 1.19.0' }], errors: [], core: '1.19.0' }),
   });
@@ -257,6 +259,32 @@ test('cmdList: a coreVersion-skipped module is surfaced on stderr, not silently
   assert.match(errs.join('\n'), /rotted: not listed — coreVersion/);
 });
 
+test('cmdList: an installed store module the store delisted is marked, and only instance modules are asked about (task 1003797)', async () => {
+  const lines = [];
+  const asked = [];
+  const code = await mod.cmdList([], {
+    log: (s) => lines.push(s),
+    gather: () => ({ rows: sample(), skipped: [], errors: [], core: '1.19.0' }),
+    checkStore: async (rows) => {
+      asked.push(...rows.map((r) => r.key));
+      return { checked: true, latest: Object.fromEntries(rows.map((r) => [r.key, { version: '9.9.9', status: 'delisted' }])) };
+    },
+  });
+  assert.equal(code, 0);
+  const instanceKeys = sample().filter((r) => r.source === 'instance').map((r) => r.key);
+  assert.deepEqual(asked, instanceKeys, 'a core module is never a store install, so it is not asked about');
+  const out = lines.join('\n');
+  assert.match(out, /DELISTED/);
+  assert.match(out, /your copy keeps working, but no more versions will come/);
+  const json = [];
+  await mod.cmdList(['--json'], {
+    log: (s) => json.push(s),
+    gather: () => ({ rows: sample(), skipped: [], errors: [], core: '1.19.0' }),
+    checkStore: async () => ({ checked: false, reason: 'offline' }),
+  });
+  assert.ok(JSON.parse(json.join('\n')).modules.every((m) => m.store_delisted === false), 'offline: nothing is marked');
+});
+
 // ---------------------------------------------------------------------------
 // The live tree — the catalog must actually describe THIS checkout
 // ---------------------------------------------------------------------------

package/tests/module_store_delist.mjs

@@ -0,0 +1,146 @@
+// tests/module_store_delist.mjs — a Metic+ person can take a module out of the store,
+// and a delisted module actually leaves it, while every instance that already holds
+// it keeps it (task 1003797, ADR 0338 D2). Drives the real POST
+// /store/modules/:key/delist handler off the real router, and the real store reads
+// behind acquire / download / update checks, against a stand-in pool (no port, no
+// real DB — the module_store_reassess.mjs harness).
+//
+// Run:  node tests/module_store_delist.mjs
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+const fresh = () => ({
+  modules: { weather: { module_key: 'weather', title: 'Weather', author_id: 42, status: 'listed', delisted_at: null } },
+  versions: [{ id: 7, module_key: 'weather', version: '1.2.0', core_version: '^1.20.0', tree_sha256: 't', tarball_sha256: 'x', tarball_bytes: 10, artifact_path: 'weather/weather-1.2.0.tgz', published_at: '2026-09-30T00:00:00Z' }],
+  sql: [],
+});
+let state = fresh();
+const query = async (sql, params = []) => {
+  state.sql.push(sql);
+  if (/^\s*UPDATE store_modules SET status = 'delisted'/.test(sql)) {
+    const m = state.modules[params[0]];
+    if (!m || m.status !== 'listed') return { rows: [] };
+    m.status = 'delisted'; m.delisted_at = '2026-10-01T00:00:00Z';
+    return { rows: [{ ...m }] };
+  }
+  if (/FROM store_modules WHERE module_key = ANY\(\$1\) AND status = 'delisted'/.test(sql)) {
+    return { rows: params[0].map((k) => state.modules[k]).filter((m) => m && m.status === 'delisted') };
+  }
+  if (/FROM store_modules WHERE module_key = \$1/.test(sql)) {
+    const m = state.modules[params[0]]; return { rows: m ? [m] : [] };
+  }
+  if (/JOIN store_modules m/.test(sql)) {
+    return { rows: state.versions.filter((v) => params[0].includes(v.module_key)).map((v) => ({ ...v, status: state.modules[v.module_key].status })) };
+  }
+  if (/FROM store_module_versions WHERE module_key = \$1/.test(sql)) {
+    return { rows: state.versions.filter((v) => v.module_key === params[0]) };
+  }
+  return { rows: [] };
+};
+const pool = { connect: async () => ({ query, release() {} }), query };
+const poolPath = require.resolve('../src/bongos/pool.js');
+require.cache[poolPath] = { id: poolPath, filename: poolPath, loaded: true, exports: { pool } };
+
+const store = require('../src/bongos/module-store.js');
+const buildModulesRouter = require('../src/bongos/routes/modules.js');
+
+const PATH = '/store/modules/:key/delist';
+function handlerFor(router) {
+  const layer = router.stack.find((l) => l.route && l.route.path === PATH && l.route.methods.post);
+  assert.ok(layer, `no POST ${PATH} on the router`);
+  const stack = layer.route.stack;
+  return { handle: stack[stack.length - 1].handle, depth: stack.length };
+}
+async function invoke(handle, { key = 'weather', body = {} } = {}) {
+  const res = {
+    statusCode: 200, body: undefined,
+    json(b) { this.body = b; return this; },
+    status(c) { this.statusCode = c; return this; },
+    set() { return this; },
+    fail(code, opts, details) { const o = typeof opts === 'number' ? { status: opts, details } : (opts || {}); this.statusCode = o.status; this.body = { error: code, ...o }; return this; },
+  };
+  let nextErr = null;
+  await handle({ params: { key }, body, builder: { id: 3 } }, res, (err) => { nextErr = err; });
+  if (nextErr) throw nextErr;
+  return res;
+}
+
+const { handle, depth } = handlerFor(buildModulesRouter());
+
+test('the route is gated by its own Metic+ atom, granted to metic and archon, and pinned', () => {
+  assert.ok(depth >= 3, 'requireBuilder + requirePermission sit in front of the handler');
+  const src = fs.readFileSync(path.join(ROOT, 'src/bongos/routes/modules.js'), 'utf8');
+  assert.match(src, /router\.post\('\/store\/modules\/:key\/delist', auth\.requireBuilder, auth\.requirePermission\('module\.delist'\)/);
+  const { byKey } = require('../modules/government/catalog.js');
+  const p = byKey('module.delist');
+  assert.equal(p.floor, 'metic');
+  assert.equal(p.system, false);
+  const mig = fs.readFileSync(path.join(ROOT, 'modules/government/migrations/government_025_module_delist.sql'), 'utf8');
+  for (const rank of ['metic', 'archon']) assert.match(mig, new RegExp(`SELECT '${rank}', unnest\\(ARRAY\\[\\s*'module\\.delist'`));
+  const pins = fs.readFileSync(path.join(ROOT, 'src/bongos/route-rank-check.js'), 'utf8');
+  assert.match(pins, /'POST \/store\/modules\/:key\/delist': 'perm:module\.delist'/);
+});
+
+test('no reason, no delist — and only `reason` is accepted', async () => {
+  state = fresh();
+  for (const body of [{}, { reason: '' }, { reason: '   ' }]) {
+    const res = await invoke(handle, { body });
+    assert.equal(res.statusCode, 400);
+    assert.equal(res.body.error, 'reason_required');
+  }
+  assert.equal((await invoke(handle, { body: { reason: 'r', revoke: true } })).statusCode, 400, 'unknown fields are refused');
+  assert.equal(state.modules.weather.status, 'listed');
+});
+
+test('a bad key is refused, an unknown module is 404, a second delist is 409', async () => {
+  state = fresh();
+  assert.equal((await invoke(handle, { key: 'Bad_Key', body: { reason: 'r' } })).statusCode, 400);
+  const missing = await invoke(handle, { key: 'nope', body: { reason: 'r' } });
+  assert.equal(missing.statusCode, 404);
+  assert.equal(missing.body.error, 'module_not_found');
+  assert.equal((await invoke(handle, { body: { reason: 'r' } })).statusCode, 200);
+  const again = await invoke(handle, { body: { reason: 'r' } });
+  assert.equal(again.statusCode, 409);
+  assert.equal(again.body.error, 'already_delisted');
+});
+
+test('a delisted module leaves the store: no new install, download, version or update', async () => {
+  state = fresh();
+  assert.equal((await store.resolveAcquirable('weather', { db: pool })).ok, true, 'installable before');
+  const res = await invoke(handle, { body: { reason: 'a security issue was reported' } });
+  assert.equal(res.statusCode, 200);
+  assert.equal(res.body.status, 'delisted');
+  assert.ok(res.body.delisted_at);
+  // acquire, tarball and acquired all go through resolveAcquirable.
+  const acq = await store.resolveAcquirable('weather', { db: pool });
+  assert.equal(acq.ok, false);
+  assert.equal(acq.code, 'module_delisted');
+  assert.equal((await store.resolveAcquirable('weather', { version: '1.2.0', db: pool })).code, 'module_delisted');
+  // `bongos upgrade` sees the status and tells the holder no more versions will come.
+  const latest = await store.latestVersions(['weather'], { db: pool });
+  assert.equal(latest.weather.status, 'delisted');
+  // The hall's Modules tab marks it.
+  assert.deepEqual([...(await store.delistedKeySet(['weather', 'other'], { db: pool }))], ['weather']);
+});
+
+test('a delist never touches holders, entitlements or scores (ADR 0338 D2, ADR 0359)', async () => {
+  state = fresh();
+  await invoke(handle, { body: { reason: 'r' } });
+  assert.ok(state.sql.every((q) => !/module_entitlements|module_assessment_scores|module_assessment_signals/.test(q)),
+    'the delist writes no entitlement, score or signal row');
+  // An installed module loads from the instance's own disk: the loader never asks
+  // the store, so a delist cannot stop a held copy from mounting.
+  for (const f of fs.readdirSync(path.join(ROOT, 'src/module-loader'))) {
+    if (!f.endsWith('.js')) continue;
+    const src = fs.readFileSync(path.join(ROOT, 'src/module-loader', f), 'utf8');
+    assert.doesNotMatch(src, /store_modules|delisted|\/store\/modules/, `${f} must not consult the store`);
+  }
+});