@bongos/core 1.21.113 → 1.21.114

package/tests/government_build_rights.mjs

@@ -0,0 +1,253 @@
+// tests/government_build_rights.mjs — WHO MAY BUILD WITHOUT A VOTE comes from the
+// FORM OF GOVERNMENT (task 1004710, goal 1000111; ADR 0375).
+//
+// What this pins (the task's done-when lines):
+//   1. EACH FORM GIVES THE DOCUMENTED ANSWER. Monarchy: at once. Timocratic
+//      Republic: at once when the holder sits on the board, else a vote. Direct
+//      Democracy, Foundation, Custom: a vote. A district is always a vote. The
+//      form is READ FROM THE SETTINGS (charter.readCharter), so the real
+//      constitution decides, not a label. FORM_ANSWERS answers exactly the forms
+//      that can be in force, plus Custom; GOVERNMENT.md documents each.
+//   2. THE RULE IS WRITTEN ONCE. build-rights.js is the only place it lives: the
+//      read (leads.js / decision-board.js) calls it, the hall reads its answer
+//      (tests/hall_street_deck.mjs), and no other file says "can_build_without_vote".
+//   3. THE BUILDING'S OWN RULE and THE GOALS HOOK. A vacant building builds
+//      nothing; a sitting of its own decides ('decide'/'first' let a seated
+//      holder build at once, any other rule is a vote); a goal's limit beats the
+//      sitting and the form, a goal's grant beats only the form.
+//   4. FAIL CLOSED. An unreadable decision row, constitution or member list reads
+//      as "a vote", never "at once".
+// DB-free: db reads are monkeypatched by property.
+//
+// Run:  node --test tests/government_build_rights.mjs
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const GOV = path.join(ROOT, 'modules', 'government');
+const br = require(path.join(GOV, 'build-rights.js'));
+const charter = require(path.join(GOV, 'charter.js'));
+const dr = require(path.join(GOV, 'decision-rules.js'));
+const leads = require(path.join(GOV, 'leads.js'));
+const db = require(path.join(GOV, 'db.js'));
+const config = require(path.join(GOV, 'config.js'));
+const decisionBoard = require(path.join(GOV, 'decision-board.js'));
+
+// Each available form's own board block, built by the real charter builder, so
+// the form is read from settings exactly as a ratified charter would write them.
+function boardOf(form) {
+  const r = charter.buildCharterProposal({ window_minutes: 1440, close_early_on_full_turnout: true }, { form, councilRank: 'trustees' });
+  assert.equal(r.ok, true, form);
+  assert.equal(charter.readCharter(r.proposal).form, form, form + ' reads as itself');
+  return r.proposal;
+}
+const asToday = (area, board = {}) => dr.resolveRow(dr.defaultRow(area), { board });
+const sitting = (area, decidedBy, rule) => dr.resolveRow({ area, decided_by: decidedBy, rule, who: null }, {});
+const rights = (board, holder, { building = 'planning', decision = asToday(building, board), goals = [] } = {}) =>
+  br.buildRightsFor({ building, board, decision, holder: { seat: 'lead:' + building, ...holder }, goals });
+const atOnce = (r) => Object.fromEntries(Object.entries(r.capsules).map(([k, v]) => [k, v.without_vote]));
+const ALL = { committee: true, floor: true, annex: true, district: false };
+const NONE = { committee: false, floor: false, annex: false, district: false };
+
+// ── 1. each form gives the documented answer ────────────────────────────────
+
+test('Monarchy / BDFL: whoever holds the building builds it out at once, sitting on the board or not', () => {
+  const b = boardOf('monarchy');
+  for (const onBoard of [true, false]) {
+    const r = rights(b, { on_board: onBoard });
+    assert.equal(r.form, 'monarchy');
+    assert.equal(r.form_name, 'Monarchy / BDFL');
+    assert.deepEqual(atOnce(r), ALL);
+    assert.equal(r.capsules.floor.ground, 'form');
+    assert.equal(r.capsules.floor.why, 'The founder decides alone, so whoever holds this building builds it out at once.');
+  }
+});
+
+test('Timocratic Republic: at once when the holder has earned a vote (sits on the board); otherwise a vote', () => {
+  const b = boardOf('timocratic-republic');
+  assert.deepEqual(atOnce(rights(b, { on_board: true })), ALL);
+  const no = rights(b, { on_board: false });
+  assert.deepEqual(atOnce(no), NONE);
+  assert.equal(no.capsules.annex.why, 'Its holder has not earned a vote yet, so the board votes on it.');
+  assert.equal(no.capsules.annex.ground, 'form');
+});
+
+test('Direct Democracy, Foundation and Custom: always a vote, whoever holds it', () => {
+  const custom = { membership: 'rank:metic+', pass_rule: 'unanimous', window_minutes: 1440 };
+  assert.equal(charter.readCharter(custom).form, 'custom');
+  const cases = [
+    [boardOf('direct-democracy'), 'direct-democracy', 'Every builder decides changes together, so it goes to a vote.'],
+    [boardOf('foundation'), 'foundation', 'The council of trustees decides changes, so it goes to a vote.'],
+    [custom, 'custom', 'These settings match no named form, so a change goes to a vote.'],
+  ];
+  for (const [board, form, why] of cases) {
+    for (const onBoard of [true, false]) {
+      const r = rights(board, { on_board: onBoard });
+      assert.equal(r.form, form);
+      assert.deepEqual(atOnce(r), NONE, form);
+      assert.equal(r.capsules.committee.why, why);
+    }
+  }
+});
+
+test('a district is a new part of the city: always a vote, under every form and every goal', () => {
+  const grantAll = [{ goal_id: '1', building: '*', allow: true }];
+  for (const f of charter.FORMS.filter((x) => x.available)) {
+    const r = rights(boardOf(f.key), { on_board: true }, { goals: grantAll });
+    assert.deepEqual(r.capsules.district, { without_vote: false, why: 'A district is a new part of the city, so the board votes on it.', ground: 'city' }, f.key);
+  }
+});
+
+test('FORM_ANSWERS answers exactly the forms that can be in force, plus Custom; the documentation names each', () => {
+  const available = charter.FORMS.filter((f) => f.available).map((f) => f.key);
+  assert.deepEqual(Object.keys(br.FORM_ANSWERS).sort(), [...available, 'custom'].sort());
+  for (const f of charter.FORMS.filter((x) => !x.available)) assert.equal(br.FORM_ANSWERS[f.key], undefined, f.key + ' can never be in force');
+  const doc = fs.readFileSync(path.join(ROOT, 'GOVERNMENT.md'), 'utf8');
+  const section = doc.slice(doc.indexOf('## Who may build without a vote'));
+  assert.ok(section.length > 30, 'GOVERNMENT.md has the section');
+  for (const f of charter.FORMS.filter((x) => x.available)) assert.ok(section.includes(f.name), 'documents ' + f.name);
+  assert.ok(section.includes('Custom'));
+});
+
+test('an unknown form reads as Custom: a vote', () => {
+  const r = br.buildRight({ building: 'planning', capsule: 'floor', form: 'presidential', decision: asToday('planning'), holder: { on_board: true } });
+  assert.equal(r.without_vote, false);
+});
+
+// ── 3. the building's own rule, and the goals hook ──────────────────────────
+
+test('a vacant building builds nothing, under any form', () => {
+  const vacant = dr.resolveRow({ area: 'planning', decided_by: 'nobody', rule: 'vacant', who: null }, {});
+  const r = rights(boardOf('monarchy'), { on_board: true }, { decision: vacant });
+  assert.deepEqual(atOnce(r), NONE);
+  assert.equal(r.capsules.floor.ground, 'building');
+});
+
+test('a sitting of its own: decide/first lets a seated holder build at once; consent/majority/unanimous/sign-off is a vote', () => {
+  const dd = boardOf('direct-democracy');
+  for (const rule of ['decide', 'first']) {
+    const d = sitting('planning', 'rank:council', rule);
+    const yes = rights(dd, { on_board: false, in_sitting: true }, { decision: d });
+    assert.deepEqual(atOnce(yes), ALL, rule + ': seated, so at once even under Direct Democracy');
+    assert.equal(yes.capsules.floor.ground, 'building');
+    assert.match(yes.capsules.floor.why, /^Planning is decided by .+, and its holder is one of them, so they build it out at once\.$/);
+    assert.deepEqual(atOnce(rights(dd, { on_board: true, in_sitting: false }, { decision: d })), NONE, rule + ': not seated there');
+  }
+  const mon = boardOf('monarchy');
+  for (const rule of ['consent', 'majority', 'unanimous', 'signoff']) {
+    const r = rights(mon, { on_board: true, in_sitting: true }, { decision: sitting('planning', 'rank:council', rule) });
+    assert.deepEqual(atOnce(r), NONE, rule + ': its sitting votes, even under Monarchy');
+    assert.match(r.capsules.annex.why, /so it goes to them as a vote\.$/);
+  }
+});
+
+test('the goals hook: a limit beats the sitting and the form; a grant beats only the form', () => {
+  const mon = boardOf('monarchy');
+  const dd = boardOf('direct-democracy');
+  const limit = { goal_id: '7', building: 'planning', capsules: ['annex'], allow: false, why: 'Goal 7 keeps Planning as it is until launch.' };
+  const r1 = rights(mon, { on_board: true }, { goals: [limit] });
+  assert.deepEqual(atOnce(r1), { committee: true, floor: true, annex: false, district: false });
+  assert.deepEqual(r1.capsules.annex, { without_vote: false, why: limit.why, ground: 'goal' });
+  const seatedDecide = sitting('planning', 'rank:council', 'decide');
+  assert.equal(rights(dd, { in_sitting: true }, { decision: seatedDecide, goals: [{ ...limit, capsules: [] }] }).capsules.floor.without_vote, false, 'a limit beats the building\'s own sitting');
+  const grant = { goal_id: '8', building: '*', allow: true };
+  const r2 = rights(dd, { on_board: false }, { goals: [grant] });
+  assert.deepEqual(atOnce(r2), ALL);
+  assert.equal(r2.capsules.floor.ground, 'goal');
+  assert.equal(rights(dd, {}, { goals: [{ ...grant, building: 'release' }] }).capsules.floor.without_vote, false, 'a grant for another building');
+  assert.equal(rights(mon, { in_sitting: false }, { decision: sitting('planning', 'rank:council', 'majority'), goals: [grant] }).capsules.floor.without_vote, false, 'a grant never beats a sitting the project voted in');
+  const vacant = dr.resolveRow({ area: 'planning', decided_by: 'nobody', rule: 'vacant', who: null }, {});
+  assert.equal(rights(dd, {}, { decision: vacant, goals: [grant] }).capsules.floor.without_vote, false, 'nor a vacant building');
+  assert.equal(rights(dd, {}, { goals: [{ goal_id: '9', building: 'planning', allow: 'yes' }] }).capsules.floor.without_vote, false, 'a malformed term is ignored');
+});
+
+// ── 4. fail closed ──────────────────────────────────────────────────────────
+
+test('fail closed: no decision row, or no board, reads as a vote', () => {
+  const r = br.buildRightsFor({ building: 'planning', board: boardOf('monarchy'), decision: null, holder: { on_board: true } });
+  assert.deepEqual(atOnce(r), NONE);
+  assert.equal(br.buildRightsFor({ building: 'planning', board: null, decision: asToday('planning'), holder: { on_board: true } }).capsules.floor.without_vote, false);
+  assert.equal(br.buildRight({ building: 'moon', capsule: 'floor', form: 'monarchy', decision: asToday('planning') }).without_vote, false);
+});
+
+// ── 2. the read carries it, resolved on the server ───────────────────────────
+
+const ARCHONS = [{ id: '3', github_login: 'ada', display_name: 'Ada' }];
+const leadRow = { id: '1', building: 'planning', builder_id: '45', charter: 'Goals.', appointed_by_item_id: '40', appointed_at: 'T', removed_by_item_id: null, removed_at: null, github_login: 'dee', display_name: 'Dee' };
+
+test('leadsView carries each building\'s build_rights for its HOLDER: the Lead where seated, the owner seat elsewhere', () => {
+  const board = boardOf('timocratic-republic');
+  const decisions = dr.resolveAll([], { board });
+  const v = leads.leadsView([leadRow], ARCHONS, { rights: { board, decisions, boardMemberIds: ['3'], sittingMemberIds: {}, goals: [] } });
+  const at = (k) => v.buildings.find((b) => b.building === k).build_rights;
+  assert.equal(at('planning').holder, 'lead:planning');
+  assert.equal(at('planning').capsules.floor.without_vote, false, 'Dee (45) has not earned a vote');
+  assert.equal(at('release').holder, 'owner');
+  assert.equal(at('release').capsules.floor.without_vote, true, 'the owner seat sits on the board');
+  assert.match(v.build_rights_from, /form of government/);
+  assert.equal(leads.leadsView([leadRow], ARCHONS).buildings[0].build_rights, null, 'no context, no answer');
+});
+
+async function withStubs(stubs, fn) {
+  const saved = [];
+  for (const [obj, k, v] of stubs) { saved.push([obj, k, obj[k]]); obj[k] = v; }
+  try { return await fn(); } finally { for (const [obj, k, v] of saved) obj[k] = v; }
+}
+
+test('the server resolves the context per request: the constitution in force, the table, who the board and each sitting seat', async () => {
+  const board = boardOf('timocratic-republic');
+  const asked = [];
+  await withStubs([
+    [db, 'listLeads', async () => [leadRow]],
+    [db, 'listActiveArchons', async () => ARCHONS],
+    [db, 'listDecisionRules', async () => [{ area: 'review', decided_by: 'rank:testers', rule: 'first', who: null, set_by_item_id: '2' }]],
+    [db, 'getActiveBuildersWithRank', async (keys) => { asked.push(keys.join(',')); return keys.includes('testers') ? [{ builder_id: '3' }] : [{ builder_id: '45' }, { builder_id: '3' }]; }],
+    [config, 'loadGovernmentConfig', () => ({ board })],
+  ], async () => {
+    const v = await decisionBoard.leadsView();
+    const at = (k) => v.buildings.find((b) => b.building === k).build_rights;
+    assert.equal(at('planning').form, 'timocratic-republic');
+    assert.equal(at('planning').capsules.floor.without_vote, true, 'Dee sits on the metic+ board');
+    assert.equal(at('review').capsules.floor.ground, 'building');
+    assert.equal(at('review').capsules.floor.without_vote, true, 'the owner sits on Review\'s first-yes sitting');
+    assert.ok(asked.includes('testers'), 'the first-yes sitting was asked who it seats');
+  });
+});
+
+test('the server fails closed: an unreadable table or member list reads as a vote', async () => {
+  await withStubs([
+    [db, 'listLeads', async () => [leadRow]],
+    [db, 'listActiveArchons', async () => ARCHONS],
+    [db, 'listDecisionRules', async () => { throw new Error('down'); }],
+    [db, 'getActiveBuildersWithRank', async () => { throw new Error('down'); }],
+    [config, 'loadGovernmentConfig', () => ({ board: boardOf('monarchy') })],
+  ], async () => {
+    const v = await decisionBoard.leadsView();
+    for (const b of v.buildings) assert.equal(b.build_rights.capsules.committee.without_vote, false, b.building);
+  });
+});
+
+// ── 2. written once ─────────────────────────────────────────────────────────
+
+test('written once: no other file holds a build rule; the per-Lead flag is gone from the code and the overlay', () => {
+  const walk = (dir, out = []) => {
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+      const p = path.join(dir, e.name);
+      if (e.isDirectory()) { if (e.name !== 'node_modules') walk(p, out); } else if (/\.(js|json)$/.test(e.name)) out.push(p);
+    }
+    return out;
+  };
+  const files = [...walk(path.join(ROOT, 'modules')), ...walk(path.join(ROOT, 'src')), ...walk(path.join(ROOT, 'scripts', 'hall-preview', 'fixtures'))];
+  const flag = files.filter((f) => fs.readFileSync(f, 'utf8').includes('can_build_without_vote') && !f.endsWith('build-rights.js'));
+  assert.deepEqual(flag.map((f) => path.relative(ROOT, f)), []);
+  const callers = files.filter((f) => /require\([^)]*build-rights/.test(fs.readFileSync(f, 'utf8')));
+  // leads.js asks the rule; buildouts.js (task 1004711) takes only its vocabulary, the four capsules
+  assert.deepEqual(callers.map((f) => path.relative(ROOT, f).replace(/\\/g, '/')), ['modules/government/buildouts.js', 'modules/government/leads.js']);
+  assert.match(fs.readFileSync(path.join(ROOT, 'modules', 'government', 'buildouts.js'), 'utf8'), /const \{ CAPSULES \} = require\('\.\/build-rights'\);/, 'buildouts.js reads the capsules, never a rule');
+});

