@bongos/core 1.21.112 → 1.21.114

package/tests/government_laws.mjs

@@ -0,0 +1,488 @@
+// tests/government_laws.mjs — STANDING ORDERS: the project's laws for its AI
+// agents (task 1004706, goal 1000111 "government is how a project steers its AI").
+//
+// What this pins (the task's three done-when lines, and the walls behind them):
+//   1. LAWS CAN BE PROPOSED, VOTED AND LISTED. A proposal (enact, repeal, or
+//      both) is validated strictly and filed as an amendment of kind 'laws',
+//      sat under the constitution IN FORCE; the board's ordinary vote decides
+//      it; GET /government/laws lists the book.
+//   2. EACH LAW RECORDS WHO PASSED IT AND WHEN. A row names the sitting that
+//      passed it, its proposer and passed_at (the database clock, set by the
+//      trigger); the book reads the government it was decided under and who
+//      said yes. A repeal records its sitting and when.
+//   3. NO ROUTE WRITES A LAW EXCEPT A PASSED AMENDMENT. One SQL writer (db.js),
+//      called from one place (law-board.js), only inside the transaction that
+//      closes a passed laws amendment, under a guard; the SQL carries the same
+//      condition; government_027's trigger refuses every other INSERT/UPDATE and
+//      every DELETE; no route names the write; the amendment routes cannot file
+//      a laws amendment by another door; and every government route that is not
+//      the propose route, driven for real, writes nothing.
+//
+// No law is seeded: the first laws are the owner's to ratify (task 1004708).
+// DB-free: db reads/writes are monkeypatched by property.
+//
+// Run:  node --test tests/government_laws.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 laws = require(path.join(GOV, 'laws.js'));
+const lawBoard = require(path.join(GOV, 'law-board.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 MIGRATION = fs.readFileSync(path.join(GOV, 'migrations', 'government_027_laws.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 });
+const ASK = { text: 'Ask like a human', effect_on_ai: 'Every question to a person is one short card with tap answers.', locks: [{ setting: 'ask_format', value: 'card' }] };
+
+// ── 1. what a law is: validated strictly ────────────────────────────────────
+
+test('a law is one short line, an optional effect line, and at most eight locks — validated strictly, nothing corrected', () => {
+  const ok = laws.validateLawsProposal({ enact: [ASK, { text: '  Land only.  Ask before going live ', locks: [{ setting: 'wandering', max: 'focused' }, { setting: 'parallel_agents', max: 3 }] }] });
+  assert.equal(ok.ok, true, JSON.stringify(ok));
+  assert.deepEqual(ok.proposal.enact[0], { text: 'Ask like a human', effect_on_ai: ASK.effect_on_ai, locks: [{ setting: 'ask_format', value: 'card' }] });
+  assert.equal(ok.proposal.enact[1].text, 'Land only. Ask before going live', 'whitespace trimmed, nothing else');
+  assert.equal(ok.proposal.enact[1].effect_on_ai, null);
+  assert.deepEqual(ok.proposal.repeal, []);
+
+  const refused = [
+    [{}, 'nothing_to_change'],
+    [{ enact: [], repeal: [] }, 'nothing_to_change'],
+    [null, 'bad_proposal'],
+    [{ enact: [ASK], extra: 1 }, 'unknown_field'],
+    [{ enact: [{ text: 'no' }] }, 'bad_text'],
+    [{ enact: [{ text: 'x'.repeat(laws.LAW_TEXT_MAX + 1) }] }, 'bad_text'],
+    [{ enact: [{ text: 'Two\nlines' }] }, 'bad_text'],
+    [{ enact: [{ text: 42 }] }, 'bad_text'],
+    [{ enact: [{ text: 'Fine words', effect_on_ai: 'two\nlines' }] }, 'bad_effect'],
+    [{ enact: [{ text: 'Fine words', author: 'me' }] }, 'unknown_field'],
+    [{ enact: [{ text: 'Fine words', locks: 'ask_format' }] }, 'bad_locks'],
+    [{ enact: [{ text: 'Fine words', locks: Array.from({ length: laws.MAX_LOCKS + 1 }, (_, i) => ({ setting: `s${i}`, value: 1 })) }] }, 'bad_locks'],
+    [{ enact: [{ text: 'Fine words', locks: [{ setting: 'Bad Key', value: 1 }] }] }, 'bad_lock_setting'],
+    [{ enact: [{ text: 'Fine words', locks: [{ setting: 'ask_format' }] }] }, 'lock_needs_value_or_max'],
+    [{ enact: [{ text: 'Fine words', locks: [{ setting: 'ask_format', value: 'card', max: 'card' }] }] }, 'lock_needs_value_or_max'],
+    [{ enact: [{ text: 'Fine words', locks: [{ setting: 'ask_format', value: {} }] }] }, 'bad_lock_value'],
+    [{ enact: [{ text: 'Fine words', locks: [{ setting: 'ask_format', max: true }] }] }, 'bad_lock_max'],
+    [{ enact: [{ text: 'Fine words', locks: [{ setting: 'ask_format', value: 'card', why: 'x' }] }] }, 'unknown_field'],
+    [{ enact: [{ text: 'Fine words', locks: [{ setting: 'ask_format', value: 'card' }, { setting: 'ask_format', value: 'free_text' }] }] }, 'setting_locked_twice'],
+    [{ enact: [ASK, { text: 'ask like a HUMAN' }] }, 'duplicate_law'],
+    [{ enact: Array.from({ length: 11 }, (_, i) => ({ text: `Law number ${i}` })) }, 'bad_enact'],
+    [{ repeal: [0] }, 'bad_law_id'],
+    [{ repeal: ['x'] }, 'bad_law_id'],
+    [{ repeal: [3, '3'] }, 'duplicate_law_id'],
+  ];
+  for (const [input, reason] of refused) {
+    const v = laws.validateLawsProposal(input);
+    assert.equal(v.ok, false, `${JSON.stringify(input)} must be refused`);
+    assert.equal(v.reason, reason, `${JSON.stringify(input)}: ${JSON.stringify(v)}`);
+  }
+});
+
+test('against the laws in force: a repeal names one in force, no law twice, no setting locked by two laws', () => {
+  const inForce = [{ id: '3', text: 'Ask like a human', locks: [{ setting: 'ask_format', value: 'card' }] }, { id: '4', text: 'No spend limit', locks: [] }];
+  const p = (x) => laws.validateLawsProposal(x).proposal;
+  assert.deepEqual(laws.checkAgainstInForce(p({ repeal: ['9'] }), inForce), { ok: false, reason: 'not_in_force', law_id: '9' });
+  assert.equal(laws.checkAgainstInForce(p({ enact: [{ text: 'ask like a human' }] }), inForce).reason, 'already_in_force');
+  const locked = laws.checkAgainstInForce(p({ enact: [{ text: 'Free text is fine', locks: [{ setting: 'ask_format', value: 'free_text' }] }] }), inForce);
+  assert.equal(locked.reason, 'setting_already_locked');
+  assert.equal(locked.law_id, '3');
+  assert.equal(laws.checkAgainstInForce(p({ enact: [{ text: 'A', locks: [] }, { text: 'Cards only', locks: [{ setting: 'render', value: 'minimal' }] }, { text: 'Rich cards', locks: [{ setting: 'render', value: 'rich' }] }].slice(1) }), inForce).reason, 'setting_already_locked', 'two new laws cannot lock one setting');
+  // repeal-and-replace in one amendment is the way to change a law
+  assert.deepEqual(laws.checkAgainstInForce(p({ repeal: ['3'], enact: [{ text: 'Ask like a human', locks: [{ setting: 'ask_format', value: 'free_text' }] }] }), inForce), { ok: true });
+});
+
+// ── 1. proposed: an amendment of kind 'laws', under the board in force ──────
+
+test('proposing files a laws amendment, sat under the constitution IN FORCE, in the record\'s own words', async () => {
+  let created = null; let opened = null;
+  await withDb({
+    listLaws: async () => [],
+    createAmendment: async (args) => { created = args; return { id: '7', ...args }; },
+    openBoardItem: async (args) => { opened = args; return { id: '31', subject_type: args.subjectType, subject_id: args.subjectId, constitution: args.constitution }; },
+  }, async () => {
+    const out = await board.proposeLaws({ enact: [ASK], proposedBy: '42' });
+    assert.equal(out.ok, true, JSON.stringify(out));
+  });
+  assert.equal(created.kind, 'laws');
+  assert.deepEqual(created.proposed, { laws: { enact: [{ text: ASK.text, effect_on_ai: ASK.effect_on_ai, locks: ASK.locks }], repeal: [] } });
+  assert.equal(created.rationaleMd, 'Law: Ask like a human.');
+  assert.equal(String(created.proposedBy), '42');
+  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 a malformed law, a repeat, an absent law and a missing proposer — before any write', async () => {
+  const never = async () => { throw new Error('must not be reached'); };
+  await withDb({
+    listLaws: async () => [{ id: '3', text: 'Ask like a human', locks: [] }],
+    createAmendment: never,
+    openBoardItem: never,
+  }, async () => {
+    assert.equal((await board.proposeLaws({ enact: [{ text: 'Ask like a human' }], proposedBy: '42' })).reason, 'already_in_force');
+    assert.equal((await board.proposeLaws({ repeal: ['8'], proposedBy: '42' })).reason, 'not_in_force');
+    assert.equal((await board.proposeLaws({ enact: [{ text: 'Two\nlines' }], proposedBy: '42' })).reason, 'bad_text');
+    assert.equal((await board.proposeLaws({ enact: [{ text: 'Fine words' }], proposedBy: null })).reason, 'missing_proposer');
+    assert.equal((await board.proposeLaws({ proposedBy: '42' })).reason, 'nothing_to_change');
+  });
+});
+
+// ── 1+2. voted: a passed sitting writes the laws, inside its close ───────────
+
+const lawsAmendment = { id: '7', kind: 'laws', proposed_by: '42', proposed: { laws: { enact: [{ text: ASK.text, effect_on_ai: ASK.effect_on_ai, locks: ASK.locks }], repeal: ['3'] } } };
+const amendmentItem = (over = {}) => ({ id: '31', subject_type: 'constitutional_amendment', subject_id: '7', 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 laws amendment writes its laws inside the closing transaction, naming the sitting and the proposer — and never touches the board block', async () => {
+  const log = [];
+  let written = null;
+  const origApply = config.applyBoardAmendment;
+  // closeItem catches an apply failure and only logs it, so a throwing stub would
+  // pass silently: count the calls instead.
+  let boardWrites = 0;
+  config.applyBoardAmendment = () => { boardWrites += 1; return {}; };
+  try {
+    await withDb({
+      getVotesForItem: async () => [{ voter_id: '42', direction: 'yes' }],
+      getAmendment: async (id) => { assert.equal(String(id), '7'); return lawsAmendment; },
+      applyLaws: async (client, args) => {
+        assert.equal(client.tx, true, 'the closing transaction\'s client');
+        written = args;
+        return { enacted: [{ id: 11, text: ASK.text }], repealed: [{ id: 3 }] };
+      },
+      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_laws, { enacted: [{ id: '11', text: ASK.text }], repealed: ['3'] });
+      assert.equal(out.applied_constitution, undefined);
+      assert.equal(out.applied_decision_rules, undefined);
+    });
+  } finally { config.applyBoardAmendment = origApply; }
+  assert.equal(boardWrites, 0, 'the board block was not rewritten');
+  assert.deepEqual(log, ['committed']);
+  assert.equal(String(written.itemId), '31', 'who passed it: the sitting');
+  assert.equal(String(written.proposedBy), '42', 'who proposed it');
+  assert.deepEqual(written.enact.map((l) => l.text), [ASK.text]);
+  assert.deepEqual(written.repeal, ['3']);
+});
+
+test('a RETURNED laws 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'); },
+    applyLaws: 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_laws, undefined);
+  });
+});
+
+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 () => lawsAmendment,
+    applyLaws: async () => { throw new Error('trigger refused'); },
+    closeBoardItem: txClose(log),
+  }, async () => {
+    await assert.rejects(() => board.closeItem(amendmentItem()), /trigger refused/);
+  });
+  assert.deepEqual(log, ['rolled_back']);
+});
+
+test('THE GUARD: only a passed laws amendment, naming its own amendment, may write a law', async () => {
+  const passed = { id: '31', subject_type: 'constitutional_amendment', subject_id: '7', outcome: 'passed' };
+  assert.equal(laws.lawsWriteAllowed(passed, lawsAmendment), true);
+  const refused = [
+    [{ ...passed, outcome: 'returned' }, lawsAmendment, 'a returned sitting'],
+    [{ ...passed, outcome: 'withdrawn' }, lawsAmendment, 'a withdrawn sitting'],
+    [{ ...passed, outcome: null }, lawsAmendment, 'an open sitting'],
+    [{ ...passed, subject_type: 'rules_matter' }, lawsAmendment, 'a matter, not an amendment'],
+    [{ ...passed, subject_type: 'full_idea' }, lawsAmendment, 'an idea'],
+    [passed, { ...lawsAmendment, kind: 'constitution' }, 'a board-block amendment'],
+    [passed, { ...lawsAmendment, kind: 'decision_rules' }, 'a who-decides amendment'],
+    [passed, { ...lawsAmendment, kind: undefined }, 'an amendment of no kind'],
+    [{ ...passed, subject_id: '8' }, lawsAmendment, 'another amendment\'s item'],
+    [null, lawsAmendment, 'no item'],
+    [passed, null, 'no amendment'],
+  ];
+  await withDb({ applyLaws: async () => { throw new Error('the write must never be reached'); } }, async () => {
+    for (const [row, am, why] of refused) {
+      assert.equal(laws.lawsWriteAllowed(row, am), false, why);
+      await assert.rejects(() => lawBoard.applyPassedLaws({ tx: true }, row, am), /only be written by a passed laws amendment/, why);
+    }
+  });
+  // and a passed amendment whose stored row was altered is not applied
+  await withDb({ applyLaws: async () => { throw new Error('the write must never be reached'); } }, async () => {
+    await assert.rejects(() => lawBoard.applyPassedLaws({ tx: true }, passed, { ...lawsAmendment, proposed: { laws: { enact: [{ text: 'x' }] } } }), /no longer validates/);
+  });
+});
+
+// ── 3. no route writes a law except a passed amendment ──────────────────────
+
+function sourceFiles() {
+  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);
+    }
+  };
+  for (const d of ['modules', 'src', 'scripts']) walk(path.join(ROOT, d));
+  return files;
+}
+const rel = (f) => path.relative(ROOT, f).replace(/\\/g, '/');
+
+test('nothing else writes a law: one SQL writer, one caller, no route, and the database refuses the rest', () => {
+  const files = sourceFiles();
+  const writers = files.filter((f) => /(INSERT INTO|UPDATE|DELETE FROM)\s+government_laws\b/.test(fs.readFileSync(f, 'utf8'))).map(rel);
+  assert.deepEqual(writers, ['modules/government/db.js'], 'exactly one SQL writer');
+  const callers = files.filter((f) => /\.applyLaws\(/.test(fs.readFileSync(f, 'utf8'))).map(rel);
+  assert.deepEqual(callers, ['modules/government/law-board.js']);
+  const lawBoardSrc = fs.readFileSync(path.join(GOV, 'law-board.js'), 'utf8');
+  assert.equal((lawBoardSrc.match(/db\.applyLaws\(/g) || []).length, 1, 'called once, inside applyPassedLaws');
+  // applyPassedLaws is reached only from the close's in-transaction hook
+  const boardSrc = fs.readFileSync(path.join(GOV, 'board.js'), 'utf8');
+  assert.equal((boardSrc.match(/lawBoard\.applyPassedLaws\(client, closedRow, amendment\)/g) || []).length, 1, 'one call, inside afterClose');
+  const applyCallers = files.filter((f) => /applyPassedLaws\(/.test(fs.readFileSync(f, 'utf8'))).map(rel).sort();
+  assert.deepEqual(applyCallers, ['modules/government/board.js', 'modules/government/law-board.js']);
+  // a laws amendment is filed in exactly one place
+  const kindLaws = files.filter((f) => /kind:\s*'laws'/.test(fs.readFileSync(f, 'utf8'))).map(rel);
+  assert.deepEqual(kindLaws, ['modules/government/law-board.js'], 'only proposeLaws files a laws amendment');
+  // no route file names the write
+  const routeFiles = files.filter((f) => /[\\/]routes[\\/]/.test(f));
+  for (const f of routeFiles) {
+    assert.ok(!/applyLaws|applyPassedLaws|government_laws/.test(fs.readFileSync(f, 'utf8')), `${rel(f)} must not write a law`);
+  }
+  // the SQL carries the same condition, for both the enact and the repeal
+  const dbSrc = fs.readFileSync(path.join(GOV, 'db.js'), 'utf8');
+  assert.equal((dbSrc.match(/i\.outcome = 'passed' AND a\.kind = 'laws'/g) || []).length, 2, 'enact and repeal both carry the condition');
+  // the trigger refuses every other write, and a delete outright
+  assert.match(MIGRATION_CODE, /CREATE OR REPLACE TRIGGER government_laws_amendment_only\s+BEFORE INSERT OR UPDATE OR DELETE ON government_laws/);
+  assert.match(MIGRATION_CODE, /i\.subject_type = 'constitutional_amendment'\s+AND i\.outcome = 'passed'\s+AND a\.kind = 'laws'/);
+  assert.match(MIGRATION_CODE, /IF TG_OP = 'DELETE' THEN\s+RAISE EXCEPTION/);
+  assert.match(MIGRATION_CODE, /IF NOT government_laws_passed_laws_item\(NEW\.passed_by_item_id\) THEN\s+RAISE EXCEPTION/, 'an insert names a passed laws sitting');
+  assert.match(MIGRATION_CODE, /IF NOT government_laws_passed_laws_item\(NEW\.repealed_by_item_id\) THEN\s+RAISE EXCEPTION/, 'a repeal names a passed laws sitting');
+  assert.match(MIGRATION_CODE, /IF OLD\.repealed_at IS NOT NULL THEN\s+RAISE EXCEPTION/, 'a repealed law never changes again');
+  assert.match(MIGRATION_CODE, /NEW\.text IS DISTINCT FROM OLD\.text/, 'a law in force cannot be edited');
+  assert.match(MIGRATION_CODE, /NEW\.passed_at := now\(\)/, 'when it passed is the database clock, not the writer\'s word');
+  assert.match(MIGRATION_CODE, /CHECK \(kind IN \('constitution', 'decision_rules', 'laws'\)\)/);
+});
+
+test('the migration seeds no law — the first laws are the owner\'s to ratify', () => {
+  assert.doesNotMatch(MIGRATION_CODE, /INSERT INTO government_laws/);
+});
+
+// ── 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 laws routes are pinned: proposing on the amendment atom, reading where the room reads', () => {
+  const pins = rrc.MODULE_EXPECTED_RANKS.government;
+  assert.equal(pins['POST /government/board/laws'], 'perm:board.item.open');
+  assert.equal(pins['GET /government/laws'], 'perm:board.vote.cast');
+});
+
+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('POST /government/board/laws files the amendment; a bad law is a named 400; a repeat is 409', async () => {
+  await withDb({
+    listLaws: async () => [{ id: '3', text: 'No spend limit', locks: [] }],
+    createAmendment: async (a) => ({ id: '7', ...a }),
+    openBoardItem: async (a) => ({ id: '31', subject_type: a.subjectType, subject_id: a.subjectId, constitution: a.constitution }),
+  }, async () => {
+    const ok = await call('POST', '/government/board/laws', { enact: [ASK] });
+    assert.equal(ok.status, 201, JSON.stringify(ok.json));
+    assert.equal(ok.json.item.subject_type, 'constitutional_amendment');
+    assert.equal(ok.json.amendment.kind, 'laws');
+    assert.equal(ok.json.proposal.enact[0].text, ASK.text);
+    const bad = await call('POST', '/government/board/laws', { enact: [{ text: 'Two\nlines' }] });
+    assert.equal(bad.status, 400);
+    assert.equal(bad.json.error.code, 'invalid_laws');
+    const again = await call('POST', '/government/board/laws', { enact: [{ text: 'No spend limit' }] });
+    assert.equal(again.status, 409);
+    assert.equal(again.json.error.code, 'already_in_force');
+    const gone = await call('POST', '/government/board/laws', { repeal: [99] });
+    assert.equal(gone.status, 409);
+    assert.equal(gone.json.error.code, 'not_in_force');
+  });
+});
+
+test('a laws amendment cannot come in by another door: the constitution and who-decides routes refuse its shape', async () => {
+  const never = async () => { throw new Error('must not be reached'); };
+  await withDb({ createAmendment: never, openBoardItem: never, applyLaws: never, listDecisionRules: async () => [], getRankByKey: async () => null }, async () => {
+    const asConstitution = await call('POST', '/government/board/items', { subject_type: 'constitutional_amendment', proposal: { laws: { enact: [ASK] } } });
+    assert.ok(asConstitution.status >= 400 && asConstitution.status < 500, `constitution door: ${asConstitution.status}`);
+    const asRules = await call('POST', '/government/board/decision-rules', { rules: [{ laws: { enact: [ASK] } }] });
+    assert.ok(asRules.status >= 400 && asRules.status < 500, `who-decides door: ${asRules.status}`);
+  });
+});
+
+test('GET /government/laws lists the book: each law with who passed it (the government, proposer, who said yes) and when', async () => {
+  let asked = null;
+  await withDb({
+    listLaws: async (opts) => {
+      asked = opts;
+      return [{
+        id: '11', text: ASK.text, effect_on_ai: ASK.effect_on_ai, locks: ASK.locks, proposed_by: '42', passed_by_item_id: '31',
+        passed_at: '2026-10-09T12:00:00.000Z', repealed_by_item_id: null, repealed_at: null,
+        decided_under: { membership: 'rank:metic+', pass_rule: 'consent', window_minutes: null, close_early_on_full_turnout: true },
+        proposer_login: 'ada', proposer_name: 'Ada',
+      }];
+    },
+    listYesVoters: async (ids) => { assert.deepEqual(ids, ['31']); return [{ item_id: '31', voter_id: '43', github_login: 'ben', display_name: 'Ben' }, { item_id: '31', voter_id: '44', github_login: 'cy', display_name: null }]; },
+  }, async () => {
+    const r = await call('GET', '/government/laws');
+    assert.equal(r.status, 200, JSON.stringify(r.json));
+    assert.deepEqual(asked, { includeRepealed: false });
+    assert.equal(r.json.in_force, 1);
+    const law = r.json.laws[0];
+    assert.equal(law.text, ASK.text);
+    assert.deepEqual(law.locks, ASK.locks);
+    assert.equal(law.in_force, true);
+    assert.equal(law.passed_at, '2026-10-09T12:00:00.000Z', 'when');
+    assert.equal(law.passed_by.item_id, '31', 'which sitting');
+    assert.equal(law.passed_by.government, 'Timocratic Republic', 'the government it was decided under, by name');
+    assert.deepEqual(law.passed_by.proposer, { id: '42', login: 'ada', name: 'Ada' });
+    assert.deepEqual(law.passed_by.yes.map((p) => p.name), ['Ben', 'cy'], 'who said yes');
+    assert.match(r.json.changed_by, /passed amendment only/);
+    const all = await call('GET', '/government/laws?include=repealed');
+    assert.equal(all.status, 200);
+    assert.deepEqual(asked, { includeRepealed: true });
+  });
+});
+
+test('a repealed law stays on the record with when and by which sitting', async () => {
+  await withDb({
+    listLaws: async () => [{ id: '3', text: 'No spend limit', effect_on_ai: null, locks: [], proposed_by: null, passed_by_item_id: '20', passed_at: 'T1', repealed_by_item_id: '33', repealed_at: 'T2', decided_under: MONARCHY }],
+    listYesVoters: async () => [],
+  }, async () => {
+    const v = await board.lawsView({ includeRepealed: true });
+    assert.equal(v.in_force, 0);
+    assert.equal(v.laws[0].in_force, false);
+    assert.equal(v.laws[0].repealed_at, 'T2');
+    assert.equal(v.laws[0].repealed_by_item_id, '33');
+    assert.equal(v.laws[0].passed_by.government, 'Monarchy / BDFL');
+    assert.equal(v.laws[0].passed_by.proposer, null, 'a departed proposer reads as nobody, never a guess');
+  });
+});
+
+test('a laws amendment is never read as a board-block divergence', async () => {
+  await withDb({
+    listAmendmentHistory: async () => [{ item_id: '31', amendment_id: '7', kind: 'laws', outcome: 'passed', closed_at: 'T', proposed: lawsAmendment.proposed }],
+    countActiveBuilders: async () => 1,
+    listDecisionRules: async () => [],
+  }, async () => {
+    const v = await board.constitutionView({});
+    assert.equal(v.divergence, null, 'a passed laws amendment says nothing about the board block');
+    assert.equal(v.history[0].kind, 'laws');
+  });
+});
+
+test('without the atoms the laws routes 403', async () => {
+  held = ['board.vote.cast'];
+  try {
+    assert.equal((await call('POST', '/government/board/laws', { enact: [ASK] })).status, 403, 'proposing needs board.item.open');
+  } finally { held = ['government.manage', 'board.item.open', 'board.vote.cast']; }
+  held = [];
+  try {
+    assert.equal((await call('GET', '/government/laws')).status, 403, 'reading needs board.vote.cast');
+  } finally { held = ['government.manage', 'board.item.open', 'board.vote.cast']; }
+});
+
+test('every government route, driven for real, writes no law — only POST /government/board/laws files one, and it is a proposal', async () => {
+  const router = buildGovernmentRouter();
+  const routes = [];
+  for (const layer of router.stack) {
+    if (!layer.route) continue;
+    for (const m of Object.keys(layer.route.methods)) routes.push([m.toUpperCase(), layer.route.path]);
+  }
+  assert.ok(routes.length >= 20, `${routes.length} routes found`);
+  const writes = [];
+  const filed = [];
+  const stubs = {};
+  for (const k of Object.keys(db)) {
+    if (typeof db[k] !== 'function') continue;
+    stubs[k] = async () => [];
+  }
+  stubs.applyLaws = async () => { writes.push('applyLaws'); return { enacted: [], repealed: [] }; };
+  stubs.createAmendment = async (a) => { filed.push(a.kind || 'constitution'); return { id: '7', ...a }; };
+  stubs.openBoardItem = async (a) => ({ id: '31', subject_type: a.subjectType, subject_id: a.subjectId, constitution: a.constitution });
+  const origApply = config.applyBoardAmendment;
+  config.applyBoardAmendment = () => ({}); // never the real file
+  const hits = {};
+  try {
+    await withDb(stubs, async () => {
+      for (const [method, p] of routes) {
+        const url = p.replace(/:[A-Za-z]+/g, '1');
+        const before = filed.length;
+        // every body a laws amendment could hide in: the laws shape itself, and each other door's shape carrying it
+        const bodies = method === 'GET' ? [undefined] : [{ enact: [ASK] }, { subject_type: 'constitutional_amendment', proposal: { laws: { enact: [ASK] } } }, { rules: [{ laws: { enact: [ASK] } }] }, { area: 'rules', title: 'Ask like a human', action: { laws: { enact: [ASK] } } }, { direction: 'yes' }];
+        for (const body of bodies) await call(method, url, body);
+        if (filed.length > before) hits[`${method} ${p}`] = filed.slice(before);
+      }
+    });
+  } finally { config.applyBoardAmendment = origApply; }
+  assert.deepEqual(writes, [], 'no route reached the write');
+  const lawsFilers = Object.entries(hits).filter(([, kinds]) => kinds.includes('laws')).map(([k]) => k);
+  assert.deepEqual(lawsFilers, ['POST /government/board/laws'], 'only the propose route files a laws amendment');
+});