@bongos/core 1.21.113 → 1.21.114

package/tests/hall_gov_living.mjs

@@ -0,0 +1,636 @@
+// tests/hall_gov_living.mjs — the living city's model (modules/hall-ui/public/
+// gov-living.js, task 1004685) over the REAL governor fixtures the harness
+// snapshots, and nothing else: task 1004717 deleted the prototype overlay.
+//
+// What it pins:
+//   1. the nine civic buildings, who holds each (a Lead GET /government/leads
+//      names, else the owner seat), and that nothing is invented without a read;
+//   2. every real docket matter is exactly one ask, and the queue is needs-you
+//      first, then oldest;
+//   3. the ask format refuses what it should and accepts every card in the
+//      past-asks corpus; a matter with no stored ask has no card at all;
+//   4. ALL OF IT IS REAL: every `_sources` label in the whole model is real,
+//      derived or mixed — never anything else — and an `overlay` handed in
+//      changes nothing, field for field;
+//   5. the module is pure: no window, document, fetch or clock in its source, the
+//      same input gives the same model, and the inputs are not mutated.
+//
+// Run:  node --test --test-reporter=tap tests/hall_gov_living.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+// five Leads seated, a room and two build-outs, the docket routed to them (test data)
+import { SEATED, leadsRead as seatedLeads, docketRouted } from './fixtures/gov-seated.mjs';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const FX = path.join(ROOT, 'scripts', 'hall-preview', 'fixtures');
+const SRC = path.join(ROOT, 'modules', 'hall-ui', 'public', 'gov-living.js');
+const G = require(SRC);
+const fx = (name) => JSON.parse(fs.readFileSync(path.join(FX, name + '.json'), 'utf8'));
+// real past asks as the cards they should have been (test data; the hall never reads it)
+const CARDS = JSON.parse(fs.readFileSync(path.join(ROOT, 'tests', 'fixtures', 'government-ask-cards.json'), 'utf8')).cards;
+
+const NOW = Date.parse('2026-10-09T14:00:00.000Z');
+function inputs(overrides = {}) {
+  return {
+    docket: fx('government__docket'),
+    constitution: fx('government__constitution'),
+    goals: fx('goals'),
+    rollups: fx('goals__rollups'),
+    blockers: fx('blockers'),
+    fence: fx('autonomy__fence'),
+    claims: fx('tasks__claimable'),
+    tasks: fx('tasks__status-active'),
+    moving: fx('moving'),
+    sessions: fx('sessions__search'),
+    learnings: fx('learnings'),
+    cost: fx('public__cost-summary'),
+    roster: fx('builders__roster'),
+    me: fx('me'),
+    laws: fx('government__laws'),
+    leads: fx('government__leads'),
+    presets: fx('government__presets'),
+    // the pots, the reserve and the spend cap (task 1004712)
+    treasury: fx('government__treasury'),
+    counts: fx('government__counts'),
+    now: NOW,
+    ...overrides,
+  };
+}
+const model = (overrides) => G.livingModel(inputs(overrides));
+// The docket as a server that did not route it serves it (no `routed`, no `route`).
+function unrouted(d = fx('government__docket')) {
+  delete d.routed;
+  d.matters.forEach((m) => { delete m.route; });
+  return d;
+}
+// the kind of thing the deleted prototype overlay said, every concept it held
+const OLD_OVERLAY = {
+  _proto: 'Prototype data: concepts not yet in the database',
+  owner: { id: '1000025' },
+  leads: [{ building: 'rules', lead: '1000301', since: '2026-09-01', charter: { scope: 'x', can_build_without_vote: true }, deputies: ['3'], committees: [{ key: 'c', name: 'C', members: ['1000025'] }] }],
+  laws: [{ id: 'design-exact', text: 'Build the approved design exactly', locks: [{ setting: 'wandering', max: 'focused' }] }],
+  personal_settings: [{ key: 'parallel_agents', label: 'Agents at once', values: [1, 2, 3], value: 3 }],
+  strictness: { current: 'factory', presets: [{ key: 'factory', name: 'Factory', line: 'x' }] },
+  pots: { reserve_usd: 999, basis: 'x', items: [{ goal_id: '1000106', budget_usd: 1, spent_usd: 2 }] },
+  buildouts: [{ id: 'b', building: 'rules', authorised: true, label: 'Invented', progress: 0.5 }],
+  build_rights: { rules: { capsules: { floor: { without_vote: true } } } },
+  asks: [{ id: 'criteria_uat:1000184', question: 'An invented rewrite?', options: [{ key: 'a', label: 'A', result: 'a' }, { key: 'b', label: 'B', result: 'b' }], recommend: { key: 'a', why: 'x' }, waits_on: 'owner', if_nobody_answers: 'x' }],
+  proto_asks: [{ id: 'proto:pot:1', building: 'treasury', question: 'Lend it?', options: [{ key: 'a', label: 'A', result: 'a' }, { key: 'b', label: 'B', result: 'b' }], recommend: { key: 'a', why: 'x' }, waits_on: 'owner', if_nobody_answers: 'x' }],
+};
+
+// ---------------------------------------------------------------------------
+// 1. the buildings
+// ---------------------------------------------------------------------------
+
+test('the nine civic buildings are all present, in the docket\'s order, named by it', () => {
+  const m = model();
+  const docket = fx('government__docket');
+  assert.deepEqual(m.buildings.map((b) => b.key), G.BUILDING_KEYS.slice());
+  assert.equal(m.buildings.length, 9);
+  assert.deepEqual(m.buildings.map((b) => b.key), docket.buildings.map((b) => b.key), 'the same nine the docket serves');
+  for (const b of m.buildings) {
+    const d = docket.buildings.find((x) => x.key === b.key);
+    assert.equal(b.name, d.name);
+    assert.equal(b.decision.rule, d.decision.rule, `${b.key}: how it decides is the docket's`);
+    assert.ok(b.activity >= 0 && b.activity <= 1 && b.lit >= 0 && b.lit <= 1, `${b.key}: activity and lit are 0..1`);
+  }
+  // with every feed missing the city still has its nine buildings, and nothing else
+  const empty = G.livingModel({});
+  assert.deepEqual(empty.buildings.map((b) => b.key), G.BUILDING_KEYS.slice());
+  assert.equal(empty.city.asks.length, 0, 'no feed, no asks: nothing is invented');
+  assert.equal(empty.districts.length, 0);
+  assert.ok(empty.buildings.every((b) => b.lead === null && b.holder === null && b.build_rights === null && b.structure.committees.length === 0 && b.construction.length === 0), 'no Lead, holder, right or build-out is invented');
+  assert.equal(empty.owner, null);
+  assert.equal(empty.strictness, null, 'no preset read: no preset');
+  assert.equal(empty.city.laws.length, 0, 'no law read: no law');
+  assert.equal(empty.city.spend.limit, null, 'no treasury read: the limit is unknown, not "none"');
+});
+
+test('a building with no Lead falls to the owner seat — its holder, and the seat its asks wait on', () => {
+  const read = seatedLeads();
+  const m = model({ leads: read, docket: unrouted() });
+  const owner = read.owner.builders[0];
+  for (const key of ['charter', 'rules', 'disputes', 'automation']) {
+    const b = m.buildings.find((x) => x.key === key);
+    assert.equal(b.lead, null, `${key}: no Lead`);
+    assert.equal(b.held_by, 'owner');
+    assert.equal(b.holder.id, String(owner.id), `${key}: the owner holds it`);
+  }
+  for (const l of SEATED) {
+    const b = m.buildings.find((x) => x.key === l.building);
+    assert.equal(b.held_by, 'lead');
+    assert.equal(b.lead.id, l.lead);
+  }
+  // on a docket the server did not route, an ask at an unseated building waits on the owner seat
+  const ask = m.city.asks.find((a) => a.building === 'disputes');
+  assert.equal(ask.waits_on.seat, 'lead:disputes');
+  assert.equal(ask.waits_on.fell_to_owner, true);
+  assert.equal(ask.waits_on.real, false, 'not the server\'s route');
+  assert.equal(ask.needs_you, true, 'the viewer is among the owner seat');
+  const review = m.city.asks.find((a) => a.building === 'review' && a.state === 'needs');
+  assert.equal(review.waits_on.seat, 'lead:review');
+  assert.equal(review.needs_you, false, 'Review has its own Lead');
+});
+
+// ---------------------------------------------------------------------------
+// 2. the asks
+// ---------------------------------------------------------------------------
+
+test('every real docket matter appears as exactly one ask, with its real id, state and text', () => {
+  const m = model();
+  const docket = fx('government__docket');
+  const count = {};
+  m.city.asks.forEach((a) => { count[a.id] = (count[a.id] || 0) + 1; });
+  for (const matter of docket.matters) {
+    assert.equal(count[matter.id], 1, `${matter.id} is one ask`);
+    const ask = m.city.asks.find((a) => a.id === matter.id);
+    assert.equal(ask.state, matter.state);
+    assert.equal(ask.raw.title, matter.title, 'the raw text is the docket\'s own');
+    assert.equal('proto' in ask, false);
+  }
+  // the open blockers are all docket matters already, so none is added twice
+  for (const b of fx('blockers').blockers) assert.equal(count['blockers:' + b.id], 1);
+  assert.equal(m.city.asks.length, docket.matters.length, 'nothing beyond the docket\'s matters');
+  // every building lists exactly the asks standing at it
+  assert.equal(m.buildings.reduce((n, b) => n + b.asks.length, 0), m.city.asks.length);
+});
+
+test('the queue is needs-you first, then oldest first, for high volume', () => {
+  // the dry pot's borrow, passed on to the People Lead: it needs someone, not you
+  const d = fx('government__docket');
+  const b = d.matters.find((x) => x.source === 'treasury_spending');
+  b.route = { ...b.route, seat: 'lead:people', label: 'the People Lead', asked: 'lead:people', fell_to_owner: false, yours: false };
+  const asks = model({ docket: d }).city.asks;
+  const tier = (a) => (a.needs_you ? 0 : { needs: 1, moving: 2, settled: 3 }[a.state]);
+  assert.ok(asks.some((a) => a.needs_you) && asks.some((a) => !a.needs_you && a.state === 'needs'), 'both tiers are present, so the order is exercised');
+  for (let i = 1; i < asks.length; i++) {
+    const a = asks[i - 1];
+    const c = asks[i];
+    assert.ok(tier(a) <= tier(c), `${a.id} before ${c.id}: tiers in order`);
+    if (tier(a) !== tier(c)) continue;
+    const ta = a.opened_at ? Date.parse(a.opened_at) : null;
+    const tb = c.opened_at ? Date.parse(c.opened_at) : null;
+    if (ta != null && tb != null) assert.ok(ta <= tb, `${a.id} before ${c.id}: oldest first`);
+    else assert.ok(!(ta == null && tb != null), `${a.id} before ${c.id}: a dated ask before an undated one`);
+  }
+  assert.equal(asks[asks.length - 1].state, 'settled', 'the settled sitting is last');
+  // the comparator on its own, with one ask that waits on the viewer
+  const mk = (id, state, opened_at, needs_you) => ({ id, state, opened_at, needs_you });
+  const sorted = [mk('c', 'needs', '2026-10-01T00:00:00Z', false), mk('a', 'settled', '2026-01-01T00:00:00Z', false), mk('d', 'needs', null, false), mk('b', 'needs', '2026-10-05T00:00:00Z', true), mk('e', 'needs', '2026-09-01T00:00:00Z', false)].sort(G.compareAsks);
+  assert.deepEqual(sorted.map((a) => a.id), ['b', 'e', 'c', 'd', 'a']);
+});
+
+// ---------------------------------------------------------------------------
+// 3. the ask format
+// ---------------------------------------------------------------------------
+
+const GOOD = {
+  question: 'Turn unattended building back on?',
+  options: [
+    { key: 'on', label: 'Turn it on', result: 'Agents work through the night.' },
+    { key: 'off', label: 'Keep it off', result: 'Nothing builds unless someone starts a session.' },
+  ],
+  recommend: { key: 'off', why: 'It was paused for a check.' },
+  waits_on: 'owner',
+  if_nobody_answers: 'It stays off.',
+};
+const card = (over) => ({ ...JSON.parse(JSON.stringify(GOOD)), ...over });
+
+test('askFormat refuses a question over twelve words, and the other ways an ask goes wrong', () => {
+  assert.equal(G.askFormat(GOOD).ok, true);
+  const long = G.askFormat(card({ question: 'Should we turn the unattended building back on now that the evaluation is done?' }));
+  assert.equal(long.ok, false);
+  assert.deepEqual(long.errors.map((e) => e.rule), ['too_long']);
+  assert.equal(long.question_words, 14);
+  const cases = {
+    not_a_question: card({ question: 'Turn unattended building back on.' }),
+    more_than_one: card({ question: 'It is off. Turn it on?' }),
+    markup: card({ question: 'Turn **unattended** building on?' }),
+    count: card({ options: [GOOD.options[0]] }),
+    label_too_long: card({ options: [{ key: 'on', label: 'Turn it on right now please', result: 'On.' }, GOOD.options[1]] }),
+    not_one_line: card({ options: [GOOD.options[0], { key: 'off', label: 'Keep it off', result: 'Off.\nAnd quiet.' }] }),
+    duplicate: card({ options: [GOOD.options[0], { ...GOOD.options[1], key: 'on' }], recommend: { key: 'on', why: 'x' } }),
+    unknown_key: card({ recommend: { key: 'maybe', why: 'It was paused.' } }),
+    no_why: card({ recommend: { key: 'off', why: '' } }),
+  };
+  for (const [rule, c] of Object.entries(cases)) {
+    const r = G.askFormat(c);
+    assert.equal(r.ok, false, rule);
+    assert.ok(r.errors.some((e) => e.rule === rule), `${rule}: ${JSON.stringify(r.errors)}`);
+  }
+  assert.equal(G.askFormat(card({ options: [...GOOD.options, GOOD.options[0], GOOD.options[1]] })).ok, false, 'four answers is too many');
+  assert.ok(G.askFormat(card({ waits_on: '' })).errors.some((e) => e.field === 'waits_on'));
+  assert.ok(G.askFormat(card({ if_nobody_answers: '' })).errors.some((e) => e.field === 'if_nobody_answers'));
+  assert.equal(G.askFormat(null).ok, false, 'no card at all is the raw form, refused');
+  assert.equal(G.askFormat(card({ question: 'Upgrade the setup service, version 1.20.82, now?' })).ok, true, 'a version number is not a sentence break');
+});
+
+test('askFormat accepts every card in the past-asks corpus, and each one reads at a glance', () => {
+  assert.ok(CARDS.length >= fx('government__docket').matters.length);
+  for (const a of CARDS) {
+    const r = G.askFormat(a);
+    assert.equal(r.ok, true, `${a.id}: ${JSON.stringify(r.errors)}`);
+    assert.ok(r.question_words <= G.ASK_RULES.question_words);
+    assert.equal(G.slopScore(a.question).slop, false, `${a.id}: the question is not slop`);
+    assert.ok(a.options.some((o) => o.key === a.recommend.key), `${a.id}: recommends an answer it offers`);
+  }
+});
+
+test('a matter with no stored ask has no card: the board shows its own words, never a made-up rewrite', () => {
+  const m = model({ overlay: OLD_OVERLAY });
+  assert.ok(m.city.asks.length > 0);
+  // (an ask its agent stored in the ask shape is shown: the dry pot's borrow, task 1004712)
+  const stored = m.city.asks.filter((a) => a.ask_real);
+  assert.deepEqual(stored.map((a) => a.id), ['treasury_spending:1']);
+  assert.equal(stored[0].format.ok, true);
+  for (const a of m.city.asks.filter((x) => !x.ask_real)) {
+    assert.equal(a.human, null, a.id + ': no card is invented');
+    assert.equal(a.shown, null);
+    assert.equal(a.format.ok, false);
+  }
+  assert.ok(!m.city.asks.some((a) => a.id.startsWith('proto:')), 'and no sample ask joins the docket\'s');
+  // (a red-team report's raw text is withheld in the fixtures, so the long one here is a criterion)
+  const criterion = m.city.asks.find((a) => a.id === 'criteria_uat:1000380');
+  const s = criterion.raw.slop;
+  assert.equal(s.slop, true, 'the raw criterion is slop by every measure');
+  assert.ok(s.words > G.SLOP.words && s.sentences > G.SLOP.sentences && s.markup > 0);
+  assert.ok(s.score > 0.5 && s.score <= 1);
+  assert.deepEqual(G.slopScore(''), { words: 0, sentences: 0, longest_sentence: 0, lines: 0, markup: 0, score: 0, slop: false, why: [] });
+});
+
+// ---------------------------------------------------------------------------
+// 4. all of it real
+// ---------------------------------------------------------------------------
+
+// every `_sources` label in a model, with where it sits
+function labelsOf(v, where = '$', out = []) {
+  if (Array.isArray(v)) v.forEach((x, i) => labelsOf(x, `${where}[${i}]`, out));
+  else if (v && typeof v === 'object') {
+    if (v._sources) for (const [f, l] of Object.entries(v._sources)) out.push({ at: `${where}.${f}`, label: l });
+    for (const [k, x] of Object.entries(v)) if (k !== '_sources') labelsOf(x, `${where}.${k}`, out);
+  }
+  return out;
+}
+const ALLOWED = new Set(['real', 'derived', 'mixed']);
+
+test('every field is real, derived or mixed: no other label anywhere in the model', () => {
+  const full = model({ leads: seatedLeads(), docket: docketRouted(), me: meWithLaws() });
+  for (const m of [model(), full, model({ docket: unrouted() }), G.livingModel({}), G.livingModel({ docket: fx('government__docket') })]) {
+    const all = labelsOf(m);
+    const bad = all.filter((x) => !ALLOWED.has(x.label));
+    assert.deepEqual(bad, [], 'only real, derived and mixed');
+  }
+  const n = labelsOf(full).length;
+  assert.ok(n > 500, `${n} labels were walked, not a vacuous check`);
+  assert.deepEqual(Object.values(G.SOURCES).sort(), ['derived', 'mixed', 'real']);
+  // and the walk would catch one that is not (it is not vacuous)
+  const lie = JSON.parse(JSON.stringify(full));
+  lie.buildings.find((b) => b.key === 'release').structure._sources = { committees: 'proto' };
+  assert.deepEqual(labelsOf(lie).filter((x) => !ALLOWED.has(x.label)).map((x) => x.at), ['$.buildings[7].structure.committees']);
+});
+
+test('an overlay handed in changes nothing: the model is the same, field for field', () => {
+  for (const over of [{}, { leads: seatedLeads(), docket: docketRouted() }, { leads: null, treasury: null, presets: null, laws: null }]) {
+    assert.deepEqual(model({ ...over, overlay: OLD_OVERLAY }), model(over));
+  }
+  assert.equal('overlay_note' in model(), false, 'there is no prototype note to carry');
+});
+
+test('the real reads land where the model says: spend, traffic, districts, readings', () => {
+  const m = model();
+  const cost = fx('public__cost-summary');
+  const day = cost.daily.find((d) => d.day.slice(0, 10) === '2026-10-09');
+  const month = cost.by_month.find((x) => x.month === '2026-10');
+  assert.equal(m.city.spend.today_usd, Math.round(day.amount_usd * 100) / 100);
+  assert.equal(m.city.spend.month_usd, Math.round(month.total_usd * 100) / 100);
+  assert.equal(m.city.spend.limit, 'none', 'no spend limit: the treasury\'s cap is off');
+  const claims = fx('tasks__claimable').active_claims;
+  assert.equal(m.city.traffic.agents, claims.length, 'every active claim is an agent on the move');
+  assert.equal(m.city.traffic.moving, fx('moving').moving);
+  const placedTotal = Object.values(m.city.traffic.by_building).reduce((n, x) => n + x, 0);
+  assert.equal(placedTotal + m.city.traffic.unplaced, claims.length);
+  assert.equal(m.buildings.reduce((n, b) => n + b.agents, 0), placedTotal);
+  const open = fx('goals').goals.filter((g) => g.status === 'open');
+  assert.deepEqual(m.districts.map((d) => d.goal_id), open.map((g) => String(g.id)), 'one district per open goal, in the goals\' order');
+  const r = fx('goals__rollups').rollups.find((x) => String(x.goal_id) === m.districts[0].goal_id);
+  assert.equal(m.districts[0].counts.shipped, r.done);
+  const money = fx('government__docket').readings.find((x) => x.key === 'money');
+  assert.equal(m.city.spend.unattended.ceiling_usd, money.value.ceiling_usd);
+  assert.ok(m.buildings.find((b) => b.key === 'treasury').readings.some((x) => x.key === 'money'));
+});
+
+test('the treasury: a dry pot asks to borrow, routed to the Treasury (task 1004712)', () => {
+  const m = model();
+  const t = fx('government__treasury');
+  const dry = m.districts.filter((d) => d.pot && d.pot.dry);
+  assert.equal(dry.length, 1, 'one pot is dry');
+  assert.equal(dry[0].pot.real, true);
+  assert.equal(dry[0]._sources.pot, 'real');
+  assert.equal(dry[0].pot.borrow_ask_id, 'treasury_spending:1', 'it asks to borrow from the reserve, on the docket');
+  const borrow = m.city.asks.find((a) => a.id === dry[0].pot.borrow_ask_id);
+  assert.equal(borrow.building, 'treasury');
+  assert.equal(borrow.ask_real, true, 'its ask is stored in the ask shape');
+  assert.equal(borrow.waits_on.seat, 'owner', 'the Treasury is unseated, so borrowing falls to the owner');
+  assert.equal(borrow.needs_you, true);
+  assert.equal(m.city.spend.reserve_usd, t.reserve.usd);
+  assert.equal(m.city.spend.cap.on, false);
+  // without the read, no district shows a pot, and nothing about the reserve is said
+  const none = model({ treasury: null });
+  assert.equal(none.districts.filter((d) => d.pot).length, 0);
+  assert.deepEqual([none.city.spend.reserve_usd, none.city.spend.pots_basis, none.city.spend.limit, none.city.spend.cap], [null, null, null, null]);
+});
+
+test('the build-outs stand at their buildings, from GET /government/leads alone', () => {
+  const m = model({ leads: seatedLeads(), docket: docketRouted() });
+  const release = m.buildings.find((b) => b.key === 'release').construction;
+  const treasury = m.buildings.find((b) => b.key === 'treasury').construction;
+  assert.deepEqual(release.map((c) => [c.kind, c.authorised, c.progress]), [['buildout', true, 0.55]], 'a floor going up, at its real progress');
+  assert.deepEqual(treasury.map((c) => [c.kind, c.authorised, c.ask_id, c.illustrative]), [['scaffold', false, 'board:77', false]], 'an annex waiting on its sitting');
+  assert.deepEqual(model().buildings.map((b) => b.construction.length).reduce((a, x) => a + x, 0), 0, 'the hub has built nothing and no sitting is open: nothing stands');
+});
+
+test('my agents: no law in force, nothing locked, whatever the preset; every row is /me\'s own', () => {
+  const a = model().myAgents;
+  assert.equal(a.strictness, null, 'no preset is in force on the hub');
+  assert.equal(a.locked, 0);
+  const wander = a.settings.find((s) => s.key === 'wandering');
+  assert.equal(wander.value, fx('me').wandering.effective_key, 'the viewer\'s own value');
+  assert.equal(wander.effective, wander.value);
+  assert.ok(a.settings.every((s) => !s.locked && !s.lockedBy && !s.advisedBy), 'no row is locked or advised by anything but a law in force');
+  assert.ok(!a.settings.some((s) => s.key === 'parallel_agents'), 'a setting no table holds is not a row');
+});
+
+test('governance is a held position: a viewer with no seat gets no governance tab', () => {
+  const m = model();
+  assert.deepEqual(m.viewer.tabs, ['city', 'agents', 'governance']);
+  const stranger = { builder: { id: '424242', github_login: 'builder-9999', display_name: 'Builder 9999', rank: 'xenos' } };
+  const s = model({ me: stranger });
+  assert.equal(s.viewer.has_seat, false);
+  assert.deepEqual(s.viewer.tabs, ['city', 'agents']);
+  assert.equal(s.city.ask_counts.needs_you, 0, 'and nothing waits on them');
+});
+
+test('governance is a held position: /me\'s server-resolved positions decide the seats, and they are real (task 1004713)', () => {
+  const me = fx('me');
+  const m = model({ me });
+  assert.deepEqual(m.viewer.seats.map((s) => s.role), me.positions.held.map((p) => p.kind), 'the seats are /me\'s');
+  assert.equal(m.viewer._sources.seats, 'real');
+  assert.equal(m.viewer._sources.tabs, 'real');
+  const none = model({ me: { ...me, positions: { held: [], title: null, has_position: false } } });
+  assert.equal(none.viewer.has_seat, false, 'the server said none');
+  assert.deepEqual(none.viewer.tabs, ['city', 'agents']);
+  const lead = model({ me: { builder: { id: '424242', rank: 'thetes' }, positions: { held: [{ kind: 'lead', seat: 'lead:review', building: 'review', title: 'Review Lead' }], title: 'Review Lead', has_position: true } } });
+  assert.deepEqual(lead.viewer.tabs, ['city', 'agents', 'governance'], 'a Lead the server seats gets the governance tab');
+  assert.equal(lead.viewer.seats[0].title, 'Review Lead');
+  // without /me's positions block, the seats come from the real reads (the owner seat), derived
+  const bare = model({ me: { builder: me.builder } });
+  assert.equal(bare.viewer._sources.seats, 'derived');
+  assert.ok(bare.viewer.seats.some((s) => s.role === 'owner'), 'the viewer is among the owner seat GET /government/leads names');
+});
+
+// ---------------------------------------------------------------------------
+// 5. purity
+// ---------------------------------------------------------------------------
+
+test('pure: no window, document, fetch or clock in the source', () => {
+  const src = fs.readFileSync(SRC, 'utf8');
+  // comments may name what the file does not do; code may not
+  const code = src.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:'"`\\])\/\/.*$/gm, '$1');
+  const tail = "typeof window !== 'undefined' ? window : globalThis";
+  assert.ok(code.includes(tail), 'the UMD root test is the one mention of window');
+  const body = code.replace(tail, '');
+  for (const [name, re] of Object.entries({
+    window: /\bwindow\b/, document: /\bdocument\b/, fetch: /\bfetch\b/, 'Date.now': /Date\.now/,
+    'new Date()': /new Date\(\s*\)/, XMLHttpRequest: /XMLHttpRequest/, localStorage: /localStorage/, setTimeout: /setTimeout|setInterval/,
+  })) assert.doesNotMatch(body, re, `${name} must not appear in gov-living.js`);
+  assert.doesNotMatch(body, /\boverlay\b|'proto'/, 'and it reads no overlay and labels nothing prototype');
+  assert.match(code, /root\.GovLiving = api/);
+  assert.match(code, /module\.exports = api/);
+});
+
+test('pure: the same input gives the same model, and the inputs are left alone', () => {
+  const a = inputs();
+  const before = JSON.stringify(a);
+  const one = G.livingModel(a);
+  assert.equal(JSON.stringify(a), before, 'livingModel does not mutate its inputs');
+  assert.deepEqual(G.livingModel(inputs()), one);
+  assert.equal(one.generated_at, new Date(NOW).toISOString(), 'the clock is the one passed in');
+});
+
+// ---------------------------------------------------------------------------
+// the law book (task 1004706) and its locks (task 1004707)
+// ---------------------------------------------------------------------------
+
+// what the server did to THIS viewer's settings (task 1004707): GET /me's laws.locks
+function meWithLaws() {
+  const me = fx('me');
+  // the slice as the server answers it under the law: the effective value obeys it
+  me.interaction.effective = { ...me.interaction.effective, verbosity: 'concise' };
+  me.laws = {
+    inject: true,
+    contract: 'Project laws — passed by a vote of this project\'s government.\n1. Ask like a human',
+    laws: [{ id: '11', no: 1, text: 'Ask like a human', effect_on_ai: null, locks: [{ setting: 'verbosity', value: 'concise' }, { setting: 'wandering', value: 'locked' }, { setting: 'ask_format', value: 'card' }] }],
+    locks: [
+      { setting: 'verbosity', law_id: '11', law_no: 1, law_text: 'Ask like a human', value: 'concise', route: 'interaction', enforced: true, from: 'detailed', to: 'concise' },
+      { setting: 'wandering', law_id: '11', law_no: 1, law_text: 'Ask like a human', value: 'locked', route: 'wandering', enforced: true, from: me.wandering.effective_key, to: me.wandering.effective_key },
+      { setting: 'ask_format', law_id: '11', law_no: 1, law_text: 'Ask like a human', value: 'card', enforced: false, reason: 'not_a_personal_setting' },
+    ],
+  };
+  return me;
+}
+
+test('a law in force locks a real setting through GET /me, whatever an overlay says', () => {
+  const m = model({ me: meWithLaws() });
+  const verb = m.myAgents.settings.find((s) => s.key === 'verbosity');
+  assert.equal(verb.locked, true);
+  assert.equal(verb.effective, 'concise', 'the server\'s effective value');
+  assert.equal(verb.value, 'detailed', 'the viewer\'s own choice, still on record');
+  assert.deepEqual(verb.lockedBy, { law_id: 'law:11', no: 1, text: 'Ask like a human', real: true });
+  for (const f of ['effective', 'locked', 'lockedBy']) assert.equal(verb._sources[f], 'real', f);
+  assert.equal(m.myAgents.settings.find((s) => s.key === 'wandering').lockedBy.law_id, 'law:11');
+  assert.equal(m.myAgents.locked, 2);
+  // a lock the server could not enforce locks nothing (no table holds ask_format yet)
+  assert.ok(!m.myAgents.settings.some((s) => s.key === 'ask_format'), 'no claim of an enforcement that is not happening');
+  assert.deepEqual(model({ me: meWithLaws(), overlay: OLD_OVERLAY }).myAgents, m.myAgents);
+});
+
+test('a law the project passed (GET /government/laws) stands in the book; a repealed one does not', () => {
+  const book = {
+    laws: [
+      { id: '11', text: 'Every screen change carries two shots', effect_on_ai: 'Agents attach a before and an after picture.', locks: [{ setting: 'render', value: 'rich' }], in_force: true, passed_at: '2026-10-09T12:00:00.000Z', passed_by: { item_id: '31', government: 'Timocratic Republic', proposer: { id: '42' }, yes: [] } },
+      { id: '9', text: 'An old rule nobody keeps', in_force: false, passed_at: '2026-09-01T00:00:00.000Z', repealed_at: '2026-10-01T00:00:00.000Z', passed_by: { item_id: '20', government: 'Monarchy / BDFL' } },
+    ],
+  };
+  const m = model({ laws: book });
+  const real = m.city.laws.find((l) => l.id === 'law:11');
+  assert.ok(real, 'the passed law is in the book');
+  assert.equal(real.real, true);
+  assert.equal(real.origin, 'vote');
+  assert.equal(real.text, 'Every screen change carries two shots');
+  assert.equal(real.passed_by.name, 'Timocratic Republic', 'passed by the government in force on its day');
+  assert.equal(real.passed_at, '2026-10-09T12:00:00.000Z');
+  assert.deepEqual(real.locks, [{ setting: 'render', value: 'rich' }]);
+  for (const f of ['id', 'text', 'passed_by', 'passed_at', 'effect_on_ai', 'locks']) assert.equal(real._sources[f], 'real', f);
+  assert.ok(!m.city.laws.some((l) => l.id === 'law:9'), 'a repealed law is not in force');
+  assert.ok(m.city.laws.every((l) => l.real), 'every law in the book is real');
+  // the BOOK's locks are not read for My agents: what a lock did to the viewer is GET /me's laws.locks
+  assert.deepEqual(m.myAgents.settings.filter((s) => s.lockedBy), []);
+  // the hub has passed no law: the book holds only the rule the docket says the project runs
+  assert.deepEqual(model().city.laws.map((l) => l.origin), ['docket']);
+  assert.deepEqual(model({ laws: null }).city.laws.map((l) => l.id), model().city.laws.map((l) => l.id));
+});
+
+// A Lead the government really appointed (task 1004709), as GET /government/leads
+// answers it: Planning led by builder 1000027, every other building unseated, and
+// the owner seat held by the Archons (the founding one first).
+function leadsRead() {
+  const read = fx('government__leads');
+  const p = read.buildings.find((b) => b.building === 'planning');
+  p.lead = { id: '1', building: 'planning', builder: { id: '1000027', login: 'builder-2016', name: 'Builder 2016' }, charter: 'Goals, priorities and the order of work.', since: '2026-10-09T12:00:00.000Z', appointed_by: { item_id: '40', href: '/board-room?item=40' } };
+  p.answers = { seat: 'lead:planning', builder_ids: ['1000027'], fell_to_owner: false };
+  read.seated = 1;
+  return read;
+}
+
+test('a Lead the government appointed (GET /government/leads) is on their building; every unseated building falls to the owner', () => {
+  const read = leadsRead();
+  const m = model({ leads: read });
+  assert.equal(m.seats_real, true);
+  const planning = m.buildings.find((b) => b.key === 'planning');
+  assert.deepEqual(planning.lead, { since: '2026-10-09T12:00:00.000Z', id: '1000027', login: 'builder-2016', name: 'Builder 2016' });
+  assert.equal(planning.held_by, 'lead');
+  assert.deepEqual(planning.charter, { scope: 'Goals, priorities and the order of work.' });
+  assert.deepEqual(planning.answers, { seat: 'lead:planning', ids: ['1000027'], fell_to_owner: false });
+  for (const f of ['lead', 'holder', 'charter', 'answers']) assert.equal(planning._sources[f], 'real', f);
+  assert.equal(planning._sources.held_by, 'derived');
+  const owner = read.owner.builders[0];
+  assert.equal(m.owner.id, String(owner.id), 'the owner is the read\'s');
+  for (const b of m.buildings.filter((x) => x.key !== 'planning')) {
+    assert.equal(b.lead, null, `${b.key}: no Lead`);
+    assert.equal(b.held_by, 'owner');
+    assert.equal(b.holder.id, String(owner.id), `${b.key}: held by the owner`);
+    assert.equal(b.answers.fell_to_owner, true);
+    assert.deepEqual(b.answers.ids, read.owner.builders.map((x) => String(x.id)), `${b.key}: the owner seat answers`);
+  }
+  // without the read, nobody leads anything and nobody is named the owner
+  const before = model({ leads: null });
+  assert.equal(before.seats_real, false);
+  assert.ok(before.buildings.every((b) => b.lead === null && b.holder === null && b.answers === null));
+  assert.equal(before.owner, null);
+});
+
+test("the hub has seated no Lead yet: with its read every building is the owner's", () => {
+  const m = model({ leads: fx('government__leads') });
+  assert.ok(m.buildings.every((b) => b.lead === null && b.held_by === 'owner'), 'every building falls to the owner');
+  assert.ok(m.buildings.every((b) => b._sources.lead === 'real' && b._sources.holder === 'real'));
+  assert.equal(G.countsOf(model({ counts: null })).on_you, fx('government__docket').matters.filter((x) => x.state === 'needs' && x.route.yours).length, 'the docket\'s own routes');
+});
+
+// ---------------------------------------------------------------------------
+// 6. the stored ask (task 1004703): the agent's own card
+// ---------------------------------------------------------------------------
+
+// A card as GET /government/docket and GET /blockers carry it (modules/government/asks.js).
+const STORED = {
+  question: 'Pick the host for the new site?',
+  options: [
+    { key: 'cheap', label: 'The cheap host', result: 'Ten dollars a month, slower builds.', act: 'go ahead' },
+    { key: 'fast', label: 'The fast host', result: 'Forty dollars a month, quick builds.' },
+  ],
+  recommend: { key: 'cheap', why: 'The site is small for now.' },
+  waits_on: 'owner',
+  if_nobody_answers: 'The site waits, unbuilt.',
+  detail: 'The long story rides along.',
+  written_at: '2026-10-09T12:00:00.000Z',
+};
+function docketWithAsk(id) {
+  const d = fx('government__docket');
+  d.matters.find((m) => m.id === id).ask = JSON.parse(JSON.stringify(STORED));
+  return d;
+}
+
+test('a matter that carries its stored ask is drawn from it', () => {
+  const id = 'override_requests:1000017';
+  const m = model({ docket: docketWithAsk(id) });
+  const a = m.city.asks.find((x) => x.id === id);
+  assert.equal(a.ask_real, true);
+  assert.equal(a.human.question, STORED.question);
+  assert.equal(a.format.ok, true);
+  assert.equal(a.shown, a.human);
+  assert.equal(a.raw.title, fx('government__docket').matters.find((x) => x.id === id).title, 'the matter\'s own words stay its raw form');
+  assert.deepEqual([a._sources.human, a._sources.format, a._sources.shown], ['real', 'derived', 'derived']);
+  assert.equal(a._sources.waits_on, 'real', 'who it waits on is the server\'s route (task 1004705)');
+  // a matter without one has none
+  const plain = m.city.asks.find((x) => x.source === 'criteria_uat');
+  assert.equal(plain.ask_real, false);
+  assert.equal(plain.human, null);
+  // a stored card that is not one (no question) is ignored, never shown
+  const d = fx('government__docket');
+  d.matters.find((x) => x.id === id).ask = { options: [] };
+  assert.equal(model({ docket: d }).city.asks.find((x) => x.id === id).ask_real, false);
+});
+
+// ---------------------------------------------------------------------------
+// the direction desk (task 1004705): who an ask waits on is the server's route
+// ---------------------------------------------------------------------------
+
+test('a routed docket decides what needs you: the route\'s seat and its yours', () => {
+  const docket = fx('government__docket');
+  assert.equal(docket.routed, true, 'the fixture is routed, as the server serves it');
+  // half the matters are not the viewer's
+  const d = fx('government__docket');
+  d.matters.forEach((m, i) => { if (i % 2) m.route = { ...m.route, seat: 'lead:review', label: 'the Review Lead', fell_to_owner: false, yours: false }; });
+  const m = model({ docket: d, counts: null });
+  assert.equal(m.routed, true);
+  for (const matter of d.matters) {
+    const a = m.city.asks.find((x) => x.id === matter.id);
+    assert.equal(a.waits_on.seat, matter.route.seat, `${a.id}: the route's seat`);
+    assert.equal(a.waits_on.real, true);
+    assert.equal(a.needs_you, a.state === 'needs' && matter.route.yours, `${a.id}: needs you is the route's word`);
+    assert.equal(a._sources.needs_you, 'derived');
+    assert.equal(a._sources.waits_on, 'real');
+  }
+  const c = G.countsOf(m);
+  const yours = d.matters.filter((x) => x.state === 'needs' && x.route.yours).length;
+  assert.equal(c.on_you, yours, 'to do counts only the routes that are yours');
+  assert.equal(c.on_others, d.matters.filter((x) => x.state === 'needs').length - yours, 'the rest waits on others');
+  assert.deepEqual([c._sources.on_you, c._sources.on_others], ['derived', 'derived']);
+});
+
+test('an ask nobody answers is settled with its own line, on nobody\'s to do', () => {
+  const d = fx('government__docket');
+  const target = d.matters.find((m) => m.state === 'needs');
+  target.route = { ...target.route, yours: false, nobody: { why: 'lapsed', outcome: 'It stays open on the Disputes desk.' } };
+  const m = model({ docket: d, counts: null });
+  const a = m.city.asks.find((x) => x.id === target.id);
+  assert.equal(a.state, 'settled');
+  assert.equal(a.needs_you, false);
+  assert.deepEqual(a.nobody, { why: 'lapsed', outcome: 'It stays open on the Disputes desk.' });
+  assert.equal(G.isOnYou(a) || G.isOnOthers(a), false, 'neither to do nor waiting on others');
+  assert.equal(G.countsOf(m).on_you, model({ counts: null }).city.counts.on_you - 1);
+});
+
+test('a docket routed for another viewer gives this viewer nothing to do', () => {
+  const stranger = { builder: { id: '424242', github_login: 'builder-9999', display_name: 'Builder 9999', rank: 'xenos' } };
+  const m = model({ me: stranger, counts: null });
+  assert.equal(m.city.asks.filter((a) => a.needs_you).length, 0);
+  assert.equal(G.countsOf(m).on_you, 0);
+});
+
+test('an open blocker read from GET /blockers carries its stored ask the same way', () => {
+  const bl = fx('blockers');
+  const docket = fx('government__docket');
+  // a blocker the docket does not carry (a viewer without the docket's blockers)
+  docket.matters = docket.matters.filter((x) => x.source !== 'blockers');
+  bl.blockers[0].ask = JSON.parse(JSON.stringify(STORED));
+  const a = model({ docket, blockers: bl }).city.asks.find((x) => x.id === 'blockers:' + bl.blockers[0].id);
+  assert.equal(a.ask_real, true);
+  assert.equal(a.shown.question, STORED.question);
+  assert.equal(a._sources.human, 'real');
+});