@bongos/core 1.21.18 → 1.21.20

package/tests/governor_docket.mjs

@@ -82,7 +82,7 @@ const item = (over = {}) => ({
   expired: false, closed_at: null, outcome: null, constitution: CONSENT, votes: [],
   ...over,
 });
-const none = () => ({ sources: new Map(), readings: new Map() });
+const none = () => ({ sources: new Map(), readings: new Map(), floors: new Map(), histories: new Map() });
 
 // ── 1. the mapper ────────────────────────────────────────────────────────────
 
@@ -285,7 +285,7 @@ test('the response shape: counts, line, street-ordered buildings, sorted matters
   c.readings.set('flow', { reading: 'flow', gate: { anyBuilder: true }, read: async () => ({ value: 3, figure: '3 stuck', line: 'longest wait 4 days, waiting for review', hot: true }) });
   const d = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast', 'security.report.adjudicate'], contributions: c, now: NOW });
 
-  assert.deepEqual(Object.keys(d).sort(), ['buildings', 'counts', 'generated_at', 'line', 'matters', 'readings', 'sources', 'viewer', 'vocabulary'].sort());
+  assert.deepEqual(Object.keys(d).sort(), ['buildings', 'counts', 'floors', 'generated_at', 'history', 'history_sources', 'line', 'matters', 'readings', 'sources', 'viewer', 'vocabulary'].sort());
   assert.deepEqual(d.viewer, { id: '7' });
   // board 11 (needs) + board 12 (settled, closed this week) + blocker + report; board 13 is too old
   assert.deepEqual(d.counts, { needs: 2, moving: 1, settled: 1 });
@@ -512,6 +512,190 @@ test('each contributed source gates on EXACTLY the atom its own list route requi
   seams._reset();
 });
 
