@bongos/core 1.21.112 → 1.21.114

package/tests/hall_street_deck.mjs

@@ -0,0 +1,609 @@
+// tests/hall_street_deck.mjs — THE DECISION DECK and THE GOVERNMENT INSIDE EACH
+// BUILDING (task 1004685, the living-city prototype: street-deck.js,
+// street-office.js, the opt-in office storey in street-inside.js).
+//
+// WHAT IT GUARDS.
+//   * Every card the deck or an interior draws keeps the ask format: a matter's
+//     stored ask (task 1004703) and the batch card. A matter with no stored ask
+//     shows in its own words, beside its floor's desk (task 1004717 deleted the
+//     prototype overlay's rewrites and the offices' sample asks). The stored asks
+//     here are the past-asks corpus (tests/fixtures/government-ask-cards.json),
+//     attached to their matters as the server attaches them.
+//   * A real ask sends what its desk row sends: an answer's act maps to the row's
+//     own act, and the request is GovMatterCard.request() of the row's own card —
+//     the same route, never a new one. Answers that record nothing send nothing.
+//   * The queue is needs-you first, then oldest; answered and passed-on asks
+//     leave; skipped ones go to the back; a building's deck is its own asks.
+//   * Batching offers three like asks at a time, never for a recorded sign-off.
+//   * The Lead's office: seated or not as GET /government/leads says, what it may build
+//     without a vote (the server's build_rights, read, never a rule of the hall's
+//     own; task 1004710), the works standing at each building, and the
+//     drawing's office storey (opt-in: the prototype-equal drawing is pinned in
+//     tests/hall_street_inside.mjs and is untouched here).
+//   * The law book is the laws in force beside the interaction contract; the
+//     treasury's tiles, pots and cap are GET /government/treasury's.
+//   * The page, in a vm: keys pick, the card leaves and the next rises, a pip is
+//     counted, the toast speaks; a refusal keeps the card; S skips; D passes it
+//     on through the server; a build-out tap is POST /government/buildouts.
+//   * The stylesheet: tokens only, motion dies under reduced motion.
+//
+// Run:  node --test --test-reporter=tap tests/hall_street_deck.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 FX = path.join(ROOT, 'scripts/hall-preview/fixtures');
+const require = createRequire(import.meta.url);
+require(path.join(PUB, 'city-draw.js'));
+const S = require(path.join(PUB, 'street-draw.js'));
+const C = require(path.join(PUB, 'street-card.js'));
+const I = require(path.join(PUB, 'street-inside.js'));
+require(path.join(PUB, 'street-depth.js'));
+const D = require(path.join(PUB, 'street-desk.js'));
+const L = require(path.join(PUB, 'gov-living.js'));
+const K = require(path.join(PUB, 'street-deck.js'));
+const O = require(path.join(PUB, 'street-office.js'));
+const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8');
+const fx = (n) => JSON.parse(fs.readFileSync(path.join(FX, n + '.json'), 'utf8'));
+const NOW = Date.parse('2026-10-09T15:00:00.000Z');
+const j = (v) => JSON.parse(JSON.stringify(v));
+// real past asks as stored asks: the server attaches a matter's stored ask as `ask`
+const CARDS = JSON.parse(fs.readFileSync(path.join(ROOT, 'tests', 'fixtures', 'government-ask-cards.json'), 'utf8')).cards;
+function withAsks(d) {
+  d.matters.forEach((m) => {
+    const c = CARDS.find((x) => x.id === m.id);
+    if (c) m.ask = { question: c.question, options: c.options, recommend: c.recommend, waits_on: c.waits_on, if_nobody_answers: c.if_nobody_answers };
+  });
+  return d;
+}
+
+function feeds() {
+  return { docket: withAsks(fx('government__docket')), goals: fx('goals'), rollups: fx('goals__rollups'), blockers: fx('blockers'), cost: fx('public__cost-summary'), roster: fx('builders__roster'), me: fx('me'), treasury: fx('government__treasury'), leads: fx('government__leads') };
+}
+function living(over = {}) { const f = feeds(); return L.livingModel({ ...f, now: NOW, ...over }); }
+function session() { return { done: {}, delegated: {}, skipped: [], extra: [], batch: null, noBatch: {} }; }
+function ctx(f = feeds()) { return { docket: f.docket, goals: f.goals.goals.filter((g) => g.status === 'open'), now: NOW, viewerId: String(f.docket.viewer.id) }; }
+const deck = (lv, s, scope, f = feeds()) => K.deckModel({ living: lv, ...ctx(f), scope, session: s });
+
+// ── the ask format, everywhere ───────────────────────────────────────────────
+
+test('every card the deck draws keeps the ask format, the batch card included', () => {
+  const lv = living();
+  const dm = deck(lv, session());
+  assert.ok(dm.remaining >= 30, 'the real docket fills the deck');
+  for (const id of dm.queue) {
+    const a = lv.city.asks.find((x) => x.id === id);
+    assert.ok(a.shown && a.ask_real, id + ' has its stored card');
+    assert.equal(L.askFormat(a.shown).ok, true, id);
+  }
+  const from = { id: 'criteria_uat:1000184', source: 'criteria_uat', building: 'review', key: 'pass', act: null, label: 'Not me' };
+  const likes = K.likesOf(K.queueOf(lv, session(), null), from, ctx());
+  const b = K.batchAsk(from, likes.slice(0, 3), likes.length - 3);
+  assert.deepEqual(L.askFormat(b.shown), { ok: true, errors: [], question_words: 5 });
+});
+
+test('a matter with no stored ask shows in its own words, beside its floor\'s desk; nothing is invented for it', () => {
+  const f = feeds();
+  f.docket = fx('government__docket');
+  const lv = L.livingModel({ ...f, now: NOW });
+  const a = lv.city.asks.find((x) => x.id === 'override_requests:1000017');
+  assert.equal(a.human, null, 'no stored ask: no card');
+  assert.equal(a.ask_real, false);
+  const cv = K.cardView(a, ctx(f));
+  assert.ok(cv.question && a.raw.title.startsWith(cv.question.replace(/…$/, '')), 'the matter\'s own words');
+  assert.deepEqual(cv.options, [], 'no tap answers are made up');
+  assert.equal(cv.desk, '/builders/street#building=' + a.building, 'its acts are on its floor\'s desk');
+  assert.doesNotMatch(cv.kicker, /sent back/, 'a matter is never "sent back" for having no card');
+  // the offices make no asks of their own any more
+  for (const k of ['proposalAsk', 'appointAsk', 'lawAsk', 'strictAsk', 'LAW_CHIPS']) assert.equal(k in O, false, k);
+  assert.equal('protoAsk' in K, false);
+});
+
+// ── real asks send what their desk row sends ─────────────────────────────────
+
+test('an answer\'s act is the matter card\'s act', () => {
+  assert.deepEqual(K.actFor('go ahead'), { key: 'decide', input: { option: 'go ahead', label: 'go ahead' } });
+  assert.deepEqual(K.actFor('force:tested_by_hand'), { key: 'force', input: { option: 'tested_by_hand' } });
+  assert.deepEqual(K.actFor('approve'), { key: 'release', input: {} });
+  assert.deepEqual(K.actFor('reject'), { key: 'hold', input: {} });
+  assert.deepEqual(K.actFor('confirm'), { key: 'confirm', input: {} });
+  assert.equal(K.actFor(null), null);
+});
+
+test('a real answer is the desk row\'s own request, to the route the desk uses', () => {
+  const lv = living();
+  const f = feeds();
+  const c = ctx(f);
+  const seen = {};
+  for (const a of lv.city.asks.filter((x) => x.state === 'needs')) {
+    const cv = K.cardView(a, c);
+    const row = D.cardFor(a.id, f.docket, { now: NOW, goals: c.goals, viewerId: c.viewerId }).row;
+    for (const o of cv.options) {
+      assert.notEqual(o.plan.mode, 'off', `${a.id} ${o.label}: ${o.why}`);
+      if (o.plan.mode !== 'send') continue;
+      assert.ok(row.actions.some((x) => x.key === o.plan.key), `${a.id} ${o.plan.key} is one of the row's acts`);
+      const r = C.request(o.plan.card, o.plan.key, o.plan.input);
+      assert.ok(r && r.url.startsWith('/api/bongos/'), a.id);
+      assert.deepEqual(r, C.request(row.card, o.plan.key, o.plan.input), 'the same request the desk row sends');
+      seen[a.source + ':' + o.plan.key] = r.method + ' ' + r.url.replace(/\d+/g, 'N');
+    }
+  }
+  assert.deepEqual(seen, {
+    'blockers:decide': 'POST /api/bongos/blockers/N/resolve',
+    'criteria_uat:force': 'POST /api/bongos/done-when/N/satisfy',
+    'redteam_reports:confirm': 'POST /api/bongos/security/reports/N/confirm',
+    'redteam_reports:dispute': 'POST /api/bongos/security/reports/N/dispute',
+    'override_requests:release': 'POST /api/bongos/override-requests/N/decide',
+    'autobongos_fence:switch_on': 'POST /api/bongos/autonomy/fence',
+    'treasury_spending:answer': 'POST /api/bongos/government/treasury/borrows/N/answer',
+  });
+  // a blocker's option is its own chip, so its words are the resolution note
+  const b = K.cardView(lv.city.asks.find((x) => x.id === 'blockers:1000136'), c);
+  assert.deepEqual(C.request(b.options[1].plan.card, 'decide', b.options[1].plan.input).body, { resolution_note: 'Decided on the floor desk: go ahead.' });
+  // a recorded sign-off opens its line; "not me" and "keep it off" record nothing
+  const cr = K.cardView(lv.city.asks.find((x) => x.id === 'criteria_uat:1000184'), c);
+  assert.deepEqual(cr.options.map((o) => o.plan.mode), ['record', 'send', 'note']);
+  assert.equal(cr.options[0].plan.id, '1000184');
+  const fence = K.cardView(lv.city.asks.find((x) => x.id === 'autobongos_fence:fence'), c);
+  assert.deepEqual(fence.options.map((o) => o.plan.mode), ['send', 'note']);
+});
+
+test('a viewer the server hands no acts gets answers marked not from here, never a send', () => {
+  const f = feeds();
+  f.docket.matters.forEach((m) => { m.acts = []; m.state = m.state === 'needs' ? 'moving' : m.state; });
+  const lv = L.livingModel({ ...f, now: NOW });
+  const a = lv.city.asks.find((x) => x.id === 'redteam_reports:1000009');
+  const cv = K.cardView({ ...a, state: 'needs' }, ctx(f));
+  assert.ok(cv.options.every((o) => o.plan.mode === 'off' && o.why), JSON.stringify(cv.options.map((o) => o.plan)));
+});
+
+// ── the queue ────────────────────────────────────────────────────────────────
+
+test('the deck is every ask that needs a person, needs-you first then oldest; answered asks leave, skipped go last', () => {
+  const lv = living();
+  const s = session();
+  const all = lv.city.asks.filter((a) => a.state === 'needs').map((a) => a.id);
+  const dm = deck(lv, s);
+  assert.deepEqual(dm.queue, all, 'the model\'s own order');
+  assert.equal(dm.current.id, all[0]);
+  assert.equal(dm.you, lv.city.asks.filter((a) => a.state === 'needs' && a.needs_you).length);
+  assert.equal(dm.scopes.reduce((t, x) => t + x.n, 0), all.length, 'the buildings add up to the deck');
+  assert.equal(dm.behind, 2, 'two cards stand behind the top one');
+  s.done[all[0]] = true;
+  s.skipped.push(all[1]);
+  s.delegated[all[2]] = 'owner';
+  const d2 = deck(lv, s);
+  assert.equal(d2.remaining, all.length - 2);
+  assert.equal(d2.current.id, all[3]);
+  assert.equal(d2.queue[d2.queue.length - 1], all[1], 'a skipped ask comes back last');
+  const rv = deck(lv, session(), 'review');
+  assert.ok(rv.queue.length === 21 && rv.queue.every((id) => /^criteria_uat:/.test(id)), 'a building\'s deck is its own asks');
+});
+
+test('batching: three like asks at a time, the rest counted; never for a recorded sign-off; "one at a time" stops it', () => {
+  const lv = living();
+  const s = session();
+  s.done['criteria_uat:1000184'] = true;
+  s.batch = { id: 'criteria_uat:1000184', source: 'criteria_uat', building: 'review', key: 'pass', act: null, label: 'Not me' };
+  const dm = deck(lv, s);
+  assert.equal(dm.current.batch, true);
+  assert.equal(dm.current.likes.length, 3);
+  assert.equal(dm.current.more, 17);
+  assert.equal(dm.current.kicker, '3 more like this');
+  assert.deepEqual(dm.current.options.map((o) => o.label), ['Not me, all 3', 'One at a time']);
+  // the words (task 1004702): the asker's voice, and the last line as a sentence
+  assert.equal(dm.current.said, "They ask the same thing of the same seat. I'd answer them together.");
+  assert.match(dm.current.foot.rest, /^Left alone, they wait in your deck\. 17 more like these after\.$/);
+  assert.equal(dm.hand, 3, 'the dock says three are in hand');
+  s.batch = { ...s.batch, key: 'record', act: 'record', label: 'Record a check' };
+  assert.notEqual(deck(lv, s).current.batch, true, 'a recording is one film per promise: no batch');
+  s.batch = { ...s.batch, key: 'pass', act: null };
+  s.noBatch['criteria_uat:review'] = true;
+  assert.notEqual(deck(lv, s).current.batch, true);
+});
+
+test('passing it on: only through the server, only a stored ask that waits on you, only to the owner and the Leads in office', () => {
+  // a docket the server did not route: nothing can be passed on from here
+  const un = living({ docket: unrouted(withAsks(fx('government__docket'))) });
+  for (const a of un.city.asks.filter((x) => x.state === 'needs')) assert.deepEqual(K.seatsFor(un, a, '1000025'), [], a.id);
+  assert.equal(deck(un, session()).pass, false, 'and the deck offers no D key');
+  // routed (task 1004705), with Planning's Lead in office
+  const leads = fx('government__leads');
+  leads.buildings.find((b) => b.building === 'planning').lead = { id: '1', building: 'planning', builder: { id: '1000027', login: 'builder-2016', name: 'Builder 2016' }, charter: 'Goals.', since: '2026-10-01T00:00:00Z', appointed_by: { item_id: '5' } };
+  const routed = living({ leads });
+  assert.equal(routed.routed, true);
+  assert.equal(deck(routed, session()).pass, true);
+  for (const a of routed.city.asks.filter((x) => x.state === 'needs' && x.needs_you)) {
+    const seats = K.seatsFor(routed, a, '1000025');
+    assert.ok(seats.length >= 1 && seats.length <= 5, a.id);
+    assert.ok(seats.every((s) => s.seat !== a.waits_on.seat && s.label.length <= 16 && /^(owner|lead:\w+)$/.test(s.seat)), a.id);
+  }
+  const f = feeds();
+  f.docket = fx('government__docket');
+  const bare = L.livingModel({ ...f, leads, now: NOW });
+  for (const a of bare.city.asks.filter((x) => x.state === 'needs' && !x.ask_real)) assert.deepEqual(K.seatsFor(bare, a, '1000025'), [], a.id + ': no stored ask, nothing the server could pass on');
+  // a stored ask can be passed on (POST /government/asks/:matter/pass): the dry pot's borrow (task 1004712)
+  const borrow = routed.city.asks.find((x) => x.id === 'treasury_spending:1');
+  assert.ok(borrow.ask_real && K.seatsFor(routed, borrow, '1000025').length >= 1);
+});
+
+// ── the Lead's office ────────────────────────────────────────────────────────
+
+test('the office: who leads it, what the form of government lets it build, and what stands at each building', () => {
+  const lv = living();
+  // the hub has seated no Lead: every office stands, held by the owner
+  assert.deepEqual(L.BUILDING_KEYS.map((k) => O.officeOf(lv, k).seated), L.BUILDING_KEYS.map(() => false));
+  const pl = O.officeOf(lv, 'planning');
+  assert.equal(pl.line, 'no Lead · Builder 2013 holds it');
+  assert.ok(pl.holders.includes('1000025'), 'the owner seat answers for it, the viewer among them');
+  // the hub's constitution matches no named form: everything goes to a vote
+  assert.equal(O.buildPlan(lv, 'planning', 'floor').authorised, false);
+  assert.equal(O.buildsAlone(pl).fact, 'no · it goes to a vote');
+  assert.deepEqual(O.worksOf(lv, 'release'), [], 'no build-out stands or waits there');
+  assert.equal(O.officeOf(living({ leads: null }), 'planning'), null, 'the Leads not read: no office is invented');
+});
+
+test('who may build without a vote is the SERVER\'s answer (GET /government/leads build_rights): the hall holds no rule of its own', () => {
+  const os = O.blank();
+  const leadsFx = fx('government__leads');
+  const DEE = { id: '1000025', login: 'builder-2012', name: 'Builder 2012' };
+  const answer = (withoutVote, why, by) => ({ without_vote: withoutVote, why, ground: by });
+  const readWith = (rights) => {
+    const r = j(leadsFx);
+    const pl = r.buildings.find((b) => b.building === 'planning');
+    pl.lead = { id: '1', building: 'planning', builder: DEE, charter: 'Goals.', since: '2026-10-09T12:00:00.000Z', appointed_by: { item_id: '40' } };
+    pl.answers = { seat: 'lead:planning', builder_ids: [DEE.id], fell_to_owner: false };
+    pl.build_rights = rights;
+    return r;
+  };
+  // a monarchy: the server says at once, and says why
+  const yes = answer(true, 'The founder decides alone, so whoever holds this building builds it out at once.', 'form');
+  const monarchy = { form: 'monarchy', form_name: 'Monarchy / BDFL', holder: 'lead:planning', capsules: { committee: yes, floor: yes, annex: yes, district: answer(false, 'A district is a new part of the city, so the board votes on it.', 'city') } };
+  const lvM = living({ leads: readWith(monarchy) });
+  assert.equal(lvM.buildings.find((b) => b.key === 'planning')._sources.build_rights, 'real');
+  assert.deepEqual(j(O.buildPlan(lvM, 'planning', 'annex', os)), { authorised: true, why: yes.why, ground: 'form' });
+  assert.equal(O.buildPlan(lvM, 'planning', 'district', os).authorised, false);
+  assert.equal(O.buildsAlone(O.officeOf(lvM, 'planning', os)).fact, 'yes, under Monarchy / BDFL');
+  // a direct democracy: a vote, in the server's words
+  const no = answer(false, 'Every builder decides changes together, so it goes to a vote.', 'form');
+  const dd = { form: 'direct-democracy', form_name: 'Direct Democracy', holder: 'lead:planning', capsules: { committee: no, floor: no, annex: no, district: no } };
+  const lvD = living({ leads: readWith(dd) });
+  assert.deepEqual(j(O.buildPlan(lvD, 'planning', 'committee', os)), { authorised: false, why: no.why, ground: 'form' });
+  assert.match(O.officeOf(lvD, 'planning').line, /^Builder 2012 · Lead since 9 Oct$/);
+  // a building's own rule, said by the server
+  const sat = answer(true, 'Planning is decided by the council rank, and its holder is one of them, so they build it out at once.', 'building');
+  const lvB = living({ leads: readWith({ form: 'direct-democracy', form_name: 'Direct Democracy', holder: 'lead:planning', capsules: { committee: sat, floor: sat, annex: sat, district: no } }) });
+  assert.equal(O.buildsAlone(O.officeOf(lvB, 'planning', os)).fact, 'yes, by how this building decides');
+  // an older server with no build_rights: nothing is built at once
+  const lvN = living({ leads: readWith(null) });
+  assert.deepEqual(j(O.buildPlan(lvN, 'planning', 'floor', os)), { authorised: false, why: 'Who may build here is not known, so the board votes on it.' });
+  // the capsules are the server's own four (modules/government/build-rights.js)
+  const BR = require(path.join(ROOT, 'modules/government/build-rights.js'));
+  assert.deepEqual(O.CAPSULES.map((c) => c.key), [...BR.CAPSULES]);
+});
+
+test('the drawing: the office is one storey on top, the lift runs to it, a live site takes the next empty floor', () => {
+  const f = feeds();
+  const base = I.buildingModel({ key: 'release', docket: f.docket, goals: [], mode: 'dark', now: NOW });
+  const office = { seated: true, line: 'Builder 2016 · Lead since 5 Sep', ini: '', rooms: [{ name: 'Testers', proposed: false }] };
+  const works = [{ kind: 'floor', state: 'site', label: 'Staging floor', line: '55% built', progress: 0.55 }];
+  const bv = I.buildingModel({ key: 'release', docket: f.docket, goals: [], mode: 'dark', now: NOW, office, works, floor: 'office' });
+  assert.equal(bv.cap, base.cap + 1, 'one storey more: the office');
+  assert.equal(bv.capFloors, base.cap, 'the office is not one of the floors in use');
+  assert.equal(bv.fill, base.fill);
+  assert.equal(bv.officeSel, true);
+  assert.equal(bv.lift.ty, -(bv.officeIdx * 52));
+  assert.ok(bv.floors.some((x) => x.index === 'office' && x.selected && !('proto' in x)));
+  assert.ok(!bv.floors.some((x) => x.index !== 'office' && x.selected), 'no floor is chosen while the office is');
+  assert.ok(bv.texts.some((t) => t.v === 'Lead\'s office'));
+  assert.ok(bv.texts.some((t) => t.v === '55%'), 'the site says how far it is');
+  assert.deepEqual(bv.sites.map((s) => [s.label, s.y]), [['Staging floor', 676 - (base.occ + 1) * 52]]);
+  const annex = I.buildingModel({ key: 'treasury', docket: f.docket, goals: [], mode: 'light', now: NOW, office, works: [{ kind: 'annex', state: 'proposed', label: 'Investments arm' }] });
+  assert.ok(annex.shapes.some((p) => p.dash === '5 4'), 'a proposed annex is a dashed ghost');
+  assert.equal(annex.hasAnnex, false);
+  const built = I.buildingModel({ key: 'planning', docket: f.docket, goals: [], mode: 'dark', now: NOW, office, extraFloors: [{ name: 'A new floor', line: 'built by a build-out' }], floor: 6 });
+  assert.equal(built.occ, base.occ === undefined ? built.occ : I.PLAN.planning.floors.length + 1);
+  assert.equal(built.builtSel, true, 'a floor a build-out put up is chosen like any floor');
+});
+
+test('the picture the board votes on: the city\'s own building with the change drawn dashed, for every building and change', () => {
+  for (const key of L.BUILDING_KEYS) {
+    for (const c of O.CAPSULES) {
+      for (const mode of ['dark', 'light']) {
+        const p = O.isoPicture(key, c.key, mode);
+        assert.ok(p.paths.length > 4, key);
+        assert.ok(p.paths.some((x) => x.dash === '4 3'), `${key} ${c.key}: the change is dashed`);
+        assert.ok(p.viewBox.split(' ').map(Number).every(Number.isFinite));
+      }
+    }
+  }
+});
+
+// ── the law book, the treasury, strictness ───────────────────────────────────
+
+test('the law book: the laws in force and the docket\'s standing rule, each with what the AI does; the contract every session reads', () => {
+  const law = { id: 7, no: 1, text: 'Screenshots on UI work', effect_on_ai: 'Every screen change carries a before and after shot.', locks: [], passed_at: '2026-10-08T10:00:00Z', passed_by: { government: 'the board' }, in_force: true };
+  const lv = living({ laws: { laws: [law] } });
+  const book = O.lawBook(lv);
+  assert.equal(book.rows.length, lv.city.laws.length);
+  assert.ok(book.rows.some((r) => r.text === 'Screenshots on UI work' && r.by === 'the board' && r.when === '8 Oct'), 'the law in force, who passed it, when');
+  assert.ok(book.rows.every((r) => r.text && r.ai && r.by && r.when));
+  assert.equal('chips' in book, false, 'no law is proposed from a made-up list');
+  const me = fx('me');
+  const inj = O.injection(lv, me);
+  assert.equal(inj.real, true);
+  assert.equal([inj.head].concat(inj.profile).join('\n'), me.interaction.contract.split('\n').map((x) => x.replace(/^-\s*/, '').trim()).join('\n'), 'the contract, word for word');
+  assert.ok(inj.laws.some((l) => l.text === 'Screenshots on UI work'), 'every agent reads the law');
+  assert.equal(O.lawBook(living({ laws: { laws: [] } })).rows.every((r) => r.id !== 'law:7'), true, 'none in force: none in the book');
+});
+
+test('the treasury: the real spend as tiles, the pots per goal with the dry one first, no cap by default', () => {
+  const lv = living();
+  const t = O.treasury(lv);
+  assert.deepEqual(t.tiles.map((x) => x.v), [O.usd(lv.city.spend.month_usd), O.usd(lv.city.spend.last_month_usd), O.usd(lv.city.spend.reserve_usd)]);
+  assert.ok(t.tiles.every((x) => x.v.length <= 8 && x.l.split(' ').length <= 2), 'a tile is one number and two words');
+  assert.equal(t.pots[0].dry, true);
+  // the pots, the reserve and the cap are GET /government/treasury's (task 1004712)
+  assert.equal(t.dryAsk, 'treasury_spending:1', 'the dry pot\'s real borrow, on the docket');
+  assert.equal(t.cap.on, false);
+  assert.match(t.cap.line, /no spend limit/);
+  // a loan the treasury really made refills the pot (a visit's own answer does not)
+  const tr = fx('government__treasury');
+  tr.pots.find((p) => p.dry).lent_usd = 2350;
+  assert.equal(O.treasury(living({ treasury: tr })).pots.find((p) => p.goal === t.pots[0].goal).dry, false, 'a loan refills the pot');
+  assert.equal(O.treasury(living({ treasury: null })), null, 'the treasury not read: no book');
+});
+
+test('the model halves are pure: no document, no fetch, no clock above the page half', () => {
+  for (const f of ['street-deck.js', 'street-office.js']) {
+    const src = read(f).split('THE PAGE HALF')[0].replace(/\/\/.*$/gm, '');
+    assert.doesNotMatch(src, /\bdocument\b|\bfetch\(|Date\.now|localStorage/, f);
+  }
+  const a = j(deck(living(), session()));
+  const b = j(deck(living(), session()));
+  assert.deepEqual(a, b, 'the same input gives the same deck');
+});
+
+// ── the page ─────────────────────────────────────────────────────────────────
+
+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; },
+    removeAttribute(k) { delete this.attrs[k]; },
+    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 + this.kids.map((k) => k.textContent || '').join(''); },
+    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), createTextNode: (t) => { const n = mk('#text'); n._text = String(t); return n; } }, byId, focused };
+}
+const FEED = {
+  '/api/bongos/government/docket': 'government__docket', '/api/bongos/goals': 'goals', '/api/bongos/goals/rollups': 'goals__rollups',
+  '/api/bongos/me': 'me', '/api/bongos/builders/roster': 'builders__roster',
+  '/api/bongos/blockers': 'blockers', '/api/bongos/public/cost-summary': 'public__cost-summary',
+  // the living model's reads, as gov-feeds.js names them (one read each per page)
+  '/api/bongos/tasks/claimable?limit=1': 'tasks__claimable', '/api/bongos/tasks?status=active&limit=200': 'tasks__status-active',
+  '/api/bongos/blockers?limit=100': 'blockers', '/api/bongos/moving': 'moving', '/api/bongos/autonomy/fence': 'autonomy__fence',
+  '/api/bongos/government/constitution': 'government__constitution', '/api/bongos/government/leads': 'government__leads',
+};
+// The docket as a server that did not route it serves it.
+function unrouted(d) {
+  delete d.routed;
+  d.matters.forEach((m) => { delete m.route; });
+  return d;
+}
+// feeds: { url: body | null } served instead of the fixture (null answers 404)
+async function bootPage(hash, { answer = null, feeds = {} } = {}) {
+  const { document, byId, focused } = fakeDom();
+  const sent = [];
+  const got = [];
+  const store = new Map();
+  const winL = {};
+  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(t, fn) { (winL[t] = winL[t] || []).push(fn); }, history: { pushState() {} },
+  };
+  const fetch = (url, init) => {
+    if (init && init.method && init.method !== 'GET') {
+      const body = JSON.parse(init.body || '{}');
+      sent.push({ method: init.method, url, body });
+      const own = answer ? answer(url, body) : null;
+      const out = own || { status: 501, body: { error: { code: 'preview_readonly' } } };
+      return Promise.resolve({ ok: out.status < 300, status: out.status, json: async () => out.body || {} });
+    }
+    got.push(url);
+    if (Object.prototype.hasOwnProperty.call(feeds, url)) {
+      const body = feeds[url];
+      return Promise.resolve(body ? { ok: true, json: async () => JSON.parse(JSON.stringify(body)) } : { ok: false, status: 404, json: async () => ({}) });
+    }
+    const name = FEED[url];
+    const body = name === 'government__docket' ? withAsks(fx(name)) : name ? fx(name) : null;
+    return Promise.resolve(name ? { ok: true, json: async () => body } : { ok: false, json: async () => ({}) });
+  };
+  window.fetch = fetch;
+  const ctxv = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, Date, console, encodeURIComponent, decodeURIComponent, isNaN, isFinite, Map, Set, setTimeout, clearTimeout });
+  ctxv.globalThis = ctxv;
+  for (const f of ['gov-living.js', 'gov-feeds.js', 'city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street-depth.js', 'street-desk.js', 'street-amend.js', 'street-deck.js', 'street-office.js', 'street.js']) vm.runInContext(read(f), ctxv);
+  await window.GovStreetPage.ready;
+  for (let i = 0; i < 6; i++) await new Promise((r) => setTimeout(r, 0));
+  const key = (k) => (winL.keydown || []).forEach((fn) => fn({ key: k, target: null, preventDefault() {} }));
+  const walk = (el, pred, out = []) => { (el.kids || []).forEach((k) => { if (pred(k)) out.push(k); walk(k, pred, out); }); return out; };
+  const cls = (el, c) => walk(el, (k) => String(k.className).split(' ').includes(c));
+  const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+  return { window, byId, focused, sent, got, store, key, walk, cls, wait, deck: () => byId.get('streetDeck') };
+}
+
+test('the page: #deck draws the top card over the street; a key answers it through the row\'s route, the next rises, a pip is counted', async () => {
+  const p = await bootPage('#deck=planning');
+  const box = p.deck();
+  assert.equal(box.hidden, false);
+  assert.equal(p.byId.get('streetWindow').getAttribute('data-view'), 'deck', 'the deck is open over the street');
+  assert.doesNotMatch(read('street-deck.css'), /\[data-view="deck"\] \.street-sizer/, 'the street stays in view (task 1004702)');
+  const card = p.cls(box, 'ask')[0];
+  assert.equal(card.getAttribute('data-ask'), 'blockers:1000136');
+  // the headline is what needs you (gov-living.js countsOf: the city's door says the same)
+  assert.equal(p.cls(box, 'deck-dock__n')[0].textContent, '1', 'one card in hand');
+  assert.equal(p.cls(box, 'deck-dock__of')[0].textContent, ' of 9 to do', 'Planning\'s own: its nine blockers');
+  assert.ok(/\bdeck-panel\b/.test(card.className) && /\bgov-glass\b/.test(card.className), 'the card is the glass panel');
+  assert.equal(p.cls(card, 'ask__bld')[0].textContent, 'Planning', 'the building that asks, named on the card');
+  assert.ok(p.cls(box, 'deck-dock').length === 1 && p.cls(box, 'deck-scene').length === 1, 'the dock at the foot, the scene layer under the panel');
+  assert.ok(p.walk(card, (k) => k.tagName === 'kbd').length >= 3, 'each answer wears its key');
+  assert.equal(p.cls(card, 'ask__opt').length, 3);
+  assert.equal(p.walk(box, (k) => k.getAttribute && k.getAttribute('data-proto') != null).length, 0, 'nothing on the deck is marked prototype');
+  // the deck reads nothing of its own: the street's living model, one read of each feed
+  assert.deepEqual(p.got.filter((u, i) => p.got.indexOf(u) !== i), [], 'no feed is read twice on the page');
+  assert.ok(!p.got.includes('/api/bongos/blockers'), 'the deck\'s old extra read is gone');
+  p.key('2');
+  await p.wait(450);
+  assert.deepEqual(p.sent, [{ method: 'POST', url: '/api/bongos/blockers/1000136/resolve', body: { resolution_note: 'Decided on the floor desk: go ahead.' } }]);
+  assert.match(p.byId.get('streetToast').textContent, /reached|Sent to POST \/blockers\/1000136\/resolve/);
+  assert.equal(JSON.parse(p.store.get('gov-desk-today')).n, 1, 'one pip, kept for the day');
+  const next = p.cls(p.deck(), 'ask')[0];
+  assert.equal(next.getAttribute('data-ask'), 'blockers:1000143');
+  assert.match(next.className, /\bask--rise\b/, 'the next one rises');
+  assert.equal(p.cls(p.deck(), 'deck-dock__of')[0].textContent, ' of 8 to do');
+  assert.equal(p.byId.get('hudNeeds').textContent, '37', 'the street\'s header moves with the deck');
+});
+
+test('the page: a refusal keeps the card and counts nothing; S skips to the back', async () => {
+  const p = await bootPage('#deck=planning', { answer: () => ({ status: 409, body: { error: { code: 'not_pending' } } }) });
+  p.key('1');
+  await p.wait(60);
+  assert.equal(p.byId.get('streetToast').textContent, 'Someone already decided this.');
+  assert.equal(p.cls(p.deck(), 'ask')[0].getAttribute('data-ask'), 'blockers:1000136', 'the card stays');
+  assert.equal(p.store.get('gov-desk-today'), undefined, 'nothing counted');
+  p.key('s');
+  await p.wait(400);
+  assert.equal(p.cls(p.deck(), 'ask')[0].getAttribute('data-ask'), 'blockers:1000143');
+  assert.equal(p.cls(p.deck(), 'deck-dock__of')[0].textContent, ' of 9 to do', 'a skip answers nothing');
+});
+
+test('the page, routed (task 1004705): the deck holds what the server routed to you; a real ask is passed on through the server', async () => {
+  const docket = fx('government__docket');
+  const id = docket.matters.find((m) => m.state === 'needs' && m.route.yours).id;
+  docket.matters.find((m) => m.id === id).ask = {
+    question: 'Close this report as fixed?',
+    options: [{ key: 'close', label: 'Close it', result: 'The report is marked fixed.' }, { key: 'keep', label: 'Keep it open', result: 'It stays on the Disputes desk.' }],
+    recommend: { key: 'keep', why: 'Nobody has checked the fix yet.' }, waits_on: 'owner', if_nobody_answers: 'It stays on the Disputes desk.',
+  };
+  const leads = fx('government__leads');
+  const planning = leads.buildings.find((b) => b.building === 'planning');
+  planning.lead = { id: '1', building: 'planning', builder: { id: '1000027', login: 'builder-27', name: 'Builder 27' }, charter: 'Goals, priorities and the order of work.', since: '2026-10-01T00:00:00Z', appointed_by: { item_id: '5', href: '/board-room?item=5' } };
+  const yours = docket.matters.filter((m) => m.state === 'needs' && m.route.yours).length;
+  const p = await bootPage('#deck', {
+    feeds: { '/api/bongos/government/docket': docket, '/api/bongos/government/leads': leads },
+    answer: (url) => (/\/pass$/.test(url) ? { status: 200, body: { ok: true } } : null),
+  });
+  assert.equal(p.cls(p.deck(), 'deck-dock__of')[0].textContent, ' of ' + yours + ' to do', 'to do is the routes that are yours');
+  const card = p.cls(p.deck(), 'ask')[0];
+  assert.equal(card.getAttribute('data-ask'), id);
+  assert.equal(p.cls(card, 'ask__waits')[0].textContent, 'waits on you', 'the route says it is yours');
+  p.key('d');
+  const chips = p.cls(p.deck(), 'ask__seats')[0];
+  assert.ok(chips, 'the seats open');
+  const seats = p.cls(p.deck(), 'ask__seat');
+  assert.deepEqual(seats.map((s) => s.getAttribute('title')), ['Planning Lead'], 'only a real Lead in office (the owner is where it waits already)');
+  seats[0].fire('click');
+  await p.wait(450);
+  assert.deepEqual(p.sent, [{ method: 'POST', url: '/api/bongos/government/asks/' + encodeURIComponent(id) + '/pass', body: { seat: 'lead:planning' } }]);
+  assert.match(p.byId.get('streetToast').textContent, /^Passed to .+\. It leaves your deck\.$/);
+  assert.equal(p.cls(p.deck(), 'deck-dock__of')[0].textContent, ' of ' + (yours - 1) + ' to do');
+  // the next card has no stored ask: nothing to pass on
+  const next = p.cls(p.deck(), 'ask')[0];
+  assert.ok(!p.walk(next, (k) => k.getAttribute && k.getAttribute('data-act') === 'pass').length, 'no stored ask, no pass it on');
+});
+
+test('the page: inside Planning the office opens from its top storey; a build-out tap is POST /government/buildouts', async () => {
+  const p = await bootPage('#building=planning', { answer: (url) => (/\/government\/buildouts$/.test(url) ? { status: 201, body: { ok: true, path: 'at_once', rights: { why: 'The founder decides alone.' } } } : null) });
+  const govt = p.byId.get('insideGovt');
+  assert.equal(govt.hidden, false, 'the government layer stands in the panel');
+  assert.ok(p.cls(govt, 'govx-lead').length === 1 && p.cls(govt, 'govx-stack').length === 1);
+  const office = p.byId.get('insideFloors').kids.find((b) => b.getAttribute('data-floor') === 'office');
+  assert.equal(office.getAttribute('data-proto'), null, 'nothing is marked prototype');
+  office.fire('click');
+  const desk = () => (p.byId.get('insideOpenA').hidden ? p.byId.get('insideOpenB') : p.byId.get('insideOpenA'));
+  assert.match(desk().className, /\boffice\b/);
+  const cap = p.walk(desk(), (k) => k.getAttribute && k.getAttribute('data-capsule') === 'floor')[0];
+  assert.ok(cap, 'the owner seat holds Planning, the viewer among it: the capsules are offered');
+  cap.fire('click');
+  await p.wait(60);
+  assert.deepEqual(p.sent, [{ method: 'POST', url: '/api/bongos/government/buildouts', body: { building: 'planning', capsule: 'floor' } }]);
+  assert.equal(p.byId.get('streetToast').textContent, 'Building a new floor now. The founder decides alone.');
+  assert.equal(p.cls(p.byId.get('insideFloors'), 'office-site').length, 0, 'nothing is drawn for this visit only: the server\'s read draws it');
+});
+
+test('the page: a build-out the server files as a vote says so; the preview stores nothing and says that too', async () => {
+  const p = await bootPage('#building=treasury', { answer: (url, body) => (body.capsule === 'committee' ? { status: 201, body: { ok: true, path: 'vote' } } : null) });
+  p.byId.get('insideFloors').kids.find((b) => b.getAttribute('data-floor') === 'office').fire('click');
+  const desk = () => (p.byId.get('insideOpenA').hidden ? p.byId.get('insideOpenB') : p.byId.get('insideOpenA'));
+  p.walk(desk(), (k) => k.getAttribute && k.getAttribute('data-capsule') === 'committee')[0].fire('click');
+  await p.wait(60);
+  assert.equal(p.sent.length, 1);
+  assert.match(p.byId.get('streetToast').textContent, /^Filed for a vote\. The card has its picture\.$/);
+  p.byId.get('insideFloors').kids.find((b) => b.getAttribute('data-floor') === 'office').fire('click');
+  p.walk(desk(), (k) => k.getAttribute && k.getAttribute('data-capsule') === 'annex')[0].fire('click');
+  await p.wait(60);
+  assert.equal(p.sent.length, 2);
+  assert.equal(p.byId.get('streetToast').textContent, 'This preview stores nothing; nothing was built.');
+});
+
+test('the stylesheet: tokens only, the accent only on what needs you, motion dies under reduced motion, 24px targets', () => {
+  const css = read('street-deck.css').replace(/\/\*[\s\S]*?\*\//g, '');
+  assert.doesNotMatch(css, /#[0-9a-f]{3,8}\b|rgba?\(/i, 'no literal colours');
+  assert.doesNotMatch(css, /:root/);
+  assert.match(css, /@media \(prefers-reduced-motion: reduce\) \{[^}]*animation: none !important; transition: none !important;/);
+  for (const m of css.matchAll(/animation: ([a-z-]+) (\d+)(m?s)/g)) {
+    const ms = m[3] === 's' ? Number(m[2]) * 1000 : Number(m[2]);
+    if (/infinite/.test(css.slice(m.index, m.index + 120))) assert.ok(ms >= 20000, m[1] + ': an ambient loop is 20 s or more');
+  }
+  assert.doesNotMatch(css.split('@keyframes').slice(1).join(''), /opacity/, 'motion is transform only');
+  assert.match(css, /\.ask__opt \{[^}]*min-height: 60px/);
+  // task 1004702: the panel rises once and the halo breathes on a 24 s loop; both stop
+  assert.match(css, /\.ask--rise \{ animation: deck-rise \d+ms[^}]*both; \}/, 'the rise is a one-shot');
+  assert.match(css, /\.gov-halo \{[^}]*animation: gov-halo 24s ease-in-out infinite/);
+  const still = /@media \(prefers-reduced-motion: reduce\) \{\s*([^{]*)\{ animation: none !important/.exec(css);
+  assert.ok(still && /\.ask--rise\b/.test(still[1]) && /\.gov-halo\b/.test(still[1]), 'the rise and the halo both stop under reduced motion');
+  // dark is written twice; light is paper: an ink shadow and no glow
+  assert.match(css, /html\[data-theme="dark"\] body\[data-page="street"\][^{]*\{[^}]*--gov-glass:/);
+  assert.match(css, /html:not\(\[data-theme\]\) body\[data-page="street"\][^{]*\{[^}]*--gov-glass:/);
+  const light = /body\[data-page="street"\], body\[data-page="city"\] \{([^}]*)\}/.exec(css)[1];
+  assert.match(light, /--gov-glass-drop: 0 28px 70px color-mix\(in srgb, var\(--ink\)/, 'light mode: an ink shadow');
+  assert.doesNotMatch(light, /--gov-glass-drop:[^;]*var\(--accent/, 'no glow');
+  assert.match(css, /\.ask__text \{[^}]*min-height: 24px; min-width: 24px/);
+  const accent = css.split('\n').filter((l) => /var\(--accent\)|var\(--street-accent-text\)/.test(l)).map((l) => l.split('{')[0].trim());
+  assert.ok(accent.length >= 6);
+  assert.deepEqual(accent.filter((s) => !/needs|--you|--dry|focus-visible|deck-clear__tick/.test(s)), [], 'the accent lights only what needs you (and focus, and the cleared deck\'s lit tick)');
+  const html = read('street.html');
+  assert.ok(html.indexOf('/builders/street-deck.js?') > html.indexOf('/builders/gov-living.js?') && html.indexOf('/builders/street-office.js?') < html.indexOf('/builders/street.js?'), 'the deck and the offices load after the model and before the page');
+  assert.match(html, /<section class="deck" id="streetDeck"[^>]*hidden><\/section>/);
+});