@bongos/core 1.21.8 → 1.21.10

package/tests/government_decision_rules.mjs

@@ -0,0 +1,701 @@
+// tests/government_decision_rules.mjs — WHO DECIDES WHAT, set per project by
+// amendment (task 1004529, goal 1000125 the Governor City; ADR 0363).
+//
+// What this pins:
+//   1. THE DEFAULTS ARE TODAY. government_023 seeds one row per building, each
+//      meaning "as today" (the fixed gate; the charter's board), and every
+//      building reads that way with no rows at all — no permission changes for
+//      an existing project until it amends itself.
+//   2. THE FOUR GOVERNMENTS ARE EXPRESSIBLE — read off the design file itself
+//      (docs/design/mocks/governor-city/Governments.dc.html): one founder, a
+//      council, everyone votes, a board of trustees, each as a valid
+//      constitution plus valid table rows whose resolved rule per building is
+//      the design's glyph.
+//   3. CHANGED ONLY BY A PASSED AMENDMENT. The table is written in exactly one
+//      place — inside the transaction that closes a decision-rules amendment as
+//      passed — under a guard that refuses every other shape; the SQL carries
+//      the same condition and the migration's trigger refuses any other write.
+//      No route writes it.
+//   4. MORE SUBJECTS. Eight building matters join the board's three subjects; a
+//      matter opens only where an amendment handed the building to a sitting,
+//      and sits under the row's own rule (sign-off holds the proposer to the
+//      author rule).
+//   5. THE GATE IS REPLACED WHERE THE BUILDING ALLOWS IT — People's rank
+//      assignments defer to People's row; a passed People matter acts by itself.
+//   6. THE FEED READS THE TABLE — the docket's buildings carry who decides, and a
+//      building's sitting carries the table's rule.
+//
+// DB-free: db reads/writes are monkeypatched by property.
+//
+// Run:  node tests/government_decision_rules.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 dr = require(path.join(GOV, 'decision-rules.js'));
+const vocab = require(path.join(GOV, 'docket-vocab.js'));
+const catalog = require(path.join(GOV, 'catalog.js'));
+const board = require(path.join(GOV, 'board.js'));
+const db = require(path.join(GOV, 'db.js'));
+const config = require(path.join(GOV, 'config.js'));
+const docket = require(path.join(GOV, 'docket.js'));
+
+const MIGRATION = fs.readFileSync(path.join(GOV, 'migrations', 'government_023_decision_rules.sql'), 'utf8');
+const MIGRATION_CODE = MIGRATION.replace(/--[^\n]*/g, '');
+
+async function withDb(stubs, fn) {
+  const originals = {};
+  for (const [k, v] of Object.entries(stubs)) { originals[k] = db[k]; db[k] = v; }
+  try { return await fn(); } finally { for (const [k, v] of Object.entries(originals)) db[k] = v; }
+}
+
+const MONARCHY = Object.freeze({ membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true });
+
+// ── 1. the defaults are today ───────────────────────────────────────────────
+
+test('the nine buildings are the docket\'s nine, in street order, each gate a real permission', () => {
+  assert.deepEqual(dr.AREA_KEYS, vocab.BUILDING_KEYS);
+  for (const a of dr.AREAS) {
+    if (a.key === 'charter') { assert.equal(a.gate, null); continue; }
+    assert.ok(catalog.byKey(a.gate), `${a.key}: gate ${a.gate} is a catalog permission`);
+  }
+});
+
+test('with no rows at all every building reads AS TODAY: the gate decides alone, the charter is the board', () => {
+  const all = dr.resolveAll([], { board: MONARCHY });
+  assert.deepEqual(all.map((r) => r.area), vocab.BUILDING_KEYS);
+  for (const r of all) {
+    assert.equal(r.as_today, true, `${r.area} is as today`);
+    assert.equal(r.sitting, false, `${r.area}: nothing goes to a sitting`);
+    assert.equal(r.set_by_item_id, null);
+    assert.equal(dr.mayActAlone(r), true, `${r.area}: whoever holds the gate may still act alone`);
+    if (r.area === 'charter') {
+      assert.equal(r.decided_by, 'board');
+      assert.equal(r.rule, 'first', 'the charter reads the board\'s own pass rule (monarchy: first yes)');
+    } else {
+      assert.equal(r.decided_by, 'gate');
+      assert.equal(r.rule, 'decide');
+    }
+  }
+});
+
+test('the migration seeds exactly the as-today row for every building, and nothing else', () => {
+  const seedBlock = /FROM \(VALUES([\s\S]*?)\) AS v\(area, decided_by\)/.exec(MIGRATION_CODE)[1];
+  const values = [...seedBlock.matchAll(/\('(\w+)',\s*'(gate|board)'\)/g)].map((m) => [m[1], m[2]]);
+  assert.deepEqual(values.map(([a]) => a), dr.AREA_KEYS, 'one seed row per building, in order');
+  for (const [area, decidedBy] of values) assert.equal(decidedBy, dr.defaultRow(area).decided_by);
+  assert.match(MIGRATION_CODE, /INSERT INTO government_decision_rules \(area, decided_by, rule\)\s+SELECT v\.area, v\.decided_by, NULL/,
+    'the seed carries no rule of its own — a default row means "as today"');
+  // a stored row that is malformed reads as the default: never wider than today
+  const odd = dr.resolveRow({ area: 'people', decided_by: 'rank:xenos+', rule: 'by_acclamation' });
+  assert.equal(odd.as_today, true);
+});
+
+test('a malformed board block cannot make the charter row read wider', () => {
+  const r = dr.resolveRow({ area: 'charter', decided_by: 'gate', rule: null }, { board: MONARCHY });
+  assert.equal(r.decided_by, 'board', 'the charter is the board, always');
+});
+
+// ── 2. the four governments, read off the design of record ───────────────────
+
+const GOVERNMENTS_SRC = fs.readFileSync(path.join(ROOT, 'docs', 'design', 'mocks', 'governor-city', 'Governments.dc.html'), 'utf8');
+function designCells() {
+  const lists = [...GOVERNMENTS_SRC.matchAll(/cells: (\[\[[^\n]*\]\])/g)].map((m) => Function(`return ${m[1]}`)());
+  const auto = Function(`return ${/const automation = (\[\[[^\n]*\]\]);/.exec(GOVERNMENTS_SRC)[1]}`)();
+  const rowNames = Function(`return ${/const rowNames = (\[[^\n]*\]);/.exec(GOVERNMENTS_SRC)[1]}`)();
+  const names = [...GOVERNMENTS_SRC.matchAll(/name: '([^']+)', form: '([^']+)'/g)].map((m) => m[1]);
+  return lists.map((cells, i) => {
+    const full = [...cells, auto[i]];
+    return { name: names[i], byArea: Object.fromEntries(rowNames.map((n, r) => [n.toLowerCase(), { who: full[r][0], how: full[r][1] }])) };
+  });
+}
+
+// Each government written as THIS system expresses it: a constitution (the
+// charter's board) + the table's rows. Custom ranks (council, tester, lead,
+// trustee, maintainer, treasurer) are a project's own rank rows.
+const EXPRESSED = {
+  'One founder': {
+    board: MONARCHY,
+    rules: [
+      { area: 'rules', decided_by: 'rank:archon', rule: 'decide', who: 'you' },
+      { area: 'treasury', decided_by: 'rank:archon', rule: 'decide', who: 'you' },
+      { area: 'planning', decided_by: 'rank:archon', rule: 'decide', who: 'you' },
+      { area: 'review', decided_by: 'rank:xenos+', rule: 'signoff', who: 'any builder who did not build it' },
+      { area: 'release', decided_by: 'rank:archon', rule: 'decide', who: 'you' },
+      { area: 'people', decided_by: 'rank:archon', rule: 'first', who: 'you' },
+      { area: 'disputes', decided_by: 'rank:archon', rule: 'decide', who: 'you' },
+      { area: 'automation', decided_by: 'rank:archon', rule: 'decide', who: 'you' },
+    ],
+  },
+  'A council': {
+    board: { membership: 'rank:council', pass_rule: 'unanimous', window_minutes: 1440, close_early_on_full_turnout: true },
+    rules: [
+      { area: 'rules', decided_by: 'rank:council', rule: 'majority', who: 'the council' },
+      { area: 'treasury', decided_by: 'rank:treasurer', rule: 'decide', who: 'Mira under $50, the council above' },
+      { area: 'planning', decided_by: 'rank:council', rule: 'majority', who: 'the council' },
+      { area: 'review', decided_by: 'nobody', rule: 'vacant', who: 'no one yet' },
+      { area: 'release', decided_by: 'rank:archon', rule: 'decide', who: 'you' },
+      { area: 'people', decided_by: 'rank:council', rule: 'consent', who: 'the council' },
+      { area: 'disputes', decided_by: 'rank:council', rule: 'decide', who: 'one member, on rota' },
+      { area: 'automation', decided_by: 'rank:archon', rule: 'decide', who: 'you, the owner' },
+    ],
+  },
+  'Everyone votes': {
+    board: { membership: 'rank:xenos+', pass_rule: 'majority', window_minutes: 1440, close_early_on_full_turnout: true },
+    rules: [
+      { area: 'rules', decided_by: 'rank:xenos+', rule: 'majority', who: 'every member' },
+      { area: 'treasury', decided_by: 'rank:xenos+', rule: 'consent', who: 'every member' },
+      { area: 'planning', decided_by: 'rank:xenos+', rule: 'majority', who: 'every member' },
+      { area: 'review', decided_by: 'rank:tester', rule: 'signoff', who: 'testers' },
+      { area: 'release', decided_by: 'rank:lead', rule: 'first', who: 'any lead' },
+      { area: 'people', decided_by: 'rank:xenos+', rule: 'consent', who: 'every member' },
+      { area: 'disputes', decided_by: 'rank:xenos+', rule: 'majority', who: 'every member' },
+      { area: 'automation', decided_by: 'rank:xenos+', rule: 'majority', who: 'every member' },
+    ],
+  },
+  'A board of trustees': {
+    board: { membership: 'rank:trustee', pass_rule: 'unanimous', window_minutes: 1440, close_early_on_full_turnout: true },
+    rules: [
+      { area: 'rules', decided_by: 'rank:trustee', rule: 'majority', who: 'the trustees' },
+      { area: 'treasury', decided_by: 'rank:trustee', rule: 'majority', who: 'the trustees' },
+      { area: 'planning', decided_by: 'rank:maintainer', rule: 'first', who: 'the maintainers' },
+      { area: 'review', decided_by: 'rank:reviewer', rule: 'signoff', who: 'reviewers' },
+      { area: 'release', decided_by: 'rank:maintainer', rule: 'first', who: 'any maintainer' },
+      { area: 'people', decided_by: 'rank:maintainer', rule: 'consent', who: 'the maintainers' },
+      { area: 'disputes', decided_by: 'rank:trustee', rule: 'majority', who: 'the trustees' },
+      { area: 'automation', decided_by: 'rank:trustee', rule: 'majority', who: 'the trustees' },
+    ],
+  },
+};
+
+test('the design file names four governments over all nine buildings', () => {
+  const govs = designCells();
+  assert.deepEqual(govs.map((g) => g.name), ['One founder', 'A council', 'Everyone votes', 'A board of trustees']);
+  for (const g of govs) assert.deepEqual(Object.keys(g.byArea).sort(), [...dr.AREA_KEYS].sort());
+});
+
+for (const g of designCells()) {
+  test(`expressible: ${g.name} — a valid constitution + valid rows, every building's rule the design's glyph`, () => {
+    const e = EXPRESSED[g.name];
+    assert.ok(e, `an expression of ${g.name}`);
+    assert.equal(board.validateProposedConstitution(e.board).ok, true, 'its charter is a valid constitution');
+    const v = dr.validateDecisionRulesProposal(e.rules);
+    assert.equal(v.ok, true, JSON.stringify(v));
+    const resolved = dr.resolveAll(v.rules, { board: e.board });
+    for (const r of resolved) {
+      const cell = g.byArea[r.area];
+      // A one-seat board's first yes IS that person deciding alone: the founder's
+      // charter (monarchy, first_ratifier over rank:archon) is the design's 'decide'.
+      const expected = r.area === 'charter' && cell.how === 'decide' && e.board.pass_rule === 'first_ratifier' ? 'first' : cell.how;
+      assert.equal(r.rule, expected, `${g.name} · ${r.area}: design says "${cell.who}, ${cell.how}"`);
+      if (r.area !== 'charter') assert.equal(r.who, cell.who, `${g.name} · ${r.area}: the seat in the design's words`);
+    }
+  });
+}
+
+// ── strict validation ───────────────────────────────────────────────────────
+
+test('a proposal is validated strictly: every refusal named, nothing corrected', () => {
+  const ok = [{ area: 'people', decided_by: 'rank:council', rule: 'consent' }];
+  assert.equal(dr.validateDecisionRulesProposal(ok).ok, true);
+  const cases = [
+    [null, 'proposal_not_a_list'],
+    [[], 'proposal_not_a_list'],
+    [[{ area: 'people', decided_by: 'rank:council', rule: 'consent', extra: 1 }], 'unknown_field'],
+    [[{ area: 'kitchen', decided_by: 'gate' }], 'unknown_area'],
+    [[{ area: 'people', decided_by: 'gate' }, { area: 'people', decided_by: 'gate' }], 'duplicate_area'],
+    [[{ area: 'charter', decided_by: 'rank:council', rule: 'unanimous' }], 'charter_is_the_board'],
+    [[{ area: 'people', decided_by: 'board' }], 'only_the_charter_is_the_board'],
+    [[{ area: 'people', decided_by: 'gate', rule: 'consent' }], 'gate_takes_no_rule'],
+    [[{ area: 'review', decided_by: 'nobody', rule: 'consent' }], 'nobody_is_vacant'],
+    [[{ area: 'people', decided_by: 'everyone', rule: 'consent' }], 'bad_decided_by'],
+    [[{ area: 'people', decided_by: 'rank:council', rule: 'vacant' }], 'bad_rule'],
+    [[{ area: 'people', decided_by: 'rank:council', rule: 'by_acclamation' }], 'bad_rule'],
+    [[{ area: 'people', decided_by: 'rank:council', rule: 'consent', who: '' }], 'bad_who'],
+  ];
+  for (const [raw, reason] of cases) {
+    const v = dr.validateDecisionRulesProposal(raw);
+    assert.equal(v.ok, false, `${JSON.stringify(raw)} refused`);
+    assert.equal(v.reason, reason, JSON.stringify(raw));
+  }
+  // returning a building to its gate is a legal change
+  assert.equal(dr.validateDecisionRulesProposal([{ area: 'people', decided_by: 'gate' }]).ok, true);
+});
+
+test('a sitting is snapshotted from the row: who, how, and a clock only where expiry means return', () => {
+  const board4 = { ...MONARCHY, window_minutes: 90 };
+  const maj = dr.sittingConstitution(dr.resolveRow({ area: 'rules', decided_by: 'rank:council', rule: 'majority' }), { board: board4 });
+  assert.deepEqual({ ...maj }, { membership: 'rank:council', pass_rule: 'majority', window_minutes: 90, close_early_on_full_turnout: true, rule: 'majority', area: 'rules' });
+  const con = dr.sittingConstitution(dr.resolveRow({ area: 'people', decided_by: 'rank:council', rule: 'consent' }), { board: board4 });
+  assert.equal(con.window_minutes, null, 'consent passes on silence — no clock');
+  const sign = dr.sittingConstitution(dr.resolveRow({ area: 'review', decided_by: 'rank:tester', rule: 'signoff' }), { board: board4 });
+  assert.equal(sign.pass_rule, 'first_ratifier');
+  assert.equal(sign.window_minutes, null);
+  assert.equal(dr.sittingConstitution(dr.resolveRow({ area: 'review', decided_by: 'nobody', rule: 'vacant' }), { board: board4 }), null);
+  assert.equal(dr.sittingConstitution(dr.resolveRow({ area: 'review', decided_by: 'gate', rule: null }), { board: board4 }), null);
+});
+
+test('mayActAlone: as today yes; decide/first only a seated member; any other rule nobody', () => {
+  const R = (decided_by, rule) => dr.resolveRow({ area: 'people', decided_by, rule });
+  assert.equal(dr.mayActAlone(R('gate', null)), true);
+  assert.equal(dr.mayActAlone(R('rank:council', 'decide'), { seated: true }), true);
+  assert.equal(dr.mayActAlone(R('rank:council', 'decide'), { seated: false }), false);
+  assert.equal(dr.mayActAlone(R('rank:council', 'first'), { seated: true }), true);
+  for (const rule of ['consent', 'majority', 'unanimous', 'signoff']) {
+    assert.equal(dr.mayActAlone(R('rank:council', rule), { seated: true }), false, rule);
+  }
+  assert.equal(dr.mayActAlone(R('nobody', 'vacant'), { seated: true }), false);
+});
+
+// ── 3. changed only by a passed amendment ───────────────────────────────────
+
+test('proposing files a decision_rules amendment, sat under the constitution IN FORCE', async () => {
+  let created = null; let opened = null;
+  await withDb({
+    getRankByKey: async (k) => ({ rank_key: k, is_system: false }),
+    listDecisionRules: async () => [],
+    createAmendment: async (args) => { created = args; return { id: '5', ...args }; },
+    openBoardItem: async (args) => { opened = args; return { id: '21', subject_type: args.subjectType, subject_id: args.subjectId, constitution: args.constitution }; },
+  }, async () => {
+    const out = await board.proposeDecisionRules({ rules: [{ area: 'people', decided_by: 'rank:council', rule: 'consent', who: 'the council' }], proposedBy: '42' });
+    assert.equal(out.ok, true, JSON.stringify(out));
+  });
+  assert.equal(created.kind, 'decision_rules');
+  assert.deepEqual(created.proposed, { decision_rules: [{ area: 'people', decided_by: 'rank:council', rule: 'consent', who: 'the council' }] });
+  assert.match(created.rationaleMd, /People: the council, passes unless someone objects/);
+  assert.equal(opened.subjectType, 'constitutional_amendment', 'one amendment subject, one pass path');
+  assert.equal(opened.constitution.pass_rule, 'first_ratifier', 'decided under the board in force (this checkout: monarchy)');
+});
+
+test('proposing refuses an unknown rank, a no-op, and anything malformed — before any write', async () => {
+  const never = async () => { throw new Error('must not be reached'); };
+  await withDb({
+    getRankByKey: async () => null,
+    listDecisionRules: async () => [],
+    createAmendment: never,
+    openBoardItem: never,
+  }, async () => {
+    const unknown = await board.proposeDecisionRules({ rules: [{ area: 'people', decided_by: 'rank:council', rule: 'consent' }], proposedBy: '42' });
+    assert.equal(unknown.reason, 'unknown_rank');
+    assert.equal(unknown.rank_key, 'council');
+    const noop = await board.proposeDecisionRules({ rules: [{ area: 'people', decided_by: 'gate' }], proposedBy: '42' });
+    assert.equal(noop.reason, 'no_change', 'People is already as today');
+    const bad = await board.proposeDecisionRules({ rules: [{ area: 'charter', decided_by: 'rank:archon', rule: 'decide' }], proposedBy: '42' });
+    assert.equal(bad.reason, 'charter_is_the_board');
+    assert.equal((await board.proposeDecisionRules({ rules: [{ area: 'people', decided_by: 'rank:metic+', rule: 'consent' }], proposedBy: null })).reason, 'missing_proposer');
+  });
+});
+
+const rulesAmendment = { id: '5', kind: 'decision_rules', proposed: { decision_rules: [{ area: 'people', decided_by: 'rank:council', rule: 'consent', who: null }] } };
+const amendmentItem = (over = {}) => ({ id: '21', subject_type: 'constitutional_amendment', subject_id: '5', opened_by: '42', closed_at: null, expired: false, constitution: MONARCHY, ...over });
+
+// A closeBoardItem stub that behaves like the real one: afterClose runs INSIDE
+// the "transaction"; a throw from it rolls the close back (nothing is closed).
+function txClose(log) {
+  return async ({ itemId, outcome, afterClose }) => {
+    const closedRow = { ...amendmentItem({ id: itemId }), closed_at: 'T', outcome };
+    const client = { tx: true };
+    if (typeof afterClose === 'function') {
+      try { await afterClose(client, closedRow); } catch (err) { log.push('rolled_back'); throw err; }
+    }
+    log.push('committed');
+    return closedRow;
+  };
+}
+
+test('a PASSED decision-rules amendment writes the rows inside the closing transaction — and never touches the board block', async () => {
+  const log = [];
+  let written = null;
+  const origApply = config.applyBoardAmendment;
+  config.applyBoardAmendment = () => { throw new Error('a rules amendment must not rewrite the board block'); };
+  try {
+    await withDb({
+      getVotesForItem: async () => [{ voter_id: '42', direction: 'yes' }],
+      getAmendment: async (id) => { assert.equal(String(id), '5'); return rulesAmendment; },
+      applyDecisionRules: async (client, args) => { assert.equal(client.tx, true, 'the closing transaction\'s client'); written = args; return 1; },
+      closeBoardItem: txClose(log),
+      getBoardItemAuthor: async () => '42',
+      insertAuthorRatifyKarma: async () => true,
+    }, async () => {
+      const out = await board.closeItem(amendmentItem());
+      assert.equal(out.outcome, 'passed');
+      assert.deepEqual(out.applied_decision_rules.map((r) => r.area), ['people']);
+      assert.equal(out.applied_constitution, undefined);
+    });
+  } finally { config.applyBoardAmendment = origApply; }
+  assert.deepEqual(log, ['committed']);
+  assert.equal(String(written.itemId), '21');
+  assert.deepEqual(written.rules.map((r) => [r.area, r.decided_by, r.rule]), [['people', 'rank:council', 'consent']]);
+});
+
+test('a RETURNED decision-rules amendment writes nothing', async () => {
+  await withDb({
+    getVotesForItem: async () => [{ voter_id: '9', direction: 'no', reason_md: 'r', section_key: 'fit' }],
+    getAmendment: async () => { throw new Error('must not be reached — a return applies nothing'); },
+    applyDecisionRules: async () => { throw new Error('must not be reached'); },
+    closeBoardItem: async ({ outcome, afterClose }) => { assert.equal(afterClose, null); return { ...amendmentItem(), closed_at: 'T', outcome }; },
+  }, async () => {
+    const out = await board.closeItem(amendmentItem());
+    assert.equal(out.outcome, 'returned');
+    assert.equal(out.applied_decision_rules, undefined);
+  });
+});
+
+test('THE GUARD: only a passed decision-rules amendment, naming its own amendment, may write the table', async () => {
+  const passed = { id: '21', subject_type: 'constitutional_amendment', subject_id: '5', outcome: 'passed' };
+  assert.equal(board.decisionRulesWriteAllowed(passed, rulesAmendment), true);
+  const refused = [
+    [{ ...passed, outcome: 'returned' }, rulesAmendment, 'a returned sitting'],
+    [{ ...passed, outcome: null }, rulesAmendment, 'an open sitting'],
+    [{ ...passed, subject_type: 'people_matter' }, rulesAmendment, 'a matter, not an amendment'],
+    [{ ...passed, subject_type: 'full_idea' }, rulesAmendment, 'an idea'],
+    [passed, { ...rulesAmendment, kind: 'constitution' }, 'a board-block amendment'],
+    [passed, { ...rulesAmendment, kind: undefined }, 'an amendment of no kind'],
+    [{ ...passed, subject_id: '6' }, rulesAmendment, 'another amendment\'s item'],
+    [null, rulesAmendment, 'no item'],
+    [passed, null, 'no amendment'],
+  ];
+  await withDb({ applyDecisionRules: async () => { throw new Error('the write must never be reached'); } }, async () => {
+    for (const [row, am, why] of refused) {
+      assert.equal(board.decisionRulesWriteAllowed(row, am), false, why);
+      await assert.rejects(() => board.applyPassedDecisionRules({ tx: true }, row, am), /only be written by a passed decision-rules amendment/, why);
+    }
+  });
+});
+
+test('a failed write rolls the close back — the sitting is retried, never passed-but-unapplied', async () => {
+  const log = [];
+  await withDb({
+    getVotesForItem: async () => [{ voter_id: '42', direction: 'yes' }],
+    getAmendment: async () => rulesAmendment,
+    applyDecisionRules: async () => { throw new Error('trigger refused'); },
+    closeBoardItem: txClose(log),
+  }, async () => {
+    await assert.rejects(() => board.closeItem(amendmentItem()), /trigger refused/);
+  });
+  assert.deepEqual(log, ['rolled_back']);
+});
+
+test('nothing else writes the table: one writer in db.js, one caller in decision-board.js, no route, and the database refuses the rest', () => {
+  const files = [];
+  const walk = (dir) => {
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (e.name === 'node_modules' || e.name.startsWith('.')) continue;
+      const p = path.join(dir, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (/\.(js|mjs|cjs)$/.test(e.name)) files.push(p);
+    }
+  };
+  walk(path.join(ROOT, 'modules'));
+  walk(path.join(ROOT, 'src'));
+  walk(path.join(ROOT, 'scripts'));
+  const writers = [];
+  for (const f of files) {
+    const src = fs.readFileSync(f, 'utf8');
+    if (/(INSERT INTO|UPDATE|DELETE FROM)\s+government_decision_rules\b/.test(src)) writers.push(path.relative(ROOT, f).replace(/\\/g, '/'));
+  }
+  assert.deepEqual(writers, ['modules/government/db.js'], 'exactly one SQL writer');
+  const callers = files.filter((f) => /\.applyDecisionRules\(/.test(fs.readFileSync(f, 'utf8'))).map((f) => path.relative(ROOT, f).replace(/\\/g, '/'));
+  assert.deepEqual(callers, ['modules/government/decision-board.js']);
+  const boardSrc = fs.readFileSync(path.join(GOV, 'decision-board.js'), 'utf8');
+  assert.equal((boardSrc.match(/db\.applyDecisionRules\(/g) || []).length, 1, 'called once, inside applyPassedDecisionRules');
+  const routes = fs.readFileSync(path.join(GOV, 'routes', 'government.js'), 'utf8');
+  assert.ok(!/applyDecisionRules|applyPassedDecisionRules|government_decision_rules/.test(routes), 'no route writes the table');
+  // the SQL carries the same condition, and the trigger refuses every other write
+  const dbSrc = fs.readFileSync(path.join(GOV, 'db.js'), 'utf8');
+  assert.match(dbSrc, /i\.outcome = 'passed' AND a\.kind = 'decision_rules'/);
+  assert.match(MIGRATION_CODE, /CREATE OR REPLACE TRIGGER government_decision_rules_amendment_only\s+BEFORE INSERT OR UPDATE OR DELETE ON government_decision_rules/);
+  assert.match(MIGRATION_CODE, /i\.subject_type = 'constitutional_amendment'\s+AND i\.outcome = 'passed'\s+AND a\.kind = 'decision_rules'/);
+});
+
+// ── 4. more subjects ────────────────────────────────────────────────────────
+
+test('the board votes on eleven subjects now — three before, one per building besides the charter', () => {
+  const types = Object.values(dr.MATTER_SUBJECT_TYPES);
+  assert.equal(types.length, 8);
+  const check = /CHECK \(subject_type IN \(([\s\S]*?)\)\)/.exec(MIGRATION_CODE)[1];
+  const listed = [...check.matchAll(/'(\w+)'/g)].map((m) => m[1]);
+  assert.deepEqual(listed, ['full_idea', 'constitutional_amendment', 'genesis_stage', ...types]);
+  for (const t of types) assert.equal(dr.isMatterSubject(t), true);
+  assert.equal(dr.isMatterSubject('full_idea'), false);
+});
+
+const sittingRow = (area, decided_by, rule) => ({ area, decided_by, rule, who: null, set_by_item_id: '30' });
+
+test('under the default rows no matter can be opened anywhere — today unchanged', async () => {
+  const never = async () => { throw new Error('must not be reached'); };
+  await withDb({ listDecisionRules: async () => [], createMatter: never, openBoardItem: never }, async () => {
+    for (const area of dr.AREA_KEYS.filter((a) => a !== 'charter')) {
+      const out = await board.openMatter({ area, title: 'Admit Kai as a builder', proposedBy: '42' });
+      assert.equal(out.reason, 'decided_by_gate', area);
+    }
+    assert.equal((await board.openMatter({ area: 'charter', title: 'x', proposedBy: '42' })).reason, 'charter_matters_are_amendments');
+  });
+  await withDb({ listDecisionRules: async () => [sittingRow('review', 'nobody', 'vacant')], createMatter: never, openBoardItem: never }, async () => {
+    assert.equal((await board.openMatter({ area: 'review', title: 'Sign off the new sign-up', proposedBy: '42' })).reason, 'no_one_holds_this');
+  });
+});
+
+test('a matter at a building handed to a sitting sits under the ROW: its members, its rule', async () => {
+  let opened = null; let made = null;
+  await withDb({
+    listDecisionRules: async () => [sittingRow('people', 'rank:council', 'consent')],
+    getRankByKey: async (k) => ({ rank_key: k, is_system: false }),
+    createMatter: async (args) => { made = args; return { id: '8', ...args }; },
+    openBoardItem: async (args) => { opened = args; return { id: '40', subject_type: args.subjectType, subject_id: args.subjectId, constitution: args.constitution }; },
+  }, async () => {
+    const out = await board.openMatter({ area: 'people', title: 'Admit Kai as a builder', action: { type: 'assign_rank', builder_id: 77, rank_key: 'tester' }, proposedBy: '42' });
+    assert.equal(out.ok, true, JSON.stringify(out));
+  });
+  assert.deepEqual(made.action, { type: 'assign_rank', builder_id: 77, rank_key: 'tester' });
+  assert.equal(opened.subjectType, 'people_matter');
+  assert.equal(opened.constitution.membership, 'rank:council');
+  assert.equal(opened.constitution.pass_rule, 'consent');
+  assert.equal(opened.constitution.rule, 'consent');
+  assert.equal(opened.windowMinutes, null);
+});
+
+test('a matter\'s act is checked when it is opened: People only, a custom rank only', async () => {
+  await withDb({
+    listDecisionRules: async () => [sittingRow('people', 'rank:council', 'consent'), sittingRow('rules', 'rank:council', 'majority')],
+    getRankByKey: async (k) => (k === 'metic' ? { rank_key: k, is_system: true } : k === 'ghost' ? null : { rank_key: k, is_system: false }),
+    createMatter: async () => { throw new Error('must not be reached'); },
+    openBoardItem: async () => { throw new Error('must not be reached'); },
+  }, async () => {
+    const act = (a) => ({ type: 'assign_rank', builder_id: 7, rank_key: 'tester', ...a });
+    assert.equal((await board.openMatter({ area: 'rules', title: 't', action: act(), proposedBy: '42' })).reason, 'action_not_supported_here');
+    assert.equal((await board.openMatter({ area: 'people', title: 't', action: act({ rank_key: 'metic' }), proposedBy: '42' })).reason, 'seeded_rank');
+    assert.equal((await board.openMatter({ area: 'people', title: 't', action: act({ rank_key: 'ghost' }), proposedBy: '42' })).reason, 'unknown_rank');
+    assert.equal((await board.openMatter({ area: 'people', title: 't', action: act({ type: 'promote' }), proposedBy: '42' })).reason, 'bad_action');
+    assert.equal((await board.openMatter({ area: 'people', title: 't', action: act({ builder_id: -1 }), proposedBy: '42' })).reason, 'bad_action');
+    assert.equal((await board.openMatter({ area: 'people', title: '', proposedBy: '42' })).reason, 'bad_title');
+  });
+});
+
+test('sign-off holds the proposer to the author rule: their own yes never decides; another member\'s does', () => {
+  const signoff = { membership: 'rank:tester', pass_rule: 'first_ratifier', rule: 'signoff', close_early_on_full_turnout: true };
+  assert.equal(board.authorRuleApplies('review_matter', signoff), true);
+  assert.equal(board.authorRuleApplies('review_matter', { ...signoff, rule: 'first' }), false, 'first yes: the proposer may decide, like an amendment');
+  assert.equal(board.authorRuleApplies('constitutional_amendment', signoff), false, 'the amendment carve-out is untouched');
+  assert.equal(board.authorRuleApplies('full_idea', null), true);
+  const own = [{ voter_id: '42', direction: 'yes' }];
+  assert.equal(board.shouldCloseAfterVote({ constitution: signoff, votes: own, members: [], authorId: '42' }), false);
+  assert.equal(board.shouldCloseAfterVote({ constitution: signoff, votes: [...own, { voter_id: '9', direction: 'yes' }], members: [], authorId: '42' }), true);
+});
+
+test('a passed People matter acts by itself: the rank is given, nobody is paid, the decision is announced', async () => {
+  const events = [];
+  const api = require(path.join(ROOT, 'src', 'module-api.js'));
+  const origEmit = api.emitAsync;
+  api.emitAsync = async (name, payload) => { events.push([name, payload]); };
+  let assigned = null;
+  try {
+    await withDb({
+      getVotesForItem: async () => [{ voter_id: '9', direction: 'yes' }],
+      closeBoardItem: async ({ outcome, afterClose }) => { assert.equal(afterClose, null, 'a matter books nothing in the close'); return { id: '40', subject_type: 'people_matter', subject_id: '8', opened_by: '42', closed_at: 'T', outcome }; },
+      getMatter: async () => ({ id: '8', area: 'people', title: 'Admit Kai', action: { type: 'assign_rank', builder_id: 77, rank_key: 'tester' }, proposed_by: '42' }),
+      getRankByKey: async (k) => ({ rank_key: k, is_system: false }),
+      assignRank: async (args) => { assigned = args; return true; },
+      insertAuthorRatifyKarma: async () => { throw new Error('a matter pays nobody'); },
+      getBoardItemAuthor: async () => '42',
+    }, async () => {
+      const item = { id: '40', subject_type: 'people_matter', subject_id: '8', opened_by: '42', closed_at: null, constitution: { membership: 'rank:council', pass_rule: 'consent', rule: 'consent' } };
+      const out = await board.closeItem(item);
+      assert.equal(out.outcome, 'passed');
+      assert.equal(out.author_karma, null);
+      assert.equal(out.acted.done, true);
+    });
+  } finally { api.emitAsync = origEmit; }
+  assert.deepEqual(assigned, { builderId: 77, rankKey: 'tester', assignedBy: '42' });
+  const passed = events.find(([n]) => n === 'board.matter.passed');
+  assert.ok(passed, 'board.matter.passed emitted');
+  assert.equal(passed[1].area, 'people');
+  assert.equal(passed[1].acted, true);
+});
+
+// ── 5. the gate replaced where the building allows it ───────────────────────
+
+test('checkActAlone: People as today lets the gate act; handed to a sitting it refuses one builder acting alone', async () => {
+  await withDb({ listDecisionRules: async () => [] }, async () => {
+    assert.equal((await board.checkActAlone('people', '42')).ok, true);
+  });
+  await withDb({ listDecisionRules: async () => [sittingRow('people', 'rank:council', 'consent')], builderHoldsRankActive: async () => true }, async () => {
+    const out = await board.checkActAlone('people', '42');
+    assert.equal(out.ok, false);
+    assert.equal(out.reason, 'decided_by_sitting');
+    assert.equal(out.open_with, 'POST /government/board/matters');
+  });
+  await withDb({ listDecisionRules: async () => [sittingRow('people', 'rank:council', 'decide')], builderHoldsRankActive: async (_id, keys) => keys.includes('council') }, async () => {
+    assert.equal((await board.checkActAlone('people', '42')).ok, true, 'a seated member may decide alone');
+  });
+  await withDb({ listDecisionRules: async () => [sittingRow('people', 'rank:council', 'decide')], builderHoldsRankActive: async () => false }, async () => {
+    assert.equal((await board.checkActAlone('people', '42')).ok, false, 'not seated: not theirs to decide');
+  });
+});
+
+// ── 6. the feed reads the table ─────────────────────────────────────────────
+
+test('the docket: every building carries who decides it, and a building\'s sitting carries the table\'s rule', async () => {
+  const decisions = dr.resolveAll([sittingRow('review', 'rank:tester', 'signoff')], { board: MONARCHY });
+  const origView = board.boardRoomView;
+  const origMembers = db.getActiveBuildersWithRank;
+  const origCount = db.countActiveBuilders;
+  board.boardRoomView = async () => ({
+    open: [{
+      id: '40', subject_type: 'review_matter', subject_id: '8', opened_at: '2026-10-01T00:00:00Z', closes_at: null, expired: false,
+      closed_at: null, outcome: null, votes: [],
+      subject: { area: 'review', title: 'Sign off the new sign-up', author_id: '42' },
+      constitution: { membership: 'rank:tester', pass_rule: 'first_ratifier', rule: 'signoff', area: 'review' },
+    }],
+    closed: [],
+  });
+  db.getActiveBuildersWithRank = async () => [{ builder_id: 7, github_login: 'lu', display_name: 'Lu' }];
+  db.countActiveBuilders = async () => 3;
+  try {
+    const d = await docket.buildDocket({ viewer: { id: 7 }, permissions: ['board.vote.cast'], contributions: { sources: new Map(), readings: new Map() }, decisions });
+    const m = d.matters.find((x) => x.id === 'board:40');
+    assert.equal(m.building, 'review');
+    assert.equal(m.rule, 'signoff', 'the table\'s rule, not the pass rule underneath it');
+    assert.equal(m.state, 'needs', 'a tester who did not build it is needed');
+    assert.equal(m.where, 'review · matter');
+    const review = d.buildings.find((b) => b.key === 'review');
+    assert.equal(review.decision.rule, 'signoff');
+    assert.equal(review.decision.as_today, false);
+    const people = d.buildings.find((b) => b.key === 'people');
+    assert.deepEqual({ rule: people.decision.rule, as_today: people.decision.as_today }, { rule: 'decide', as_today: true });
+    assert.deepEqual(d.vocabulary.decision_rules.map((r) => r.key), dr.DECISION_RULE_KEYS);
+    const unread = await docket.buildDocket({ viewer: { id: 7 }, permissions: ['board.vote.cast'], contributions: { sources: new Map(), readings: new Map() }, decisions: null });
+    assert.ok(unread.buildings.every((b) => b.decision === null), 'an unread table is null, never a guess');
+  } finally {
+    board.boardRoomView = origView;
+    db.getActiveBuildersWithRank = origMembers;
+    db.countActiveBuilders = origCount;
+  }
+});
+
+test('the constitution view carries the table, and a rules amendment is never read as a board-block divergence', async () => {
+  await withDb({
+    listAmendmentHistory: async () => [{
+      item_id: '21', amendment_id: '5', kind: 'decision_rules', outcome: 'passed', closed_at: 'T',
+      proposed: { decision_rules: [{ area: 'people', decided_by: 'rank:council', rule: 'consent', who: null }] },
+    }],
+    countActiveBuilders: async () => 1,
+    listDecisionRules: async () => [sittingRow('people', 'rank:council', 'consent')],
+  }, async () => {
+    const v = await board.constitutionView({});
+    assert.equal(v.divergence, null, 'a passed rules amendment says nothing about the board block');
+    const people = v.decision_rules.areas.find((a) => a.area === 'people');
+    assert.equal(people.rule, 'consent');
+    assert.equal(people.set_by_item_id, '30');
+    assert.equal(v.history[0].kind, 'decision_rules');
+  });
+});
+
+// ── the routes, 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');
+
+test('the two new routes are pinned to the amendment atom', () => {
+  const pins = rrc.MODULE_EXPECTED_RANKS.government;
+  assert.equal(pins['POST /government/board/decision-rules'], 'perm:board.item.open');
+  assert.equal(pins['POST /government/board/matters'], 'perm:board.item.open');
+});
+
+const realRequireBuilder = api.requireBuilder;
+api.requireBuilder = (req, res, next) => { req.builder = { id: 42, rank: 'archon' }; next(); };
+seams._reset();
+let held = ['government.manage', 'board.item.open', '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('People\'s rank assignments: as today they go through; once People is a sitting one builder is refused', async () => {
+  let assigned = 0;
+  const base = { getRankByKey: async (k) => ({ rank_key: k, is_system: false, seeded_rank: null }), assignRank: async () => { assigned += 1; return true; }, unassignRank: async () => { assigned += 1; return true; } };
+  await withDb({ ...base, listDecisionRules: async () => [] }, async () => {
+    const r = await call('POST', '/government/assignments', { builder_id: 7, rank_key: 'tester' });
+    assert.equal(r.status, 201);
+  });
+  await withDb({ ...base, listDecisionRules: async () => [sittingRow('people', 'rank:council', 'consent')], builderHoldsRankActive: async () => true }, async () => {
+    const r = await call('POST', '/government/assignments', { builder_id: 7, rank_key: 'tester' });
+    assert.equal(r.status, 409);
+    assert.equal(r.json.error.code, 'decided_by_sitting');
+    const d = await call('DELETE', '/government/assignments/7/tester');
+    assert.equal(d.status, 409);
+  });
+  assert.equal(assigned, 1, 'only the as-today assignment was written');
+  await withDb({ ...base, listDecisionRules: async () => { throw new Error('db down'); } }, async () => {
+    const r = await call('POST', '/government/assignments', { builder_id: 7, rank_key: 'tester' });
+    assert.equal(r.status, 503, 'an unreadable row refuses — fail-closed');
+  });
+  assert.equal(assigned, 1);
+});
+
+test('POST /government/board/decision-rules files the amendment; a bad row is a named 400; a no-op is 409', async () => {
+  await withDb({
+    getRankByKey: async (k) => ({ rank_key: k, is_system: false }),
+    listDecisionRules: async () => [],
+    createAmendment: async (a) => ({ id: '5', ...a }),
+    openBoardItem: async (a) => ({ id: '21', subject_type: a.subjectType, subject_id: a.subjectId, constitution: a.constitution }),
+  }, async () => {
+    const ok = await call('POST', '/government/board/decision-rules', { rules: [{ area: 'review', decided_by: 'rank:tester', rule: 'signoff', who: 'testers' }] });
+    assert.equal(ok.status, 201, JSON.stringify(ok.json));
+    assert.equal(ok.json.rules[0].rule, 'signoff');
+    const bad = await call('POST', '/government/board/decision-rules', { rules: [{ area: 'charter', decided_by: 'rank:council', rule: 'unanimous' }] });
+    assert.equal(bad.status, 400);
+    assert.equal(bad.json.error.code, 'invalid_decision_rules');
+    const noop = await call('POST', '/government/board/decision-rules', { rules: [{ area: 'review', decided_by: 'gate' }] });
+    assert.equal(noop.status, 409);
+  });
+});
+
+test('POST /government/board/matters: 409 where the building is as today, 201 where a sitting decides it', async () => {
+  await withDb({ listDecisionRules: async () => [] }, async () => {
+    const r = await call('POST', '/government/board/matters', { area: 'rules', title: 'Small fixes ship without a vote' });
+    assert.equal(r.status, 409);
+    assert.equal(r.json.error.code, 'decided_by_gate');
+  });
+  await withDb({
+    listDecisionRules: async () => [sittingRow('rules', 'rank:council', 'majority')],
+    createMatter: async (a) => ({ id: '8', ...a }),
+    openBoardItem: async (a) => ({ id: '41', subject_type: a.subjectType, subject_id: a.subjectId, constitution: a.constitution }),
+  }, async () => {
+    const r = await call('POST', '/government/board/matters', { area: 'rules', title: 'Small fixes ship without a vote' });
+    assert.equal(r.status, 201, JSON.stringify(r.json));
+    assert.equal(r.json.item.subject_type, 'rules_matter');
+    assert.equal(r.json.decided.rule, 'majority');
+  });
+});
+
+test('without board.item.open both new routes 403', async () => {
+  held = ['board.vote.cast'];
+  try {
+    assert.equal((await call('POST', '/government/board/decision-rules', { rules: [] })).status, 403);
+    assert.equal((await call('POST', '/government/board/matters', { area: 'rules', title: 'x' })).status, 403);
+  } finally { held = ['government.manage', 'board.item.open', 'board.vote.cast']; }
+});