+// ── 5b. floors and the record (task 1004527) ────────────────────────────────
+
+const floorsDocket = require(path.join(ROOT, 'modules', 'government', 'docket-floors.js'));
+const economyDocket = require(path.join(ROOT, 'modules', 'economy', 'governor-docket.js'));
+
+const GOV = {
+  board: { membership: 'rank:metic+', pass_rule: 'majority' },
+  members: [{ builder_id: '7', github_login: 'ana', display_name: 'Ana' }, { builder_id: '9', github_login: 'theo', display_name: null }],
+  decisions: [
+    { area: 'people', name: 'People', who: 'whoever may manage ranks', rule: 'decide', rule_words: 'decides alone', as_today: true, decided_by: 'gate', gate: 'government.manage' },
+    { area: 'rules', name: 'Rules', who: 'whoever may change the project settings', rule: 'decide', rule_words: 'decides alone', as_today: true, decided_by: 'gate' },
+    { area: 'review', name: 'Review', who: 'testers', rule: 'signoff', rule_words: 'signed off by someone who did not build it', as_today: false, decided_by: 'rank:tester', set_by_item_id: '40' },
+    { area: 'release', name: 'Release', who: 'no one yet', rule: 'vacant', rule_words: 'no one holds this yet', as_today: false, decided_by: 'nobody' },
+    { area: 'treasury', name: 'Treasury', who: 'whoever may set spending limits', rule: 'decide', rule_words: 'decides alone', as_today: true, decided_by: 'gate' },
+  ],
+  holders: { review: [{ builder_id: '3', github_login: 'lu', display_name: 'Lu' }], release: [], charter: null },
+  genesis: { stages: [{ key: 'charter', label: 'the charter', state: 'passed', item_id: '1', closed_at: '2026-07-04T00:00:00Z' }, { key: 'pay', label: 'who can be paid', state: 'sitting', item_id: '2' }] },
+  ranks: [{ rank_key: 'metic', label: 'Metic', holders: 4 }, { rank_key: 'archon', label: 'Archon', holders: 1 }],
+  amendments: [{ item_id: '40', kind: 'decision_rules', rationale_md: '# Testers hold Review', closed_at: '2026-10-01T09:00:00Z', outcome: 'passed' }, { item_id: '41', kind: 'constitution', rationale_md: '', closed_at: '2026-09-02T09:00:00Z', outcome: 'returned' }],
+  closed: [{ id: '50', subject_type: 'full_idea', subject_id: '8', subject: { title: 'A template marketplace' }, closed_at: '2026-09-20T00:00:00Z', outcome: 'passed' }, { id: '40', subject_type: 'constitutional_amendment', closed_at: '2026-10-01T09:00:00Z', outcome: 'passed' }],
+  assignments: [{ builder_id: '3', github_login: 'lu', display_name: 'Lu', rank_key: 'tester', rank_label: 'Tester', is_system: false, assigned_at: '2026-09-30T00:00:00Z' }],
+};
+
+test('floors: every floor the design names is reported, and nothing is invented for one nobody answers', async () => {
+  const c = none();
+  let ran = false;
+  c.floors.set('release.live_month', { floor: 'release.live_month', gate: { anyBuilder: true }, read: async () => ({ count: 3, line: '3 pieces of work went live', lines: [['Invite flow', 'sep 26'], 'not a line', [''], ['x'.repeat(400), 'm']], hot: 'yes' }) });
+  c.floors.set('automation.running', { floor: 'automation.running', gate: { permission: 'autonomy.fence.manage' }, read: async () => { ran = true; return { count: '2' }; } });
+  c.floors.set('treasury.hosting', { floor: 'treasury.hosting', gate: { anyBuilder: true }, read: async () => { throw new Error('db down'); } });
+  const d = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: c, now: NOW });
+  assert.deepEqual(d.floors.map((f) => f.key), vocab.FLOORS.map((f) => f.key), 'every declared floor, in order');
+  const by = Object.fromEntries(d.floors.map((f) => [f.key, f]));
+  assert.deepEqual([by['release.live_month'].status, by['release.live_month'].count, by['release.live_month'].hot], ['live', '3', false]);
+  assert.deepEqual(by['release.live_month'].lines.map((l) => l[0].length), [11, 200], 'only real [text, meta] lines, bounded');
+  assert.deepEqual([by['automation.running'].status, by['automation.running'].count, ran], ['not_yours', '', false], 'a gated floor never runs');
+  assert.deepEqual([by['treasury.hosting'].status, by['treasury.hosting'].count], ['unavailable', '']);
+  assert.deepEqual([by['charter.purpose'].status, by['charter.purpose'].count], ['coming', '']);
+  assert.match(by['charter.purpose'].reason, /no written purpose/);
+  assert.deepEqual([by['treasury.grading'].status, by['treasury.grading'].count], ['off', ''], 'no contributor: off, no figure');
+  assert.equal(by['charter.council'].status, 'unavailable', 'no government read: unavailable, never an empty council');
+  assert.equal(by['planning.ideas'].status, 'live', 'ideas follow the board, which is live here');
+});
+
+test('floors: the government\'s own — council, sections, founding, ranks, testers — from the rows it read', async () => {
+  boardView = { open: [item({ id: '60', subject_type: 'full_idea', subject_id: '9', subject: { title: 'Weekly digest', author_id: '3' }, constitution: { membership: 'rank:metic+', pass_rule: 'majority' } })], closed: [] };
+  const d = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: none(), now: NOW, decisions: GOV.decisions, government: GOV });
+  const by = Object.fromEntries(d.floors.map((f) => [f.key, f]));
+  assert.deepEqual([by['charter.council'].count, by['charter.council'].line], ['2', '2 seats · passes on more than half saying yes']);
+  assert.deepEqual(by['charter.council'].lines[0], ['Ana and theo.', 'seated now']);
+  assert.deepEqual(by['people.council'].lines[2], ['Seats have no term yet. Elections and recalls are coming.', 'coming']);
+  assert.deepEqual([by['charter.founding'].line, by['charter.founding'].hot], ['1 of 2 founding steps passed', true]);
+  assert.deepEqual(by['charter.review'].lines, [['Held by testers: signed off by someone who did not build it.', 'amended']]);
+  assert.deepEqual([by['charter.release'].line, by['charter.release'].lines[0][1]], ['held by no one yet', 'amended']);
+  assert.equal(by['charter.money'].line, 'whoever may set spending limits · decides alone');
+  assert.match(by['charter.membership'].line, /metic and above/);
+  assert.deepEqual([by['people.ranks'].count, by['people.ranks'].lines[0]], ['2', ['Metic', '4 people']]);
+  assert.match(by['people.ranks'].lines.at(-1)[0], /Promotion by a vote is coming/);
+  assert.deepEqual([by['review.testers'].count, by['review.testers'].line], ['1', 'Lu']);
+  assert.deepEqual([by['planning.ideas'].count, by['planning.ideas'].lines[0][0]], ['1', 'Weekly digest']);
+  // who holds each building: the people its row seats now
+  const b = Object.fromEntries(d.buildings.map((x) => [x.key, x]));
+  assert.deepEqual([b.review.holders, b.review.holder_count], [[{ id: '3', login: 'lu', name: 'Lu' }], 1]);
+  assert.deepEqual([b.release.holders, b.release.holder_count], [[], 0], 'vacant: no one, said as no one');
+  assert.deepEqual([b.charter.holders, b.planning.holders], [null, null], 'unresolved is null, never an invented seat');
+  // without the docket's own atom none of it shows
+  const out = await docket.buildDocket({ viewer: VIEWER, permissions: [], contributions: none(), now: NOW, decisions: GOV.decisions, government: GOV });
+  assert.ok(out.floors.filter((f) => floorsDocket.BUILDERS[f.key]).every((f) => f.status === 'not_yours' && f.count === ''));
+  assert.ok(out.buildings.every((x) => x.holders === null), 'holders are not shown without it');
+  assert.deepEqual(out.history, []);
+});
+
+test('the record: what closed, from every keeper, newest first; gated keepers never run; undated rows dropped', async () => {
+  boardView = { open: [], closed: [] };
+  const c = none();
+  let ran = false;
+  c.histories.set('releases', { history: 'releases', building: 'release', gate: { anyBuilder: true }, read: async () => [{ id: 9, title: 'Invite flow', at: '2026-09-26T00:00:00Z', outcome: 'live' }, { id: 10, title: 'No date', at: null }] });
+  c.histories.set('rulings', { history: 'rulings', building: 'disputes', gate: { permission: 'security.report.adjudicate' }, read: async () => { ran = true; return []; } });
+  const d = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: c, now: NOW, decisions: GOV.decisions, government: GOV });
+  assert.equal(ran, false);
+  assert.deepEqual(d.history.map((h) => [h.id, h.building, h.outcome]), [
+    ['government:amendment:40', 'charter', 'passed'],
+    ['government:rank:3:tester', 'people', 'granted'],
+    ['releases:9', 'release', 'live'],
+    ['government:board:50', 'planning', 'ratified'],
+    ['government:amendment:41', 'charter', 'returned'],
+    ['government:founding:1', 'charter', 'passed'],
+  ]);
+  assert.equal(d.history[4].title, 'A change to the charter', 'an amendment with no rationale reads as one');
+  assert.deepEqual(d.history_sources.map((s) => [s.source, s.status]), [['government', 'live'], ['releases', 'live'], ['rulings', 'not_yours']]);
+});
+
+test('lifecycle floors: goals kept of total, priorities, versions, signed off, live this month, held back, newcomers', () => {
+  const goals = [{ id: 1, title: 'Hall', status: 'open', version_id: 'V2' }, { id: 2, title: 'Payments', status: 'open', version_id: 'V2' }, { id: 3, title: 'Old', status: 'achieved', version_id: 'V1', updated_at: '2026-09-01T00:00:00Z' }];
+  const crit = [{ id: 'c1', goal_id: 1, satisfied: true, criterion_md: 'Search works', checked_at: '2026-10-01T00:00:00Z' }, { id: 'c2', goal_id: 1, satisfied: false }, { id: 'c3', goal_id: 9, satisfied: true, criterion_md: 'Old one', checked_at: '2026-09-03T00:00:00Z' }];
+  assert.deepEqual(lifecycleDocket.goalsFloor(goals, crit).lines, [['Hall', '1 of 2 kept'], ['Payments', 'no promises yet']]);
+  assert.equal(lifecycleDocket.goalsFloor(goals, crit).count, '2');
+  assert.deepEqual(lifecycleDocket.prioritiesFloor(goals, 'V2').lines[0], ['1 Hall · 2 Payments', 'version V2']);
+  assert.equal(lifecycleDocket.versionsFloor([{ id: 'V2', name: 'V2', status: 'building' }, { id: 'V1', name: 'V1', status: 'shipped', shipped_at: '2026-09-28T00:00:00Z' }], goals).line, 'V2 building · 2 goals in it');
+  const so = lifecycleDocket.signedOffFloor(crit, NOW);
+  assert.deepEqual([so.count, so.line, so.lines[0]], ['1', '1 signed off this month', ['Search works', 'oct 1']]);
+  const shipped = [{ id: 1, title: 'A', shipped_at: '2026-10-01T03:00:00Z' }, { id: 2, title: 'B', shipped_at: '2026-09-30T23:00:00Z' }];
+  assert.deepEqual([lifecycleDocket.liveMonthFloor(shipped, NOW).count, lifecycleDocket.liveMonthFloor(shipped, NOW).lines], ['1', [['A', 'oct 1']]], 'only this month');
+  assert.deepEqual(lifecycleDocket.heldBackFloor([{ title: 'X', needs_rebase: true }, { title: 'Y', needs_rebase: false }]).count, '1');
+  assert.equal(lifecycleDocket.newcomersFloor([{ title: 'N', newcomer_friendly: true }, { title: 'M' }], [{ newcomer_friendly: true }, { newcomer_friendly: true }]).lines.at(-1)[0], '2 newcomer tasks are ready to claim.');
+  assert.deepEqual(lifecycleDocket.signoffHistory(crit).map((h) => h.id), ['c1', 'c3']);
+  assert.deepEqual(lifecycleDocket.goalHistory(goals).map((h) => h.title), ['Old achieved']);
+  assert.deepEqual(lifecycleDocket.releaseHistory(shipped).map((h) => h.at), ['2026-10-01T03:00:00Z', '2026-09-30T23:00:00Z']);
+});
+
+test('automation, treasury and disputes floors read their own ledgers, and say so when there is nothing', () => {
+  const ag = autonomyDocket.allowedGoalsFloor({ priority_goal_id: 7, goals: [{ goal_id: 7, added_at: '2026-09-20T00:00:00Z' }, { goal_id: 8, added_at: '2026-09-02T00:00:00Z' }] });
+  assert.deepEqual([ag.count, ag.lines], ['2', [['goal 7', 'first in line'], ['goal 8', 'since sep 2']]]);
+  assert.equal(autonomyDocket.allowedGoalsFloor({ goals: [] }).line, 'no goal allowed');
+  const describe = (r) => ({ ok: r.alive, state: r.alive ? 'alive' : 'dead' });
+  const run = autonomyDocket.runningFloor([{ display_name: 'Ana', runners: [{ alive: true, working_task_id: '12' }, { alive: false, working_task_id: '13' }, { alive: true, working_task_id: null }] }], NOW, describe);
+  assert.deepEqual([run.count, run.lines], ['1', [['task 12', 'Ana']]], 'only a live runner on a task is building');
+  assert.deepEqual([autonomyDocket.spendingLimitFloor({ ceilingUsd: 40, spentUsd: 12 }).line, autonomyDocket.spendingLimitFloor({ ceilingUsd: 40, spentUsd: 35 }).hot], ['$40 a month · $12 used', true]);
+  const rep = autonomyDocket.reportsFloor([{ routine: 'builder', decision: 'go', created_at: '2026-09-30T00:00:00Z' }, { routine: 'idea-triage', decision: 'no-go', reason: 'nothing open', created_at: '2026-09-01T00:00:00Z' }], NOW);
+  assert.deepEqual([rep.count, rep.lines.map((l) => l[0])], ['1', ['The builder went ahead.', 'Idea sorting held back: nothing open.']], 'said in words, not the gate\'s keys');
+  const months = [{ month: '2026-10', rewards_credits: 1180, rewarded_builders: 6, grading_usd: 310.4, hosting_usd: 120 }, { month: '2026-09', rewards_credits: 4920, rewarded_builders: 8, grading_usd: 0, hosting_usd: 160 }];
+  assert.deepEqual([economyDocket.rewardsFloor(months, NOW).count, economyDocket.rewardsFloor(months, NOW).line], ['$1,180', '$1,180 this month · 6 builders']);
+  assert.deepEqual(economyDocket.hostingFloor(months, NOW).lines[1], ['$160 in sep.', 'last month']);
+  assert.equal(economyDocket.gradingFloor([], NOW).count, '$0', 'a month with no rows is a real zero, read from the ledger');
+  assert.deepEqual(economyDocket.treasuryHistory(months).map((h) => h.title), ['Paid $1,180 to 6 builders', 'AI grading cost $310', 'Hosting cost $120', 'Paid $4,920 to 8 builders', 'Hosting cost $160']);
+  assert.deepEqual(reportsRoute.rulingHistory([{ id: 1, title: 'sign-in limits', status: 'fixed', fixed_at: '2026-08-02T00:00:00Z' }, { id: 2, title: 'open one', status: 'open' }, { id: 3, title: 'undated', status: 'wontfix' }]).map((h) => [h.title, h.outcome]), [['Security report: sign-in limits', 'fixed']]);
+});
+
+test('rules in force: the landing rule and what it settled; the record by month', () => {
+  assert.deepEqual(ideasDocket.rulesFloor(18), { count: '1', line: '1 rule · settled 18 this month', lines: [['Every filing lands in its goal without a vote.', 'settled 18'], ['A new rule put to the council is coming.', 'coming']], hot: false });
+  assert.deepEqual(ideasDocket.rulesHistory([{ month: '2026-10', n: 3 }, { month: '2026-09', n: 0 }]).map((h) => [h.title, h.at]), [['The landing rule settled 3 filings', '2026-10-01T00:00:00.000Z']]);
+});
+
+test('one ledger read per docket request: the treasury floors and record share it, and so do money and the spending limit', async () => {
+  const costMod = require(path.join(ROOT, 'modules', 'economy', 'cost.js'));
+  const autoDb = require(path.join(ROOT, 'modules', 'autonomy', 'db.js'));
+  const realFence = autoDb.readFence;
+  let fences = 0;
+  autoDb.readFence = async () => { fences += 1; return { enabled: true, goals: [], updated_at: '2026-09-02T00:00:00Z' }; };
+  const realMonths = costMod.treasuryMonths;
+  let reads = 0;
+  costMod.treasuryMonths = async () => { reads += 1; return [{ month: '2026-10', rewards_credits: 10, rewarded_builders: 1, grading_usd: 2, hosting_usd: 3 }]; };
+  let spends = 0;
+  seams._reset();
+  seams.registerProvider('reward', { autonomousApiSpendMtd: async () => { spends += 1; return 5; } });
+  try {
+    for (const f of ['modules/economy/routes/cost.js', 'modules/autonomy/routes/autonomy.js']) require(path.join(ROOT, f))();
+    const d = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast', 'autonomy.precheck'], now: NOW + 1 });
+    const by = Object.fromEntries(d.floors.map((f) => [f.key, f]));
+    assert.deepEqual([by['treasury.rewards'].count, by['treasury.hosting'].count, by['automation.spending_limit'].status], ['$10', '$3', 'live']);
+    assert.equal(reads, 1, 'one treasury read for three floors and the record');
+    assert.equal(spends, 1, 'one spend read for the money reading and the spending limit');
+    assert.equal(fences, 1, 'one fence read for the switch, allowed goals and the switch\'s record');
+    await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], now: NOW + 2 });
+    assert.equal(reads, 2, 'a new request reads afresh');
+    // two requests in flight at once, even at the same instant, each read once
+    reads = 0; spends = 0;
+    await Promise.all([1, 2, 3].map(() => docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast', 'autonomy.precheck'], now: NOW + 3 })));
+    assert.deepEqual([reads, spends], [3, 3], 'one read per request, never shared across requests');
+  } finally {
+    costMod.treasuryMonths = realMonths;
+    autoDb.readFence = realFence;
+    seams._reset();
+  }
+});
+
+test('each floor and record gates on the atom of the route that serves its rows', async () => {
+  seams._reset();
+  for (const f of ['modules/ideas/routes/blockers.js', 'modules/lifecycle/routes/lifecycle.js', 'modules/security/routes/reports.js', 'modules/autonomy/routes/autonomy.js', 'modules/economy/routes/cost.js']) require(path.join(ROOT, f))();
+  const reg = docket.registeredContributions();
+  const routePerm = (file, key) => rrc.classifyText(fs.readFileSync(path.join(ROOT, file), 'utf8')).find((x) => x.key === key).perms;
+  assert.deepEqual([reg.floors.get('automation.running').gate.permission], routePerm('modules/autonomy/routes/autonomy.js', 'GET /autonomy/runners/all'));
+  for (const k of ['automation.spending_limit', 'automation.reports']) assert.deepEqual([reg.floors.get(k).gate.permission], routePerm('modules/autonomy/routes/autonomy.js', 'GET /autonomy/runs'));
+  assert.deepEqual([reg.histories.get('rulings').gate.permission], routePerm('modules/security/routes/reports.js', 'GET /security/reports'));
+  const anyBuilder = [...reg.floors].filter(([, c]) => c.gate.anyBuilder === true).map(([k]) => k).sort();
+  assert.deepEqual(anyBuilder, ['automation.allowed_goals', 'people.newcomers', 'planning.goals', 'planning.priorities', 'planning.versions', 'release.held_back', 'release.live_month', 'review.signed_off', 'rules.in_force', 'treasury.grading', 'treasury.hosting', 'treasury.rewards']);
+  // every declared floor has exactly one answer: a contributor, the government, or a coming reason
+  const own = new Set([...Object.keys(floorsDocket.BUILDERS), 'planning.ideas']);
+  for (const f of vocab.FLOORS) {
+    const answers = [reg.floors.has(f.key), own.has(f.key), docket.COMING_FLOORS.some((c) => c.floor === f.key)].filter(Boolean).length;
+    assert.equal(answers, 1, `${f.key} has one answer`);
+  }
+  seams._reset();
+});
+
 // ── 6. the route ─────────────────────────────────────────────────────────────
 
 const realRequireBuilder = api.requireBuilder;

