@bongos/core 1.21.33 → 1.21.35

package/tests/hall_street_desk.mjs

@@ -0,0 +1,557 @@
+// 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"/);
+});
+
+// ── the old-page actions on their floors (task 1004559) ───────────────────────
+// Rows built by the REAL server mappers (each module's own pure function), run
+// through the docket's own normalisers, into the real desk: so a field the
+// server stops sending, or a desk row the desk cannot draw, reds here.
+const SRV = (p) => require(path.join(ROOT, p));
+const DK = SRV('modules/government/docket.js');
+const reportsRoute = SRV('modules/security/routes/reports.js');
+const lifeDocket = SRV('modules/lifecycle/governor-docket.js');
+const autoDocket = SRV('modules/autonomy/governor-docket.js');
+const buildersRoute = SRV('src/bongos/routes/builders.js');
+const govFloors = SRV('modules/government/docket-floors.js');
+const LADDER = ['xenos', 'thetes', 'metic', 'archon'];
+const healthy = () => ({ ok: true, state: 'alive' });
+
+function actedDocket({ longWords = false, force = true } = {}) {
+  const t = (s) => (longWords ? `${LONG} ${s}` : s);
+  const norm = (source, building, list) => list.map((m) => DK.normalizeMatter(m, { source, building })).filter(Boolean);
+  const matters = [
+    ...norm('redteam_reports', 'disputes', [reportsRoute.redteamDocketMatter({ id: 2, title: t('sign-in limits'), severity: 'high', status: 'open', reported_at: '2026-10-01T10:00:00.000Z' })]),
+    ...norm('removal_proposals', 'disputes', [lifeDocket.removalMatter({ proposal_task_id: '50', title: t('old search page'), filed_at: '2026-09-30T10:00:00.000Z' })]),
+    ...norm('criteria_uat', 'review', [
+      lifeDocket.uatMatter({ id: 8, criterion_md: t('Refunds work'), goal_id: 4, shipped_total: 3, backend_only: true }, { force }),
+      lifeDocket.uatMatter({ id: 9, criterion_md: t('The city draws'), goal_id: 4, shipped_total: 2, backend_only: false }, { force }),
+    ]),
+    ...norm('autobongos_fence', 'automation', autoDocket.fenceDocketMatters({ enabled: false, paused_reason: 'payments touched', goals: [] }, true)),
+  ];
+  const desk = (key, building, rows) => ({ key, building, status: 'live', rows: rows.map((r) => DK.normalizeDeskRow(r, { desk: key, building })).filter(Boolean) });
+  const project = { enabled: true, priority_goal_id: 1, goals: [{ goal_id: 1, added_at: '2026-09-20T10:00:00.000Z' }, { goal_id: 2, added_at: '2026-09-21T10:00:00.000Z' }] };
+  const desks = [
+    desk('people.builders', 'people', buildersRoute.builderDeskRows([{ id: 7, display_name: t('Ana Ruiz'), github_login: 'ana', rank: 'thetes' }, { id: 95, display_name: 'Me', rank: 'archon' }], { viewerId: '95', mayRank: true, mayStop: true, ranks: LADDER })),
+    desk('people.ranks', 'people', govFloors.rankDeskRows([{ rank_key: 'tester', label: t('Tester'), is_system: false }, { rank_key: 'archon', label: 'Archon', is_system: true }], [{ builder_id: 7, display_name: 'Ana Ruiz', rank_key: 'tester' }, { builder_id: 8, github_login: 'kai', rank_key: 'metic' }])),
+    desk('disputes.confirmed', 'disputes', [reportsRoute.confirmedDeskRow({ id: 3, title: t('token leak'), severity: 'low', confirmed_at: '2026-09-28T10:00:00.000Z' })]),
+    desk('automation.switch', 'automation', autoDocket.switchDeskRows(project)),
+    desk('automation.goals', 'automation', autoDocket.goalDeskRows(project)),
+    desk('automation.runners', 'automation', autoDocket.runnerDeskRows([{ builder_id: 7, display_name: t('Ana Ruiz'), runners: [{ working_task_id: 12 }] }, { builder_id: 8, owner_paused: true, owner_paused_reason: 'spending too much', runners: [] }], NOW, healthy)),
+  ];
+  return docket(matters, { desks });
+}
+const GOALS = [{ id: '1', title: 'Governor city', status: 'open' }, { id: '2', title: 'Payments', status: 'open' }, { id: '3', title: LONG, status: 'open' }];
+const actedRows = (dk, key, floor) => D.rowsFor(key, floor, dk, { now: NOW, viewerId: '95', goals: GOALS });
+
+test('the moved acts keep the line rule on every floor, long words or short', () => {
+  for (const longWords of [false, true]) {
+    const dk = actedDocket({ longWords });
+    const desks = [];
+    for (const key of S.CIVIC_KEYS) I.PLAN[key].floors.forEach((_f, floor) => desks.push(D.deskModel({ key, floor, docket: dk, goals: GOALS, now: NOW, viewerId: '95' })));
+    assert.deepEqual(desks.flatMap((d) => D.breaks(d)), []);
+    const rows = desks.flatMap((d) => d.rows);
+    assert.ok(rows.length >= 14, 'every moved act drew its row');
+    assert.ok(rows.every((r) => r.wait === '' || r.actions.length === 0));
+  }
+});
+
+test('breaks() catches an asking button with no chips of its own', () => {
+  const dk = actedDocket();
+  const dm = D.deskModel({ key: 'people', floor: 2, docket: dk, goals: GOALS, now: NOW, viewerId: '95' });
+  assert.deepEqual(D.breaks(dm), []);
+  const bad = j(dm);
+  bad.rows[0].choices = {};
+  assert.ok(D.breaks(bad).some((b) => /without its own chips/.test(b)));
+});
+
+test('People: set tier and deactivate are chips on the builder row, never your own; ranks are given and taken back', () => {
+  const dk = actedDocket();
+  const rows = actedRows(dk, 'people', 2);
+  assert.deepEqual(rows.map((r) => r.name), ['Ana Ruiz'], 'your own row is never drawn');
+  const ana = rows[0];
+  assert.deepEqual(ana.actions.map((a) => [a.key, a.label]), [['tier', 'tier'], ['deactivate', 'deactivate']]);
+  assert.deepEqual(ana.choices.tier.options.map((o) => o.key), ['xenos', 'metic'], 'one rung up at most, any rung down');
+  assert.deepEqual(j(C.request(ana.card, 'tier', ana.choices.tier.options[1].input)), { method: 'PATCH', url: '/api/bongos/builders/7/rank', body: { rank: 'metic' } });
+  assert.deepEqual(j(C.request(ana.card, 'deactivate', ana.choices.deactivate.options[0].input)), { method: 'PATCH', url: '/api/bongos/builders/7/status', body: { status: 'inactive', reason: 'left the project' } });
+  const rank = actedRows(dk, 'people', 5)[0];
+  assert.deepEqual(rank.actions.map((a) => a.key), ['give', 'take']);
+  assert.deepEqual(rank.choices.give.options.map((o) => o.label), ['kai']);
+  assert.deepEqual(j(C.request(rank.card, 'give', rank.choices.give.options[0].input)), { method: 'POST', url: '/api/bongos/government/assignments', body: { builder_id: 8, rank_key: 'tester' } });
+  assert.deepEqual(j(C.request(rank.card, 'take', rank.choices.take.options[0].input)), { method: 'DELETE', url: '/api/bongos/government/assignments/7/tester', body: {} });
+  assert.deepEqual(buildersRoute.builderDeskRows([{ id: 7, rank: 'xenos' }], { viewerId: '95', mayRank: false, mayStop: false, ranks: LADDER }), [], 'no atom, no rows');
+  assert.deepEqual(buildersRoute.builderDeskRows([{ id: 7, rank: 'xenos' }], { viewerId: '95', mayRank: false, mayStop: true, ranks: LADDER })[0].acts.map((a) => a.key), ['deactivate']);
+});
+
+test('Disputes: a report is confirmed or disputed, a confirmed one marked fixed, a removal confirmed or kept', () => {
+  const dk = actedDocket();
+  const [rep, fix] = actedRows(dk, 'disputes', 0);
+  assert.deepEqual(rep.actions.map((a) => a.label), ['confirm', 'dispute']);
+  assert.equal(C.request(rep.card, 'confirm').url, '/api/bongos/security/reports/2/confirm');
+  assert.equal(C.request(rep.card, 'dispute').url, '/api/bongos/security/reports/2/dispute');
+  assert.deepEqual(fix.actions.map((a) => a.label), ['fixed']);
+  assert.equal(C.request(fix.card, 'fix').url, '/api/bongos/security/reports/3/fix');
+  const rm = actedRows(dk, 'disputes', 1)[0];
+  assert.deepEqual(rm.actions.map((a) => a.label), ['remove', 'keep']);
+  assert.deepEqual(j(C.request(rm.card, 'remove')), { method: 'POST', url: '/api/bongos/removal-proposals/50/decide', body: { verdict: 'confirmed' } });
+  assert.deepEqual(j(C.request(rm.card, 'keep')).body, { verdict: 'dismissed' });
+});
+
+test('Automation: switch on and off, allow a goal from the open goals, first in line, disallow, pause and resume a runner', () => {
+  const dk = actedDocket();
+  const sw = actedRows(dk, 'automation', 0);
+  const off = sw.find((r) => r.source === 'autobongos_fence');
+  assert.deepEqual(off.actions.map((a) => a.label), ['switch on']);
+  assert.deepEqual(j(C.request(off.card, 'switch_on')), { method: 'POST', url: '/api/bongos/autonomy/fence', body: { enabled: true } });
+  const on = sw.find((r) => r.desk);
+  assert.deepEqual(j(C.request(on.card, 'switch_off', on.choices.switch_off.options[0].input)).body, { enabled: false, reason: 'pause for now' });
+  const goals = actedRows(dk, 'automation', 1);
+  const first = goals.find((r) => r.name === 'Governor city');
+  assert.ok(first, 'an allowed goal is lettered with its title');
+  assert.deepEqual(first.actions.map((a) => a.key), ['disallow'], 'the goal first in line is not offered first again');
+  assert.equal(j(C.request(first.card, 'disallow')).method, 'DELETE');
+  assert.equal(C.request(first.card, 'disallow').url, '/api/bongos/autonomy/fence/goals/1');
+  const pay = goals.find((r) => r.name === 'Payments');
+  assert.deepEqual(j(C.request(pay.card, 'first')), { method: 'POST', url: '/api/bongos/autonomy/fence/priority', body: { goal_id: 2 } });
+  const add = goals.find((r) => r.actions.some((a) => a.key === 'allow'));
+  assert.deepEqual(add.choices.allow.options.map((o) => o.key), ['3'], 'only open goals not yet allowed');
+  const goalDesk = D.deskModel({ key: 'automation', floor: 1, docket: dk, goals: GOALS, now: NOW });
+  assert.match(goalDesk.status, /^2 allowed/, 'the allow row is a tool, not a goal: the floor counts two');
+  assert.deepEqual(j(C.request(add.card, 'allow', add.choices.allow.options[0].input)).body, { goal_id: 3 });
+  const runners = actedRows(dk, 'automation', 2);
+  const busy = runners.find((r) => r.actions[0].key === 'pause');
+  assert.deepEqual(j(C.request(busy.card, 'pause', busy.choices.pause.options[2].input)), { method: 'POST', url: '/api/bongos/autonomy/builders/7/pause', body: { paused: true, reason: 'it is stuck' } });
+  const paused = runners.find((r) => r.actions[0].key === 'resume');
+  assert.deepEqual(j(C.request(paused.card, 'resume')).body, { paused: false });
+  // with every open goal allowed, the allow row has no chip to offer and is not drawn
+  const none = D.rowsFor('automation', 1, dk, { now: NOW, goals: GOALS.slice(0, 2) });
+  assert.ok(!none.some((r) => r.actions.some((a) => a.key === 'allow')));
+});
+
+test('Review: a backend-only promise signs off in one tap; a recorded one goes to its page; force sign-off only with its atom', () => {
+  const rows = actedRows(actedDocket(), 'review', 1);
+  const backend = rows.find((r) => r.actions[0].key === 'signoff');
+  assert.deepEqual(j(C.request(backend.card, 'signoff', backend.choices.signoff.options[0].input)), { method: 'POST', url: '/api/bongos/done-when/8/uat', body: { kind: 'backend_signoff', live_attested: true } });
+  assert.deepEqual(j(C.request(backend.card, 'force', backend.choices.force.options[0].input)), { method: 'POST', url: '/api/bongos/done-when/8/satisfy', body: { override_reason: 'Signed off on the floor desk: tested by hand.' } });
+  const ui = rows.find((r) => r.actions[0].key === 'record');
+  assert.equal(ui.actions[0].go, '/goals#/goal/4');
+  const noForce = actedRows(actedDocket({ force: false }), 'review', 1);
+  assert.ok(noForce.every((r) => !r.actions.some((a) => a.key === 'force')));
+});
+
+test('a viewer the server hands no acts sees the quiet line, not rows', () => {
+  const dk = actedDocket();
+  dk.desks = dk.desks.map((d) => ({ ...d, status: 'not_yours', rows: [] }));
+  const dm = D.deskModel({ key: 'people', floor: 2, docket: dk, goals: GOALS, now: NOW, viewerId: '95' });
+  assert.equal(dm.quiet, true);
+  assert.deepEqual(D.breaks(dm), []);
+});
+
+// ── Release, Rules, Treasury and the invite (task 1004559, second pass) ──────
+const coreRoute = SRV('modules/provisioning/routes/core-upgrade.js');
+const settingsRoute = SRV('modules/lifecycle/routes/project-settings.js');
+const modulesRoute = SRV('src/bongos/routes/modules.js');
+const backupRoute = SRV('src/bongos/routes/backup.js');
+const accessRoute = SRV('modules/onboarding/routes/access-requests.js');
+const PREVIEW = { instance_id: 41, served_version: '1.21.19', recommended_version: '1.21.20', behind: true, observed_at: '2026-10-03T10:00:00.000Z' };
+
+function moreDesks({ preflight = null, longWords = false } = {}) {
+  const t = (s) => (longWords ? `${LONG} ${s}` : s);
+  const desk = (key, building, rows) => ({ key, building, status: 'live', rows: rows.map((r) => DK.normalizeDeskRow(r, { desk: key, building })).filter(Boolean) });
+  const dk = actedDocket({ longWords });
+  dk.matters.push(DK.normalizeMatter({ id: '1.21.20', rule: 'decide', state: 'needs', title: 'Take core 1.21.20 (running 1.21.19)', short: 'core 1.21.20', href: '/settings#software-update', ref: { type: 'core_version', id: '1.21.20' } }, { source: 'core_update', building: 'release' }));
+  dk.desks.push(
+    desk('release.core', 'release', coreRoute.coreDeskRows({ ...PREVIEW, preflight })),
+    desk('rules.settings', 'rules', settingsRoute.settingsDeskRows({ days: 14, categories: [{ active: true }, { active: false }] })),
+    desk('rules.modules', 'rules', modulesRoute.moduleDeskRows([{ key: 'discord', title: t('Discord'), enabled: true }, { key: 'economy', title: 'Economy', enabled: false }])),
+    desk('treasury.backup', 'treasury', backupRoute.backupDeskRows({ age_hours: 30, stale: false }, false)),
+    desk('people.invite', 'people', [accessRoute.INVITE_DESK_ROW]),
+  );
+  return dk;
+}
+
+test('the second-pass desks keep the line rule on every floor', () => {
+  for (const longWords of [false, true]) {
+    for (const preflight of [null, { target: '1.21.20', ok: true }, { target: '1.21.20', ok: false, error: LONG }]) {
+      const dk = moreDesks({ preflight, longWords });
+      const desks = [];
+      for (const key of S.CIVIC_KEYS) I.PLAN[key].floors.forEach((_f, floor) => desks.push(D.deskModel({ key, floor, docket: dk, goals: GOALS, now: NOW, viewerId: '95' })));
+      assert.deepEqual(desks.flatMap((d) => D.breaks(d)), []);
+    }
+  }
+});
+
+test('Release: the core update is checked first; take is offered only after a pass, for that version, and stands in for the link', () => {
+  const rows = (pf) => actedRows(moreDesks({ preflight: pf }), 'release', 3);
+  const fresh = rows(null);
+  assert.deepEqual(fresh.map((r) => r.source), ['release.core'], 'the core row replaces the plain core-update link');
+  assert.deepEqual(fresh[0].actions.map((a) => a.key), ['check'], 'no take before a check');
+  assert.deepEqual(j(C.request(fresh[0].card, 'check', fresh[0].choices.check.options[0].input)), { method: 'POST', url: '/api/bongos/provisioning/instances/41/core-upgrade', body: { to: '1.21.20', dry_run: true } });
+  assert.deepEqual(rows({ target: '1.21.20', ok: false, error: 'x' })[0].actions.map((a) => a.key), ['check'], 'a refused check offers no take');
+  assert.deepEqual(rows({ target: '1.21.19', ok: true })[0].actions.map((a) => a.key), ['check'], 'a pass for another version is no pass');
+  const passed = rows({ target: '1.21.20', ok: true })[0];
+  assert.deepEqual(passed.actions.map((a) => [a.key, a.label]), [['take', 'take it'], ['check', 'check']]);
+  assert.deepEqual(j(C.request(passed.card, 'take', passed.choices.take.options[0].input)), { method: 'POST', url: '/api/bongos/provisioning/instances/41/core-upgrade', body: { to: '1.21.20' } });
+  assert.equal(C.request(passed.card, 'take', {}), null, 'no version chip, no move');
+  assert.deepEqual(coreRoute.coreDeskRows({ ...PREVIEW, open_intent: { state: 'running' } }), [], 'a run in progress offers nothing');
+  assert.deepEqual(coreRoute.coreDeskRows({ ...PREVIEW, behind: false }), []);
+});
+
+test('Rules: the rot timer as day chips, work categories as a link, modules on in one tap and off with a yes', () => {
+  const rows = actedRows(moreDesks(), 'rules', 0);
+  const rot = rows.find((r) => r.name === 'Rot timer');
+  assert.deepEqual(rot.choices.rot.options.map((o) => o.key), ['7', '30', '60', '90'], 'the current value is not offered');
+  assert.deepEqual(j(C.request(rot.card, 'rot', rot.choices.rot.options[1].input)), { method: 'PATCH', url: '/api/bongos/project-settings/rot-days', body: { days: 30 } });
+  const cats = rows.find((r) => r.name === 'Work categories');
+  assert.equal(cats.actions[0].go, '/project-settings');
+  const on = rows.find((r) => r.name === 'Economy');
+  assert.deepEqual(j(C.request(on.card, 'module_on')), { method: 'POST', url: '/api/bongos/modules/economy/enable', body: { enabled: true } });
+  const off = rows.find((r) => r.name === 'Discord');
+  assert.equal(off.choices.module_off.options[0].label, 'yes, turn off');
+  assert.deepEqual(j(C.request(off.card, 'module_off', off.choices.module_off.options[0].input)).body, { enabled: false });
+});
+
+test('Treasury: back up now in one tap; People: invite takes one typed GitHub name', () => {
+  const dk = moreDesks();
+  const backup = actedRows(dk, 'treasury', 2)[0];
+  assert.equal(backup.fact, 'last 30 hours ago');
+  assert.deepEqual(j(C.request(backup.card, 'backup')), { method: 'POST', url: '/api/bongos/backup/trigger', body: {} });
+  assert.deepEqual(backupRoute.backupDeskRows(null, true)[0].acts, [], 'a backup already running offers no second one');
+  const invite = actedRows(dk, 'people', 4).find((r) => r.name === 'Invite someone');
+  assert.equal(invite.choices.invite.field, 'github_login');
+  assert.deepEqual(j(C.request(invite.card, 'invite', { option: '  ana-ruiz ' })), { method: 'POST', url: '/api/bongos/access-requests/invite', body: { github_login: 'ana-ruiz' } });
+  assert.equal(C.request(invite.card, 'invite', { option: ' ' }), null, 'nothing typed, nothing sent');
+  const tiles = D.deskModel({ key: 'treasury', floor: 2, docket: dk, goals: GOALS, now: NOW });
+  assert.deepEqual(D.breaks(tiles), []);
+});
+
+test('the Treasury desk reads the newest backup without blocking (no sync disk read on the docket path)', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'src/bongos/routes/backup.js'), 'utf8');
+  assert.match(src, /desk: 'treasury\.backup'[^\n]*await newestDumpAge\(\)/);
+  const body = src.split('async function newestDumpAge')[1].split('\nfunction latestDump')[0];
+  assert.doesNotMatch(body, /Sync\(/);
+});

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));