package/tests/government_buildouts.mjs

@@ -0,0 +1,382 @@
+// tests/government_buildouts.mjs — A LEAD'S BUILD-OUTS: a committee room, a new
+// floor, an annex, or growing a building into a district, as data (task 1004711,
+// goal 1000111; ADR 0378).
+//
+// What this pins (the task's done-when lines, and the walls behind them):
+//   1. STRUCTURE IS DATA. A build-out is a row of government_030 (building,
+//      capsule, name, line, who asked, how it was allowed, when it started);
+//      GET /government/leads carries each building's `structure`: what stands
+//      (going up for a day, then built) and what waits on a vote, with the
+//      docket id its tally rides on.
+//   2. BOTH PATHS WORK. POST /government/buildouts: only the building's holder
+//      may ask; where build_rights (build-rights.js, never a second rule) says
+//      without_vote it is on the record at once with the rule's ground; otherwise
+//      it is filed as a build_out matter through openMatter, the board matters
+//      path — under the board where the building has no sitting, for every
+//      district and for the Charter; at the building's sitting otherwise. A
+//      passed matter puts it on the record naming the item; a returned one
+//      builds nothing.
+//   3. THE WALLS. One SQL writer (db.insertBuildout), called only from
+//      decision-board.js; the trigger refuses a vote its matter did not say, an
+//      at-once district, every edit and every delete.
+// The proposal picture drawn from the real building is pinned in
+// tests/hall_street_deck.mjs; the city's site and ghost in tests/hall_gov_living.mjs.
+// DB-free: db reads/writes are monkeypatched by property.
+//
+// Run:  node --test tests/government_buildouts.mjs
+
+import { strict as assert } from 'node:assert';
+import { test, after } from 'node:test';
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const GOV = path.join(ROOT, 'modules', 'government');
+const bo = require(path.join(GOV, 'buildouts.js'));
+const leads = require(path.join(GOV, 'leads.js'));
+const charter = require(path.join(GOV, 'charter.js'));
+const decisionBoard = require(path.join(GOV, 'decision-board.js'));
+const board = require(path.join(GOV, 'board.js'));
+const config = require(path.join(GOV, 'config.js'));
+const db = require(path.join(GOV, 'db.js'));
+
+const MIGRATION = fs.readFileSync(path.join(GOV, 'migrations', 'government_030_buildouts.sql'), 'utf8');
+const MIGRATION_CODE = MIGRATION.replace(/--[^\n]*/g, '');
+
+const ARCHONS = [{ id: '3', github_login: 'ada', display_name: 'Ada' }];
+const DEE_LEAD = {
+  id: '1', building: 'planning', builder_id: '45', charter: 'Goals, priorities and the order of work.', appointed_by_item_id: '40',
+  appointed_at: '2026-10-09T12:00:00.000Z', removed_by_item_id: null, removed_at: null, github_login: 'dee', display_name: 'Dee',
+};
+function boardOf(form) {
+  const r = charter.buildCharterProposal({ window_minutes: 1440, close_early_on_full_turnout: true }, { form, councilRank: 'trustees' });
+  assert.equal(r.ok, true, form);
+  return r.proposal;
+}
+async function withStubs(stubs, fn) {
+  const saved = [];
+  for (const [obj, k, v] of stubs) { saved.push([obj, k, obj[k]]); obj[k] = v; }
+  try { return await fn(); } finally { for (const [obj, k, v] of saved.reverse()) obj[k] = v; }
+}
+const never = async () => { throw new Error('must not be reached'); };
+// a project under `form`, Dee leading Planning, nothing built yet; `writes` collects every write
+function project(form, { rules = [], standing = [], pending = [], writes = [] } = {}) {
+  return [
+    [config, 'loadGovernmentConfig', () => ({ board: boardOf(form) })],
+    [db, 'listLeads', async () => [DEE_LEAD]],
+    [db, 'listActiveArchons', async () => ARCHONS],
+    [db, 'listDecisionRules', async () => rules],
+    [db, 'getActiveBuildersWithRank', async () => [{ builder_id: '3' }]],
+    [db, 'listBuildouts', async () => standing],
+    [db, 'listPendingBuildouts', async () => pending],
+    [db, 'insertBuildout', async (a) => { writes.push(['insert', a]); return { done: true, buildout: { id: '7', ...a } }; }],
+    [db, 'createMatter', async (a) => { writes.push(['matter', a]); return { id: '8', ...a }; }],
+    [db, 'openBoardItem', async (a) => { writes.push(['item', a]); return { id: '50', subject_type: a.subjectType, subject_id: a.subjectId, constitution: a.constitution }; }],
+  ];
+}
+
+// ── 1. the shape ────────────────────────────────────────────────────────────
+
+test('a build-out is one of the four capsules at one of the nine buildings, with a short name and one line', () => {
+  assert.deepEqual(bo.checkBuildOut({ building: 'planning', capsule: 'floor', name: '  Road-map floor ', line: 'Where the next quarter is planned.' }).buildout,
+    { type: 'build_out', building: 'planning', capsule: 'floor', name: 'Road-map floor', line: 'Where the next quarter is planned.' });
+  assert.deepEqual(bo.checkBuildOut({ building: 'review', capsule: 'committee' }).buildout,
+    { type: 'build_out', building: 'review', capsule: 'committee', name: bo.DEFAULT_NAMES.committee, line: '' }, 'no name: the capsule\'s own');
+  const refused = [
+    [{ building: 'kitchen', capsule: 'floor' }, 'building'],
+    [{ building: 'planning', capsule: 'tower' }, 'capsule'],
+    [{ building: 'planning', capsule: 'floor', name: 'x' }, 'name'],
+    [{ building: 'planning', capsule: 'floor', name: 'x'.repeat(bo.NAME_MAX + 1) }, 'name'],
+    [{ building: 'planning', capsule: 'floor', line: 'two\nlines' }, 'line'],
+    [{ building: 'planning', capsule: 'floor', line: 'x'.repeat(bo.LINE_MAX + 1) }, 'line'],
+    [{ building: 'planning', capsule: 'floor', without_vote: true }, 'without_vote'],
+  ];
+  for (const [raw, field] of refused) assert.equal(bo.checkBuildOut(raw).field, field, JSON.stringify(raw));
+  assert.equal(bo.matterAreaFor('release'), 'release');
+  assert.equal(bo.matterAreaFor('charter'), 'people', 'the Charter takes no matters: its build-outs are People matters');
+});
+
+test('build_out is a matter action at the building it adds to, and nowhere else', () => {
+  const v = (area, a) => decisionBoard.validateMatterAction(area, a);
+  assert.equal(v('release', { type: 'build_out', building: 'release', capsule: 'annex', name: 'Staging annex' }).ok, true, 'at a building whose module acts nothing else');
+  assert.equal(v('rules', { type: 'build_out', building: 'rules', capsule: 'floor' }).ok, true, 'Rules has no other matter acts');
+  assert.equal(v('people', { type: 'build_out', building: 'charter', capsule: 'committee' }).ok, true);
+  assert.equal(v('planning', { type: 'build_out', building: 'release', capsule: 'floor' }).field, 'action.building');
+  assert.equal(v('planning', { type: 'build_out', building: 'planning', capsule: 'floor', ground: 'form' }).reason, 'unknown_field');
+});
+
+test('progress is a real clock: a day from the start, then built', () => {
+  const t0 = Date.parse('2026-10-09T00:00:00.000Z');
+  const row = { started_at: '2026-10-09T00:00:00.000Z' };
+  assert.equal(bo.progressOf(row, t0), 0);
+  assert.equal(bo.progressOf(row, t0 + bo.BUILD_MS / 2), 0.5);
+  assert.equal(bo.progressOf(row, t0 + bo.BUILD_MS * 3), 1);
+  assert.equal(bo.BUILD_HOURS, 24);
+});
+
+// ── 1. the read ─────────────────────────────────────────────────────────────
+
+test('GET /government/leads carries each building\'s structure: what stands, going up or built, and what waits on a vote', () => {
+  const now = Date.parse('2026-10-10T06:00:00.000Z');
+  const standing = [
+    { id: '1', building: 'release', capsule: 'floor', name: 'Staging floor', line: 'Try each release first.', built_by: '3', authorised_by_item_id: null, ground: 'form', why: 'The founder decides alone.', started_at: '2026-10-10T00:00:00.000Z', github_login: 'ada', display_name: 'Ada' },
+    { id: '2', building: 'review', capsule: 'committee', name: 'Copy room', line: '', built_by: '3', authorised_by_item_id: '44', ground: null, why: null, started_at: '2026-10-01T00:00:00.000Z' },
+  ];
+  const pending = [{ item_id: '51', matter_id: '9', action: { type: 'build_out', building: 'treasury', capsule: 'district', name: 'Reserve quarter', line: '' }, opened_at: 'T', closes_at: null }];
+  const v = leads.leadsView([DEE_LEAD], ARCHONS, { structure: { rows: standing, pending, now } });
+  const at = (k) => v.buildings.find((b) => b.building === k).structure;
+  assert.deepEqual(at('release').standing[0], {
+    id: '1', building: 'release', capsule: 'floor', name: 'Staging floor', line: 'Try each release first.', state: 'building', progress: 0.25,
+    started_at: '2026-10-10T00:00:00.000Z', builder: { id: '3', login: 'ada', name: 'Ada' },
+    allowed: { path: 'at_once', ground: 'form', why: 'The founder decides alone.' },
+  });
+  assert.equal(at('review').standing[0].state, 'built');
+  assert.deepEqual(at('review').standing[0].allowed, { path: 'vote', item_id: '44', href: '/board-room?item=44' });
+  assert.deepEqual(at('treasury').proposed, [{ item_id: '51', matter_id: '9', docket_id: 'board:51', building: 'treasury', capsule: 'district', name: 'Reserve quarter', line: '', opened_at: 'T', closes_at: null, href: '/board-room?item=51' }]);
+  assert.deepEqual(at('planning'), { standing: [], proposed: [] });
+  assert.equal(leads.leadsView([DEE_LEAD], ARCHONS).buildings[0].structure, null, 'not read: null, never invented');
+});
+
+test('the server read: a failed build-out read leaves structure out, the rest still answers', async () => {
+  await withStubs([...project('monarchy'), [db, 'listBuildouts', async () => { throw new Error('down'); }]], async () => {
+    const v = await decisionBoard.leadsView();
+    assert.equal(v.buildings.length, 9);
+    assert.equal(v.buildings[0].structure, null);
+  });
+});
+
+// ── 2. the two paths ────────────────────────────────────────────────────────
+
+test('at once: where the form of government lets the holder build, the build-out is on the record now with the rule\'s ground', async () => {
+  const writes = [];
+  await withStubs(project('monarchy', { writes }), async () => {
+    const out = await board.buildOut({ buildout: { building: 'planning', capsule: 'floor', name: 'Road-map floor' }, builderId: '45' });
+    assert.equal(out.ok, true, JSON.stringify(out));
+    assert.equal(out.path, 'at_once');
+    assert.equal(out.rights.ground, 'form');
+  });
+  assert.equal(writes.length, 1);
+  const [kind, a] = writes[0];
+  assert.equal(kind, 'insert');
+  assert.deepEqual(a, { building: 'planning', capsule: 'floor', name: 'Road-map floor', line: '', builtBy: '45', ground: 'form', why: a.why });
+  assert.match(a.why, /founder decides alone/);
+});
+
+test('by vote: where it does not, the build-out is filed as a matter through the board matters path, and nothing is built', async () => {
+  const writes = [];
+  await withStubs(project('direct-democracy', { writes }), async () => {
+    const out = await board.buildOut({ buildout: { building: 'planning', capsule: 'annex', name: 'Research annex', line: 'Spikes live here.' }, builderId: '45' });
+    assert.equal(out.ok, true, JSON.stringify(out));
+    assert.equal(out.path, 'vote');
+    assert.equal(out.rights.without_vote, false);
+    assert.equal(out.decided.sat_under, 'board', 'Planning has no sitting of its own: the board in force decides');
+  });
+  assert.deepEqual(writes.map((w) => w[0]), ['matter', 'item'], 'no build-out written');
+  assert.equal(writes[0][1].area, 'planning');
+  assert.deepEqual(writes[0][1].action, { type: 'build_out', building: 'planning', capsule: 'annex', name: 'Research annex', line: 'Spikes live here.' });
+  assert.equal(writes[0][1].title, 'Add an annex to Planning: Research annex');
+  assert.equal(writes[1][1].subjectType, 'planning_matter');
+});
+
+test('a district always goes to the board, even under a monarchy; the Charter\'s go to the board as People matters', async () => {
+  const writes = [];
+  await withStubs(project('monarchy', { writes }), async () => {
+    const d = await board.buildOut({ buildout: { building: 'planning', capsule: 'district' }, builderId: '45' });
+    assert.equal(d.path, 'vote');
+    assert.equal(d.rights.ground, 'city');
+  });
+  assert.deepEqual(writes.map((w) => w[0]), ['matter', 'item']);
+  const writes2 = [];
+  await withStubs(project('direct-democracy', { writes: writes2 }), async () => {
+    const c = await board.buildOut({ buildout: { building: 'charter', capsule: 'committee', name: 'Drafting room' }, builderId: '3' });
+    assert.equal(c.path, 'vote', JSON.stringify(c));
+  });
+  assert.equal(writes2[0][1].area, 'people');
+  assert.equal(writes2[1][1].subjectType, 'people_matter');
+});
+
+test('a building with a sitting of its own: the vote sits there; a district still goes to the board', async () => {
+  const rules = [{ area: 'release', decided_by: 'rank:release-council', rule: 'consent', who: null, set_by_item_id: '2' }];
+  const writes = [];
+  await withStubs(project('monarchy', { rules, writes }), async () => {
+    const f = await board.buildOut({ buildout: { building: 'release', capsule: 'floor' }, builderId: '3' });
+    assert.equal(f.path, 'vote', JSON.stringify(f));
+    assert.equal(f.rights.ground, 'building');
+    assert.notEqual(f.decided.sat_under, 'board', 'it sits at Release\'s own council');
+    assert.equal(writes[1][1].constitution.membership, 'rank:release-council');
+    const d = await board.buildOut({ buildout: { building: 'release', capsule: 'district' }, builderId: '3' });
+    assert.equal(d.decided.sat_under, 'board');
+  });
+});
+
+test('only the holder may ask: the Lead where seated, the owner seat elsewhere; nobody else, and nothing is written', async () => {
+  const writes = [];
+  await withStubs(project('monarchy', { writes }), async () => {
+    const stranger = await board.buildOut({ buildout: { building: 'planning', capsule: 'floor' }, builderId: '3' });
+    assert.equal(stranger.reason, 'not_the_holder', 'the owner does not build in a building its Lead holds');
+    assert.match(stranger.what_this_means, /led by Dee/);
+    const lead = await board.buildOut({ buildout: { building: 'release', capsule: 'floor' }, builderId: '45' });
+    assert.equal(lead.reason, 'not_the_holder', 'a Lead builds only their own building');
+    assert.equal((await board.buildOut({ buildout: { building: 'release', capsule: 'floor' }, builderId: '3' })).path, 'at_once', 'unseated: the owner holds it');
+    assert.equal((await board.buildOut({ buildout: { building: 'release', capsule: 'tower' }, builderId: '3' })).field, 'capsule');
+  });
+  assert.equal(writes.length, 1);
+});
+
+test('fail closed: build rights that cannot be read are a vote', async () => {
+  const writes = [];
+  // the table is unreadable when the rights are read, and readable again when the matter is filed
+  let reads = 0;
+  const flaky = async () => { reads += 1; if (reads === 1) throw new Error('down'); return []; };
+  await withStubs([...project('monarchy', { writes }), [db, 'listDecisionRules', flaky]], async () => {
+    const out = await board.buildOut({ buildout: { building: 'planning', capsule: 'floor' }, builderId: '45' });
+    assert.equal(out.path, 'vote', JSON.stringify(out));
+    assert.equal(out.rights.without_vote, false);
+  });
+  assert.equal(writes.some((w) => w[0] === 'insert'), false);
+});
+
+function closeWith({ action, outcome = 'passed', area = 'planning' }) {
+  const writes = [];
+  const subjectType = `${area}_matter`;
+  return withStubs([
+    [db, 'getVotesForItem', async () => [{ voter_id: '9', direction: outcome === 'passed' ? 'yes' : 'no' }]],
+    [db, 'closeBoardItem', async ({ outcome: o }) => ({ id: '50', subject_type: subjectType, subject_id: '8', opened_by: '45', closed_at: 'T', outcome: o })],
+    [db, 'getMatter', async () => ({ id: '8', area, title: 'Add a floor', action, proposed_by: '45' })],
+    [db, 'insertBuildout', async (a) => { writes.push(a); return { done: true, buildout: { id: '7' } }; }],
+    [db, 'insertAuthorRatifyKarma', never],
+    [db, 'getBoardItemAuthor', async () => '45'],
+  ], async () => board.closeItem({ id: '50', subject_type: subjectType, subject_id: '8', opened_by: '45', closed_at: null, constitution: { membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true } }))
+    .then((out) => ({ out, writes }));
+}
+
+test('a passed build_out matter puts it on the record naming the item; a returned one builds nothing', async () => {
+  const action = { type: 'build_out', building: 'planning', capsule: 'annex', name: 'Research annex', line: 'Spikes live here.' };
+  const passed = await closeWith({ action });
+  assert.equal(passed.out.outcome, 'passed');
+  assert.deepEqual(passed.out.acted, { area: 'planning', matter_id: '8', action: 'build_out', done: true, building: 'planning', capsule: 'annex' });
+  assert.deepEqual(passed.writes, [{ building: 'planning', capsule: 'annex', name: 'Research annex', line: 'Spikes live here.', builtBy: '45', itemId: '50' }]);
+  const returned = await closeWith({ action, outcome: 'returned' });
+  assert.deepEqual(returned.writes, []);
+  const charterRoom = await closeWith({ action: { type: 'build_out', building: 'charter', capsule: 'committee', name: 'Drafting room', line: '' }, area: 'people' });
+  assert.equal(charterRoom.writes[0].building, 'charter', 'a People matter builds at the Charter');
+});
+
+// ── 3. the walls ────────────────────────────────────────────────────────────
+
+test('government_030: a vote builds only what its passed matter said; at once never a district; no edit, no delete', () => {
+  assert.match(MIGRATION_CODE, /CREATE TABLE IF NOT EXISTS government_buildouts/);
+  assert.match(MIGRATION_CODE, /CHECK \(capsule IN \('committee', 'floor', 'annex', 'district'\)\)/);
+  assert.match(MIGRATION_CODE, /CONSTRAINT government_buildouts_one_path CHECK \(\(authorised_by_item_id IS NULL\) <> \(ground IS NULL\)\)/, 'exactly one way it was allowed');
+  assert.match(MIGRATION_CODE, /CONSTRAINT government_buildouts_district_votes CHECK \(capsule <> 'district' OR authorised_by_item_id IS NOT NULL\)/);
+  assert.match(MIGRATION_CODE, /i\.subject_type = m\.area \|\| '_matter'\s+AND i\.outcome = 'passed'/, 'only a passed matter');
+  assert.match(MIGRATION_CODE, /act->>'type' IS DISTINCT FROM 'build_out'\s+OR act->>'building' IS DISTINCT FROM NEW\.building\s+OR act->>'capsule' IS DISTINCT FROM NEW\.capsule\s+OR act->>'name' IS DISTINCT FROM NEW\.name\s+OR act->>'line' IS DISTINCT FROM NEW\.line THEN\s+RAISE EXCEPTION/);
+  assert.match(MIGRATION_CODE, /IF TG_OP <> 'INSERT' THEN\s+RAISE EXCEPTION/, 'no edit, no delete');
+  assert.match(MIGRATION_CODE, /ELSIF NEW\.ground IS NULL OR NEW\.why IS NULL OR NEW\.capsule = 'district' THEN\s+RAISE EXCEPTION/);
+  assert.match(MIGRATION_CODE, /NEW\.started_at := now\(\)/, 'when is the database clock');
+  assert.match(MIGRATION_CODE, /BEFORE INSERT OR UPDATE OR DELETE ON government_buildouts/);
+  assert.doesNotMatch(MIGRATION_CODE, /INSERT INTO government_buildouts/, 'nothing is seeded');
+});
+
+test('one writer, one caller: db.insertBuildout; only decision-board calls it; no route does', () => {
+  const dbSrc = fs.readFileSync(path.join(GOV, 'db.js'), 'utf8');
+  assert.equal((dbSrc.match(/INSERT INTO government_buildouts/g) || []).length, 1);
+  assert.equal((dbSrc.match(/UPDATE government_buildouts|DELETE FROM government_buildouts/g) || []).length, 0);
+  const callers = [];
+  const walk = (dir) => {
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+      const p = path.join(dir, e.name);
+      if (e.isDirectory()) { if (e.name !== 'node_modules' && e.name !== 'migrations') walk(p); continue; }
+      if (e.name.endsWith('.js') && /insertBuildout\(/.test(fs.readFileSync(p, 'utf8'))) callers.push(path.relative(ROOT, p).replace(/\\/g, '/'));
+    }
+  };
+  walk(path.join(ROOT, 'modules'));
+  walk(path.join(ROOT, 'src'));
+  assert.deepEqual(callers.sort(), ['modules/government/db.js', 'modules/government/decision-board.js']);
+  // the at-once answer is read off the build rule, never decided here
+  const dbSrcBoard = fs.readFileSync(path.join(GOV, 'decision-board.js'), 'utf8');
+  assert.doesNotMatch(dbSrcBoard, /buildRight\(|FORM_ANSWERS/, 'decision-board asks build-rights through the read, never a second rule');
+});
+
+// ── the route, through the real router ──────────────────────────────────────
+
+const api = require(path.join(ROOT, 'src', 'module-api.js'));
+const seams = require(path.join(ROOT, 'src', 'module-seams.js'));
+const rrc = require(path.join(ROOT, 'src', 'bongos', 'route-rank-check.js'));
+const { attachFail } = require(path.join(ROOT, 'src', 'bongos', 'middleware', 'error-envelope.js'));
+const express = require('express');
+
+const realRequireBuilder = api.requireBuilder;
+let caller = 45;
+api.requireBuilder = (req, res, next) => { req.builder = { id: caller, rank: 'metic' }; next(); };
+seams._reset();
+let held = ['board.vote.cast'];
+seams.registerProvider('government', { resolveBuilderPermissions: async () => held });
+const buildGovernmentRouter = require(path.join(GOV, 'routes', 'government.js'));
+const app = express();
+app.use(express.json());
+app.use(attachFail);
+app.use(buildGovernmentRouter());
+const server = http.createServer(app);
+await new Promise((r) => server.listen(0, '127.0.0.1', r));
+const BASE = `http://127.0.0.1:${server.address().port}`;
+after(() => { server.close(); api.requireBuilder = realRequireBuilder; seams._reset(); });
+async function call(method, p, body) {
+  const res = await fetch(`${BASE}${p}`, { method, headers: body === undefined ? {} : { 'content-type': 'application/json' }, body: body === undefined ? undefined : JSON.stringify(body) });
+  let json = null; try { json = await res.json(); } catch { /* none */ }
+  return { status: res.status, json };
+}
+
+test('POST /government/buildouts is pinned where the room reads; the holder is the wall inside', () => {
+  assert.equal(rrc.MODULE_EXPECTED_RANKS.government['POST /government/buildouts'], 'perm:board.vote.cast');
+});
+
+test('POST /government/buildouts: 201 at once, 201 filed as a vote, 403 for anyone but the holder, 400 for a bad ask, 403 without the atom', async () => {
+  await withStubs(project('monarchy'), async () => {
+    const now = await call('POST', '/government/buildouts', { building: 'planning', capsule: 'committee', name: 'Triage room' });
+    assert.equal(now.status, 201, JSON.stringify(now.json));
+    assert.equal(now.json.path, 'at_once');
+    assert.equal(now.json.buildout.capsule, 'committee');
+    const vote = await call('POST', '/government/buildouts', { building: 'planning', capsule: 'district' });
+    assert.equal(vote.status, 201);
+    assert.equal(vote.json.path, 'vote');
+    assert.equal(vote.json.item.subject_type, 'planning_matter');
+    const other = await call('POST', '/government/buildouts', { building: 'release', capsule: 'floor' });
+    assert.equal(other.status, 403);
+    assert.equal(other.json.error.code, 'not_the_holder');
+    const bad = await call('POST', '/government/buildouts', { building: 'planning', capsule: 'tower' });
+    assert.equal(bad.status, 400);
+    assert.equal(bad.json.error.code, 'invalid_buildout');
+  });
+  held = [];
+  try { assert.equal((await call('POST', '/government/buildouts', { building: 'planning', capsule: 'floor' })).status, 403); } finally { held = ['board.vote.cast']; }
+});
+
+test('the matters route meets the same wall: a build_out filed straight at POST /government/board/matters by anyone but the holder is refused, and nothing is filed', async () => {
+  const writes = [];
+  held = ['board.item.open', 'board.vote.cast'];
+  try {
+    await withStubs(project('direct-democracy', { writes }), async () => {
+      caller = 3; // the owner seat, but Planning is Dee's
+      const other = await call('POST', '/government/board/matters', { area: 'planning', title: 'Add a floor to Planning', action: { type: 'build_out', building: 'planning', capsule: 'floor' } });
+      assert.equal(other.status, 403, JSON.stringify(other.json));
+      assert.equal(other.json.error.code, 'not_the_holder');
+      assert.match(JSON.stringify(other.json), /Ask them to put it up/, 'the refusal says where to go instead');
+      assert.deepEqual(writes, [], 'nothing filed');
+      caller = 45; // Dee holds Planning: filed for the vote
+      const mine = await call('POST', '/government/board/matters', { area: 'planning', title: 'Add a floor to Planning', action: { type: 'build_out', building: 'planning', capsule: 'floor' } });
+      assert.equal(mine.status, 201, JSON.stringify(mine.json));
+      assert.deepEqual(writes.map((w) => w[0]), ['matter', 'item']);
+    });
+    // and openMatter itself, whoever calls it
+    await withStubs(project('direct-democracy'), async () => {
+      const out = await board.openMatter({ area: 'release', title: 'Add an annex', action: { type: 'build_out', building: 'release', capsule: 'annex' }, proposedBy: '45' });
+      assert.equal(out.reason, 'not_the_holder', 'a Lead is not the holder of a building they do not lead');
+      assert.match(out.what_this_means, /no Lead, so only the owner grows it\. Ask the owner/);
+    });
+  } finally { held = ['board.vote.cast']; caller = 45; }
+});