package/tests/hall_street.mjs

@@ -377,7 +377,7 @@ test('the page holds the prototype\'s header, the street, the readings and the c
   for (const id of ['hudNeeds', 'hudMoving', 'hudShare', 'streetMode', 'streetSigns', 'streetPins', 'streetDoors', 'streetCard']) assert.match(html, new RegExp(`id="${id}"`), id);
   assert.doesNotMatch(html, /app-sidebar|shell\.js/, 'no hall chrome, as the city');
   const scripts = [...html.matchAll(/<script src="\/builders\/([a-z-]+)\.js/g)].map((m) => m[1]);
-  assert.deepEqual(scripts, ['city-draw', 'street-draw', 'street-card', 'street-inside', 'street'], 'the shared kit loads first, then the card (task 1004528) and the interiors (task 1004526)');
+  assert.deepEqual(scripts, ['city-draw', 'street-draw', 'street-card', 'street-inside', 'street-amend', 'street'], 'the shared kit loads first, then the card (task 1004528), the interiors (task 1004526) and the drafted amendment (task 1004530)');
   assert.equal(City.STREET_HREF, '/builders/street', 'the city\'s door is this page');
 });
 

package/tests/hall_street_amend.mjs

@@ -0,0 +1,336 @@
+// tests/hall_street_amend.mjs — CHANGE HOW THIS WORKS DRAFTS AN AMENDMENT
+// (task 1004530, goal 1000125).
+//
+// WHAT IT GUARDS. From any building, "change how this works" opens a drafted
+// amendment to that building's row of the who-decides-what table, prefilled
+// with the rule in force and a proposed one as struck and inserted text; the
+// governor picks who and which rule from the vocabulary only, says why, and
+// files it; the street answers. What can go wrong:
+//   * the draft offering a seat or a rule the server does not know (free text),
+//     or a rule that does not fit who decides (as today with a rule, empty with
+//     anything but vacant) — the server would refuse what the governor drafted;
+//   * the struck and inserted words drifting from what the matter card shows the
+//     council (pinned: they ARE the card's change() over the stored amendment);
+//   * a request body the server's own validator refuses, the Charter's draft
+//     going to the rules route (it is the board: /board/items);
+//   * a refusal swallowed, or said as a code instead of words;
+//   * the page filing with no reason, filing twice, or answering nothing.
+//
+// The fixtures are the SERVER'S OWN resolved rows (decision-rules.js), so the
+// draft is tested against the shape the constitution route really serves.
+//
+// Run:  node --test tests/hall_street_amend.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);
+const C = require(path.join(PUB, 'street-card.js'));
+const A = require(path.join(PUB, 'street-amend.js'));
+const S = require(path.join(PUB, 'street-draw.js'));
+const DR = require(path.join(ROOT, 'modules/government/decision-rules.js'));
+const { RANK_ORDER } = require(path.join(ROOT, 'modules/government/membership-predicate.js'));
+const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8');
+const j = (v) => JSON.parse(JSON.stringify(v));
+
+const BOARD = { membership: 'rank:archon', pass_rule: 'majority', window_minutes: 4320, close_early_on_full_turnout: true };
+function constitution(rows = [], board = BOARD) {
+  return {
+    board,
+    decision_rules: {
+      areas: j(DR.resolveAll(rows, { board })),
+      rules: DR.DECISION_RULES.map((r) => ({ key: r.key, words: r.words })),
+      changed_by: 'a passed amendment only',
+    },
+  };
+}
+const SAT = { area: 'review', decided_by: 'rank:metic+', rule: 'signoff', who: null, set_by_item_id: 12 };
+
+// ── the draft ───────────────────────────────────────────────────────────────
+
+test('the vocabulary is the server\'s: the rank ladder, the seven rules, the nine buildings', () => {
+  assert.deepEqual(A.RANKS, [...RANK_ORDER]);
+  const c = constitution();
+  for (const area of DR.AREA_KEYS) {
+    const d = A.draftFor(area, c);
+    assert.equal(d.ok, true, area);
+    for (const o of d.whoOptions) assert.ok(o.value === 'gate' || o.value === 'nobody' || /^rank:/.test(o.value), `${area}: ${o.value} is a seat, never free text`);
+    for (const o of d.ruleOptions) assert.ok(DR.SITTING_RULE_KEYS.includes(o.value), `${area}: ${o.value}`);
+  }
+});
+
+test('a building decided as today drafts: the board\'s members, by consent, struck and inserted', () => {
+  const d = A.draftFor('review', constitution());
+  assert.equal(d.name, 'Review');
+  assert.deepEqual(d.current, { decided_by: 'gate', rule: null });
+  assert.equal(d.decided_by, 'rank:archon');
+  assert.equal(d.rule, 'consent');
+  assert.deepEqual(d.whoOptions.map((o) => o.value), ['gate', 'rank:archon', 'rank:xenos+', 'rank:thetes+', 'rank:metic+', 'nobody']);
+  assert.equal(d.whoOptions[0].words, 'as today: whoever may mark work as meeting its checks');
+  assert.deepEqual(d.ruleOptions.map((o) => o.value), ['decide', 'first', 'consent', 'majority', 'unanimous', 'signoff']);
+  assert.deepEqual(j(A.change(d)), [{ label: 'Review', struck: 'whoever may mark work as meeting its checks, decides alone', inserted: 'the archon rank, passes unless someone objects' }]);
+});
+
+test('a building already changed drafts its way back to as today', () => {
+  const d = A.draftFor('review', constitution([SAT]));
+  assert.deepEqual(d.current, { decided_by: 'rank:metic+', rule: 'signoff' });
+  assert.equal(d.decided_by, 'gate');
+  assert.equal(d.rule, null);
+  assert.deepEqual(d.ruleOptions, [], 'as today decides alone: there is no rule to pick');
+  assert.deepEqual(j(A.change(d)), [{ label: 'Review', struck: 'metic and above (metic, archon), signed off by someone who did not build it', inserted: 'as it is decided today' }]);
+});
+
+test('the rule follows who: no one is vacant, a sitting keeps a rule that fits, a value outside the vocabulary changes nothing', () => {
+  let d = A.draftFor('people', constitution());
+  d = A.pick(d, 'who', 'nobody');
+  assert.equal(d.rule, 'vacant');
+  assert.deepEqual(j(A.change(d))[0].inserted, 'no one yet');
+  d = A.pick(d, 'who', 'rank:metic+');
+  assert.ok(DR.SITTING_RULE_KEYS.includes(d.rule), 'a sitting gets a sitting rule back');
+  d = A.pick(d, 'rule', 'unanimous');
+  assert.equal(d.rule, 'unanimous');
+  assert.equal(A.pick(d, 'who', 'rank:everyone'), d, 'not a seat on offer');
+  assert.equal(A.pick(d, 'rule', 'vacant'), d, 'vacant is not a sitting rule');
+  assert.equal(A.pick(d, 'rule', 'whatever'), d);
+  d = A.pick(d, 'who', 'gate');
+  assert.equal(A.changed(d), false, 'back to as today is no change');
+  assert.deepEqual(A.change(d), []);
+  assert.match(A.check(d), /how it works today/);
+});
+
+test('the request is the one the server\'s validator accepts, and the card reads it back word for word', () => {
+  for (const [area, who, rule] of [['review', 'rank:archon', 'consent'], ['treasury', 'rank:metic+', 'majority'], ['people', 'nobody', null], ['rules', 'rank:xenos+', 'signoff']]) {
+    let d = A.draftFor(area, constitution());
+    d = A.pick(d, 'who', who);
+    if (rule) d = A.pick(d, 'rule', rule);
+    assert.equal(A.request(d), null, 'no reason, no request');
+    assert.match(A.check(d), /Say why/);
+    d = A.pick(d, 'reason', '  Three pieces of work are waiting.  ');
+    const req = A.request(d);
+    assert.equal(req.method, 'POST');
+    assert.equal(req.url, '/api/bongos/government/board/decision-rules');
+    assert.equal(req.body.rationale_md, 'Three pieces of work are waiting.');
+    const v = DR.validateDecisionRulesProposal(req.body.rules);
+    assert.equal(v.ok, true, `${area}: ${v.reason}`);
+    assert.equal(DR.changesAnything(v.rules, []), true, 'a change the server will not refuse as no_change');
+    // the card the council votes on, over the amendment as the server stores it
+    const stored = { subject_type: 'constitutional_amendment', subject: { kind: 'decision_rules', proposed: { decision_rules: j(v.rules) } } };
+    const docket = { buildings: [{ key: area, decision: constitution().decision_rules.areas.find((r) => r.area === area) }] };
+    assert.deepEqual(j(C.change(stored, docket, { board: BOARD }).rows), j(A.change(d)), `${area}: drafted words = voted words`);
+  }
+});
+
+test('the Charter is the board: its draft is a constitution amendment of members and pass rule, through /board/items', () => {
+  let d = A.draftFor('charter', constitution());
+  assert.equal(d.charter, true);
+  assert.ok(!d.whoOptions.some((o) => o.value === 'gate' || o.value === 'nobody'), 'the charter is never as-today or empty');
+  assert.deepEqual(d.ruleOptions.map((o) => o.value), ['first', 'consent', 'majority', 'unanimous'], 'the board\'s four pass rules');
+  assert.equal(d.rule, 'consent');
+  assert.deepEqual(j(A.change(d)), j(C.change({ subject: { kind: 'constitution', proposed: { pass_rule: 'consent' } } }, null, { board: { pass_rule: 'majority' } }).rows));
+  assert.equal(j(A.change(d))[0].label, 'how it passes');
+  d = A.pick(A.pick(d, 'who', 'rank:metic+'), 'reason', 'More of us should sit.');
+  const req = A.request(d);
+  assert.equal(req.url, '/api/bongos/government/board/items');
+  assert.equal(req.body.subject_type, 'constitutional_amendment');
+  assert.deepEqual(Object.keys(req.body.proposal).sort(), ['close_early_on_full_turnout', 'membership', 'pass_rule', 'window_minutes'], 'a constitution is filed whole, with no field the validator refuses');
+  assert.deepEqual(req.body.proposal, { membership: 'rank:metic+', pass_rule: 'consent', window_minutes: 4320, close_early_on_full_turnout: true });
+  assert.equal(j(A.change(d)).length, 2, 'who sits, and how it passes');
+});
+
+test('a constitution that could not be read drafts nothing, and says so', () => {
+  for (const c of [null, {}, { board: BOARD }, { board: BOARD, decision_rules: null }, { board: BOARD, decision_rules: { areas: [], rules: [] } }]) {
+    const d = A.draftFor('review', c);
+    assert.equal(d.ok, false);
+    assert.equal(A.request(d), null);
+    assert.match(A.check(d), /could not be read/);
+  }
+});
+
+test('the server\'s refusal is said plainly, never as a code', () => {
+  const env = (code, details) => ({ error: { code, message: code, details } });
+  assert.match(A.refusal(403, env('forbidden')), /not yours to do/);
+  assert.match(A.refusal(401, env('unauthorized')), /Sign in/);
+  assert.match(A.refusal(409, env('no_change', { reason: 'every building named is already decided this way' })), /already is how it works/);
+  assert.match(A.refusal(400, env('invalid_decision_rules', { reason: 'unknown_rank', rank_key: 'council' })), /no such rank/);
+  assert.equal(A.refusal(400, env('invalid_decision_rules', { reason: 'too_many_rows' })), 'The server refused it: too many rows.');
+  assert.equal(A.refusal(409, env('proposer_would_lose_their_seat', { what_this_means: 'You would no longer sit on the board.' })), 'You would no longer sit on the board.');
+  assert.equal(A.refusal(0, {}), 'It could not be done just now.');
+  for (const s of [A.refusal(400, env('invalid_decision_rules', { reason: 'bad_rule' })), A.refusal(403, env('forbidden'))]) assert.doesNotMatch(s, /_/);
+});
+
+test('the model is pure', () => {
+  const src = read('street-amend.js').replace(/^\s*\/\/.*$/gm, '');
+  assert.doesNotMatch(src, /document\.|fetch\(|Date\.now|Math\.random|innerHTML/);
+  const d = A.draftFor('review', constitution());
+  assert.deepEqual(j(A.draftFor('review', constitution())), j(d));
+  A.pick(d, 'who', 'gate');
+  assert.equal(d.decided_by, 'rank:archon', 'a pick returns a new draft');
+});
+
+// ── the page ────────────────────────────────────────────────────────────────
+
+test('the markup: the draft lives under the button, hidden, and the model loads before the page', () => {
+  const html = read('street.html').replace(/<!--[\s\S]*?-->/g, '');
+  assert.match(html, /id="insideAmend" aria-expanded="false" aria-controls="insideDraft"/);
+  assert.match(html, /<div class="inside-draft" id="insideDraft" hidden><\/div>/);
+  const order = ['street-card.js', 'street-amend.js', 'street.js'].map((f) => html.indexOf(`/builders/${f}?`));
+  assert.ok(order[0] > 0 && order[0] < order[1] && order[1] < order[2], 'card, then the draft model, then the page');
+  const css = read('street.css').replace(/\/\*[\s\S]*?\*\//g, '');
+  assert.ok(css.includes('.inside-draft[hidden] { display: none; }'));
+  assert.match(css, /@media \(max-width: 899px\) \{\s*\.inside-draft__picks \{ grid-template-columns: 1fr; \}/, 'narrow: the picks stack');
+  assert.doesNotMatch(css.slice(css.indexOf('.inside-draft')), /#[0-9a-f]{3,8}\b/i, 'tokens only');
+  assert.doesNotMatch(read('street.js'), /not built yet/);
+});
+
+function fakeDom() {
+  const byId = new Map();
+  const focused = { el: null };
+  const mk = (tag) => ({
+    tagName: tag, attrs: {}, kids: [], className: '', listeners: {}, _text: '', hidden: false, value: undefined,
+    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, e = {}) { return (this.listeners[t] || []).map((fn) => fn({ type: t, preventDefault() {}, ...e })); },
+    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;
+  }
+  const document = { documentElement: mk('html'), getElementById: (id) => byId.get(id) || null, createElement: (t) => mk(t), createElementNS: (_ns, t) => mk(t) };
+  return { document, byId, focused };
+}
+const all = (el) => [el, ...el.kids.flatMap(all)];
+const textOf = (el) => all(el).map((n) => n._text).filter(Boolean).join(' | ');
+const tick = () => new Promise((r) => setTimeout(r, 0));
+
+async function bootPage({ hash = '#building=review', cons = constitution(), answer = () => ({ status: 201, body: { ok: true, item: { id: 77 }, amendment: { id: 5 } } }) } = {}) {
+  const { document, byId, focused } = fakeDom();
+  const gets = [], posts = [], history = [];
+  const location = { hash };
+  const window = {
+    innerWidth: 1440, innerHeight: 900, location,
+    localStorage: { getItem: () => null, setItem() {} },
+    matchMedia: () => ({ matches: false, addEventListener() {} }),
+    addEventListener() {},
+    history: { pushState(_s, _t, url) { history.push(url); location.hash = ''; } },
+  };
+  const feeds = {
+    '/api/bongos/government/docket': { viewer: { id: '95' }, counts: { needs: 0, moving: 0, settled: 0 }, line: '', matters: [], buildings: S.CIVIC_KEYS.map((key) => ({ key, name: key, matter_ids: [] })), sources: [], readings: [] },
+    '/api/bongos/goals': { goals: [] },
+    '/api/bongos/goals/rollups': { rollups: [] },
+    '/api/bongos/government/constitution': cons,
+  };
+  const fetch = (url, opts = {}) => {
+    if (opts.method === 'POST') {
+      posts.push({ url, body: JSON.parse(opts.body) });
+      const a = answer(url);
+      return Promise.resolve({ ok: a.status < 300, status: a.status, json: async () => a.body });
+    }
+    gets.push(url);
+    const body = feeds[url];
+    return Promise.resolve(body == null ? { ok: false, status: 500, json: async () => ({}) } : { ok: true, status: 200, json: async () => body });
+  };
+  const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, Date, console, encodeURIComponent, decodeURIComponent, isNaN, isFinite, Map, setTimeout, clearTimeout });
+  ctx.globalThis = ctx;
+  for (const f of ['city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street-amend.js', 'street.js']) vm.runInContext(read(f), ctx);
+  await window.GovStreetPage.ready;
+  await tick();
+  return { window, byId, focused, gets, posts, history };
+}
+
+test('change how this works opens the drafted amendment: struck, inserted, who, how, why', async () => {
+  const p = await bootPage();
+  const box = p.byId.get('insideDraft');
+  assert.equal(box.hidden, true);
+  await p.byId.get('insideAmend').fire('click')[0];
+  assert.ok(p.gets.includes('/api/bongos/government/constitution'), 'the rule in force is read fresh');
+  assert.equal(box.hidden, false);
+  assert.equal(p.byId.get('insideAmend').attrs['aria-expanded'], 'true');
+  const del = all(box).find((n) => n.tagName === 'del'), ins = all(box).find((n) => n.tagName === 'ins');
+  assert.equal(del.textContent, 'whoever may mark work as meeting its checks, decides alone');
+  assert.equal(ins.textContent, 'the archon rank, passes unless someone objects');
+  assert.equal(p.focused.el, p.byId.get('insideDraftWho'), 'focus lands on who decides');
+  assert.equal(p.byId.get('insideDraftWho').kids.length, 6);
+  assert.equal(p.byId.get('insideDraftRule').value, 'consent');
+  // a pick redraws the words and keeps focus where it was
+  const who = p.byId.get('insideDraftWho');
+  who.value = 'nobody';
+  who.fire('change');
+  assert.equal(all(box).find((n) => n.tagName === 'ins').textContent, 'no one yet');
+  assert.ok(!all(box).some((n) => n.attrs.id === 'insideDraftRule'), 'an empty building has no rule to pick');
+  assert.match(textOf(box), /nothing is decided until someone holds it/);
+  assert.equal(p.focused.el.attrs.id, 'insideDraftWho');
+  // a feed landing mid-sentence leaves the draft alone
+  const before = p.byId.get('insideDraftWhy');
+  before.value = 'half a thought';
+  before.fire('input');
+  await p.window.GovStreetPage.load();
+  assert.equal(p.byId.get('insideDraftWhy'), before, 'the same textarea, not a fresh one');
+  // not now closes it and gives focus back to the button
+  all(box).find((n) => n.tagName === 'button' && n._text === 'not now').fire('click');
+  assert.equal(box.hidden, true);
+  assert.equal(p.byId.get('insideAmend').attrs['aria-expanded'], 'false');
+  assert.equal(p.focused.el, p.byId.get('insideAmend'));
+});
+
+test('filing: no reason is refused in place; a filed amendment goes to the Charter, once, and the street answers', async () => {
+  const p = await bootPage();
+  await p.byId.get('insideAmend').fire('click')[0];
+  await p.byId.get('insideDraftFile').fire('click')[0];
+  assert.equal(p.posts.length, 0, 'nothing is sent without a reason');
+  assert.match(p.byId.get('insideDraftError').textContent, /Say why/);
+  assert.equal(p.byId.get('insideDraftError').attrs.role, 'alert');
+  assert.equal(p.focused.el, p.byId.get('insideDraftWhy'));
+  const why = p.byId.get('insideDraftWhy');
+  why.value = 'Three pieces of finished work are waiting.';
+  const first = p.byId.get('insideDraftFile').fire('click')[0];
+  await p.byId.get('insideDraftFile').fire('click')[0];
+  await first;
+  assert.equal(p.posts.length, 1, 'one click files once');
+  assert.deepEqual(p.posts[0], { url: '/api/bongos/government/board/decision-rules', body: { rules: [{ area: 'review', decided_by: 'rank:archon', rule: 'consent' }], rationale_md: 'Three pieces of finished work are waiting.' } });
+  assert.equal(p.byId.get('streetToast').hidden, false);
+  assert.equal(p.byId.get('streetToast').textContent, 'Filed. Your amendment to Review is on the Charter for the council to vote on.');
+  assert.deepEqual(p.history, ['/builders/street'], 'back to the street, where the Charter pin appears');
+  assert.equal(p.byId.get('streetInside').hidden, true);
+});
+
+test('a refusal from the server is said in the draft, and the draft stays to be changed', async () => {
+  const p = await bootPage({ answer: () => ({ status: 403, body: { error: { code: 'forbidden', message: 'missing permission board.item.open' } } }) });
+  await p.byId.get('insideAmend').fire('click')[0];
+  p.byId.get('insideDraftWhy').value = 'Because.';
+  await p.byId.get('insideDraftFile').fire('click')[0];
+  assert.equal(p.posts.length, 1);
+  assert.match(p.byId.get('insideDraftError').textContent, /not yours to do/);
+  assert.equal(p.byId.get('insideDraft').hidden, false);
+  assert.equal(p.history.length, 0, 'still in the building');
+  assert.equal(p.byId.get('streetToast').hidden, true);
+});
+
+test('a constitution that cannot be read says so where the draft would be', async () => {
+  const p = await bootPage({ cons: null });
+  await p.byId.get('insideAmend').fire('click')[0];
+  assert.equal(p.byId.get('insideDraft').hidden, true);
+  assert.equal(p.byId.get('insideAmendNote').hidden, false);
+  assert.match(p.byId.get('insideAmendNote').textContent, /could not be read/);
+});