@bongos/core 1.21.113 → 1.21.114

package/tests/government_presets.mjs

@@ -0,0 +1,215 @@
+// tests/government_presets.mjs — STRICTNESS PRESETS: Open workshop, Guild,
+// Factory (task 1004715, goal 1000111 "government is how a project steers its AI").
+//
+// What this pins (the task's done-when lines, and the walls behind them):
+//   1. EACH PRESET APPLIES ITS LAWS. A switch to a preset is ONE laws proposal
+//      that, once passed, leaves exactly that preset's laws in force (and the
+//      project's own laws untouched); every move between presets is a proposal
+//      laws.js accepts against the book it would be filed on; every lock a
+//      preset carries is ENFORCED on a real personal setting (law-locks.js).
+//   2. FACTORY IS STRICT: caps on every model slot, off-task fixed at never, the
+//      ask format and no unattended runs among its laws.
+//   3. WHAT EACH WOULD LOCK: presetsView names, per preset, the locks in force
+//      after a switch to it, including a law of the project's own it would keep.
+//   4. SWITCHING IS A VOTE. POST /government/board/presets files the proposal
+//      through board.proposeLaws (the one path that ever writes a law, on
+//      passing); it writes nothing itself. Nothing is seeded: a project with no
+//      laws is "no preset".
+// DB-free: the routes run through the real router with listLaws and proposeLaws
+// replaced by fakes.
+//
+// Run:  node --test tests/government_presets.mjs
+
+import { strict as assert } from 'node:assert';
+import { test, after } from 'node:test';
+import http from 'node:http';
+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 P = require(path.join(GOV, 'presets.js'));
+const laws = require(path.join(GOV, 'laws.js'));
+const lawLocks = require(path.join(ROOT, 'modules', 'builder-settings', 'law-locks.js'));
+
+const KEYS = ['open', 'guild', 'factory'];
+// The book after a passed proposal: what applyLaws would leave in force.
+let nextId = 100;
+function pass(book, proposal) {
+  const kept = book.filter((r) => !proposal.repeal.includes(String(r.id)));
+  return kept.concat(proposal.enact.map((l) => ({ id: String(nextId++), ...l, repealed_at: null })));
+}
+const textsOf = (book) => book.map((r) => r.text).sort();
+const presetTexts = (key) => P.PRESETS.find((p) => p.key === key).laws.map((l) => l.text).sort();
+const OWN = { id: '7', text: 'Every screen change carries two shots', effect_on_ai: null, locks: [{ setting: 'verbosity', value: 'detailed' }], repealed_at: null };
+
+test('nothing is seeded: a project with no laws runs no preset', () => {
+  assert.equal(P.currentPreset([]), null);
+  assert.equal(P.presetsView([]).current, null);
+  assert.equal(P.currentPreset([OWN]), null, 'a law of the project\'s own is no preset');
+});
+
+test('each preset applies its laws: from any book, a passed switch leaves exactly that preset in force', () => {
+  const starts = [[], [OWN]];
+  for (const from of [null, ...KEYS]) {
+    for (const base of starts) {
+      let book = base.slice();
+      if (from) book = pass(book, P.switchProposal(from, book).proposal);
+      for (const to of KEYS) {
+        if (to === from) { assert.equal(P.switchProposal(to, book).reason, 'preset_in_force'); continue; }
+        const sw = P.switchProposal(to, book);
+        assert.ok(sw.ok, `${from} → ${to}`);
+        assert.ok(laws.validateLawsProposal(sw.proposal).ok, `${from} → ${to}: a valid laws proposal`);
+        assert.ok(laws.checkAgainstInForce(sw.proposal, book).ok, `${from} → ${to}: accepted against the book it is filed on`);
+        const after = pass(book, sw.proposal);
+        assert.equal(P.currentPreset(after), to, `${from} → ${to}: ${to} is in force once passed`);
+        const own = base.length ? [OWN.text] : [];
+        assert.deepEqual(textsOf(after), presetTexts(to).concat(own).sort(), `${from} → ${to}: exactly its laws${own.length ? ', and the project\'s own kept' : ''}`);
+        assert.match(sw.rationale, new RegExp(`to ${P.PRESETS.find((p) => p.key === to).name}`));
+      }
+    }
+  }
+  assert.equal(P.switchProposal('chaos', []).reason, 'unknown_preset');
+});
+
+test('a law shared by two presets is kept across a switch; a changed lock is repealed and re-enacted', () => {
+  const guild = pass([], P.switchProposal('guild', []).proposal);
+  const sw = P.switchProposal('factory', guild);
+  const repealed = guild.filter((r) => sw.proposal.repeal.includes(String(r.id))).map((r) => r.text);
+  assert.deepEqual(repealed, ['Stay on the task; note side ideas'], 'only the off-task cap goes; land-only and stuck stay');
+  assert.ok(!sw.proposal.enact.some((l) => l.text === 'Land only. Ask before going live'), 'the shared law is not enacted twice');
+  // a book that has a preset law's words with other locks is not that preset
+  const drift = guild.map((r) => (r.text === 'Stay on the task; note side ideas' ? { ...r, locks: [{ setting: 'wandering', max: 'balanced' }] } : r));
+  assert.equal(P.currentPreset(drift), null);
+  const fix = P.switchProposal('guild', drift);
+  assert.equal(fix.proposal.repeal.length, 1);
+  assert.equal(fix.proposal.enact.length, 1);
+  assert.equal(P.currentPreset(pass(drift, fix.proposal)), 'guild');
+});
+
+test('every lock a preset carries is enforced on a real personal setting', () => {
+  for (const p of P.PRESETS) {
+    for (const law of p.laws) {
+      for (const lock of law.locks) {
+        assert.ok(lawLocks.settingSpec(lock.setting), `${p.key}: ${lock.setting} is a stored personal setting`);
+      }
+    }
+    const book = pass([], P.switchProposal(p.key, []).proposal);
+    const { locks } = lawLocks.lockedPrefs({}, laws.forSession(book).laws, { rank: 'archon', instanceModels: {} });
+    assert.ok(locks.every((l) => l.enforced), `${p.key}: every lock bites (${JSON.stringify(locks.filter((l) => !l.enforced))})`);
+  }
+});
+
+test('factory is strict: caps on every model, off-task never, the ask format and no unattended runs', () => {
+  const book = pass([], P.switchProposal('factory', []).proposal);
+  const texts = book.map((r) => r.text);
+  assert.ok(texts.includes('Ask like a human'));
+  assert.ok(texts.includes('No unattended runs'));
+  const { prefs, locks } = lawLocks.lockedPrefs({ model_allocation: { main: 'fable', subagentDefault: 'opus' }, wandering: 3 }, laws.forSession(book).laws, { rank: 'archon', instanceModels: {} });
+  const to = Object.fromEntries(locks.map((l) => [l.setting, l.to]));
+  assert.deepEqual(to, { wandering: 'locked', 'model.main': 'opus', 'model.subagentDefault': 'sonnet', 'model.subagentRoutine': 'haiku' });
+  assert.ok(prefs, 'the effective prefs obey it');
+  const open = pass([], P.switchProposal('open', []).proposal);
+  assert.equal(laws.forSession(open).laws.flatMap((l) => l.locks).length, 0, 'an open workshop locks nothing');
+});
+
+test('what each would lock: the locks after a switch, a law of the project\'s own included', () => {
+  const v = P.presetsView([OWN]);
+  const of = (k) => v.presets.find((p) => p.key === k).locks.map((l) => l.setting).sort();
+  assert.deepEqual(of('open'), ['verbosity']);
+  assert.deepEqual(of('guild'), ['verbosity', 'wandering']);
+  assert.deepEqual(of('factory'), ['model.main', 'model.subagentDefault', 'model.subagentRoutine', 'verbosity', 'wandering']);
+  assert.equal(v.presets.filter((p) => p.current).length, 0);
+});
+
+// ── 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 resolver = require(path.join(GOV, 'resolver.js'));
+const db = require(path.join(GOV, 'db.js'));
+const board = require(path.join(GOV, 'board.js'));
+const { attachFail } = require(path.join(ROOT, 'src', 'bongos', 'middleware', 'error-envelope.js'));
+const express = require('express');
+
+const realRequireBuilder = api.requireBuilder;
+const realResolve = resolver.resolveBuilderPermissions;
+const realList = db.listLaws;
+const realPropose = board.proposeLaws;
+let held = ['board.vote.cast', 'board.item.open'];
+let book = [];
+const filed = [];
+api.requireBuilder = (req, res, next) => { req.builder = { id: 3, rank: 'archon' }; next(); };
+resolver.resolveBuilderPermissions = async () => held;
+db.listLaws = async () => book;
+board.proposeLaws = async (a) => {
+  filed.push(a);
+  const c = laws.checkAgainstInForce(laws.validateLawsProposal({ enact: a.enact, repeal: a.repeal }).proposal, book);
+  if (!c.ok) return c;
+  return { ok: true, amendment: { id: '50', kind: 'laws' }, item: { id: '60' }, proposal: { enact: a.enact, repeal: a.repeal } };
+};
+seams._reset();
+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; resolver.resolveBuilderPermissions = realResolve;
+  db.listLaws = realList; board.proposeLaws = realPropose; 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('the preset routes are pinned where the law routes are', () => {
+  const pins = rrc.MODULE_EXPECTED_RANKS.government;
+  assert.equal(pins['GET /government/presets'], 'perm:board.vote.cast');
+  assert.equal(pins['POST /government/board/presets'], 'perm:board.item.open');
+});
+
+test('GET /government/presets: the three presets, none in force on a fresh project; the room\'s floor', async () => {
+  book = [];
+  const r = await call('GET', '/government/presets');
+  assert.equal(r.status, 200);
+  assert.equal(r.json.current, null);
+  assert.deepEqual(r.json.presets.map((p) => p.key), KEYS);
+  book = pass([], P.switchProposal('guild', []).proposal);
+  assert.equal((await call('GET', '/government/presets')).json.current, 'guild');
+  held = ['board.item.open'];
+  try { assert.equal((await call('GET', '/government/presets')).status, 403); } finally { held = ['board.vote.cast', 'board.item.open']; }
+});
+
+test('POST /government/board/presets: a switch is ONE laws vote through proposeLaws; it writes nothing itself', async () => {
+  book = [];
+  filed.length = 0;
+  const r = await call('POST', '/government/board/presets', { preset: 'factory' });
+  assert.equal(r.status, 201);
+  assert.equal(r.json.item.id, '60', 'the vote it filed');
+  assert.equal(filed.length, 1, 'one proposal');
+  assert.deepEqual(filed[0].enact.map((l) => l.text).sort(), presetTexts('factory'));
+  assert.equal(filed[0].proposedBy, 3);
+  assert.match(filed[0].rationaleMd, /Switch from no preset to Factory/);
+  assert.equal(book.length, 0, 'no law was written');
+
+  book = pass([], P.switchProposal('guild', []).proposal);
+  assert.equal((await call('POST', '/government/board/presets', { preset: 'guild' })).json.error.code, 'preset_in_force');
+  assert.equal((await call('POST', '/government/board/presets', { preset: 'chaos' })).status, 400);
+  assert.equal((await call('POST', '/government/board/presets', {})).status, 400);
+  // a law of the project's own holding a setting the preset locks: refused by name
+  book = [{ id: '9', text: 'Agents roam freely', effect_on_ai: null, locks: [{ setting: 'wandering', value: 'exploratory' }], repealed_at: null }];
+  const clash = await call('POST', '/government/board/presets', { preset: 'guild' });
+  assert.equal(clash.status, 409);
+  assert.equal(clash.json.error.code, 'setting_already_locked');
+  held = ['board.vote.cast'];
+  try { assert.equal((await call('POST', '/government/board/presets', { preset: 'open' })).status, 403); } finally { held = ['board.vote.cast', 'board.item.open']; }
+});

package/tests/government_routes.mjs

@@ -97,7 +97,14 @@ test('every /governance route gates via REAL middleware on exactly its PINNED at
   // casting) — still gates on government.manage.
   // task 1004523: the docket reads the board family's atom too — opening the city
   // is part of casting, and each source inside is scoped to its own atom.
-  const boardFamily = (key) => key.includes('/board/') || key.endsWith('/government/constitution') || key.endsWith('/government/docket');
+  // task 1004706: the law book is read where the room is — every builder's agents obey it.
+  // task 1004703: an ask is checked and written where the docket is read.
+  // task 1004709: who leads each building is read where the room is.
+  // task 1004711: a Lead grows their building where the room is (the holder is the wall).
+  // task 1004712: the treasury is read, and its pots and borrows decided, where the room is (the holder and the seat are the walls).
+  // task 1004715: the strictness presets are read where the law book is.
+  // task 1004716: the counts are read where the docket they count is.
+  const boardFamily = (key) => key.includes('/board/') || key.includes('/government/asks') || key.endsWith('/government/constitution') || key.endsWith('/government/docket') || key.endsWith('/government/counts') || key.endsWith('/government/laws') || key.endsWith('/government/leads') || key.endsWith('/government/buildouts') || key.includes('/government/treasury') || key.endsWith('/government/presets');
   for (const r of classified.filter((x) => !boardFamily(x.key))) {
     assert.deepEqual(r.perms, ['government.manage'], `${r.key}: the admin surface gates on the manage atom`);
   }

package/tests/government_routing.mjs

@@ -0,0 +1,118 @@
+// tests/government_routing.mjs — THE DIRECTION DESK: every ask routed to a real
+// seat (task 1004705, goal 1000111; ADR 0376).
+//
+// WHAT IT GUARDS. modules/government/routing.js, the one rule for who an open
+// docket matter waits on:
+//   * every one of the nine buildings routes to its Lead when one is in office,
+//     and to the owner seat (every active Archon) when it is unseated;
+//   * a stored ask's seat wins over the building's; board:<b> goes to the
+//     members its decision rule seats, committee:<b>.<k> to the building's Lead;
+//   * a board sitting with no ask is its voters' (the docket's own `needs`);
+//   * an ask nobody can answer (past its deadline, or on an empty seat) is on
+//     nobody's "to do" and carries its own "if nobody answers" line;
+//   * passing an ask on: only whoever it waits on, only a stored ask, never a vote.
+//
+// Run:  node --test --test-reporter=tap tests/government_routing.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+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 routing = require(path.join(ROOT, 'modules', 'government', 'routing.js'));
+const leads = require(path.join(ROOT, 'modules', 'government', 'leads.js'));
+const { AREA_KEYS } = require(path.join(ROOT, 'modules', 'government', 'decision-rules.js'));
+
+const NOW = Date.parse('2026-10-09T12:00:00Z');
+const ARCHONS = [{ id: 30, github_login: 'builder-30' }, { id: 3, github_login: 'builder-3' }];
+const owner = leads.ownerOf(ARCHONS);
+const lead = (building, builderId) => ({ id: building.length, building, builder_id: builderId, removed_at: null });
+const ASK = { question: 'Ship it?', options: [], recommend: { key: 'go', why: 'Tested.' }, waits_on: 'owner', if_nobody_answers: 'It stays where it is.' };
+const matter = (over = {}) => ({ id: 'blockers:1', source: 'blockers', building: 'planning', state: 'needs', deadline: null, ...over });
+
+test('every building routes to its Lead when seated, else to the owner seat', () => {
+  assert.deepEqual(Object.keys(routing.BUILDING_NAMES), AREA_KEYS, 'the nine buildings, in the docket\'s order');
+  const seated = AREA_KEYS.map((b, i) => lead(b, 100 + i));
+  for (const [i, b] of AREA_KEYS.entries()) {
+    const m = matter({ id: `x:${b}`, building: b });
+    // seated: its Lead, and only its Lead
+    const r = routing.routeMatter(m, String(100 + i), { leads: seated, owner }, NOW);
+    assert.equal(r.seat, `lead:${b}`, `${b}: its Lead's seat`);
+    assert.equal(r.label, `the ${routing.BUILDING_NAMES[b]} Lead`);
+    assert.equal(r.fell_to_owner, false);
+    assert.equal(r.yours, true, `${b}: the Lead's to answer`);
+    assert.equal(routing.routeMatter(m, '3', { leads: seated, owner }, NOW).yours, false, `${b}: not the owner's while it has a Lead`);
+    assert.equal(routing.routeMatter(m, String(100 + ((i + 1) % 9)), { leads: seated, owner }, NOW).yours, false, `${b}: not another building's Lead's`);
+    // unseated: the owner seat, every active Archon
+    const u = routing.routeMatter(m, '30', { leads: seated.filter((l) => l.building !== b), owner }, NOW);
+    assert.deepEqual([u.seat, u.label, u.fell_to_owner, u.yours], ['owner', 'the owner', true, true], `${b}: unseated, it falls to the owner`);
+    assert.equal(routing.routeMatter(m, '3', { leads: [], owner }, NOW).yours, true, `${b}: every Archon holds the owner seat`);
+    assert.equal(routing.routeMatter(m, String(100 + i), { leads: [], owner }, NOW).yours, false, `${b}: an unseated building is not a non-Archon's`);
+  }
+  // a removed Lead is not in office
+  const gone = { ...lead('planning', 7), removed_at: '2026-10-01T00:00:00Z' };
+  assert.equal(routing.routeMatter(matter(), '7', { leads: [gone], owner }, NOW).seat, 'owner');
+});
+
+test('a stored ask\'s seat wins; board and committee seats resolve to real people', () => {
+  const ctx = { leads: [lead('review', 50)], owner, holders: { charter: [{ id: 61 }, { builder_id: 62 }], people: [] } };
+  // the ask names the owner, though the building is seated
+  const toOwner = routing.routeMatter(matter({ building: 'review', ask: ASK }), '50', ctx, NOW);
+  assert.deepEqual([toOwner.seat, toOwner.yours], ['owner', false]);
+  assert.equal(routing.routeMatter(matter({ building: 'review', ask: ASK }), '30', ctx, NOW).yours, true);
+  // board:<b> — the members its decision rule seats
+  const board = routing.routeMatter(matter({ ask: { ...ASK, waits_on: 'board:charter' } }), '62', ctx, NOW);
+  assert.deepEqual([board.seat, board.label, board.yours], ['board:charter', 'the Charter board', true]);
+  assert.equal(routing.routeMatter(matter({ ask: { ...ASK, waits_on: 'board:charter' } }), '30', ctx, NOW).yours, false, 'the owner does not sit on it');
+  // nobody seated there → the owner
+  const empty = routing.routeMatter(matter({ ask: { ...ASK, waits_on: 'board:people' } }), '3', ctx, NOW);
+  assert.deepEqual([empty.seat, empty.fell_to_owner, empty.yours], ['owner', true, true]);
+  // committees are not held anywhere yet: the building's Lead answers, or the owner
+  const com = routing.routeMatter(matter({ ask: { ...ASK, waits_on: 'committee:review.testers' } }), '50', ctx, NOW);
+  assert.deepEqual([com.asked, com.seat, com.yours], ['committee:review.testers', 'lead:review', true]);
+  assert.equal(routing.routeMatter(matter({ ask: { ...ASK, waits_on: 'committee:rules.drafting' } }), '3', ctx, NOW).seat, 'owner');
+  // a seat that is not one is never trusted: the building's own seat
+  assert.equal(routing.seatOf(matter({ building: 'review', ask: { ...ASK, waits_on: 'everyone' } })), 'lead:review');
+});
+
+test('a board sitting with no ask is its voters\', as the docket\'s own needs says', () => {
+  const vote = matter({ id: 'board:9', source: 'board', building: 'charter' });
+  assert.equal(routing.seatOf(vote), 'board:charter');
+  // nobody is listed as holding the charter, yet a voter the sitting awaits has it
+  assert.equal(routing.routeMatter(vote, '77', { leads: [], owner, holders: {} }, NOW).yours, true);
+  assert.equal(routing.routeMatter({ ...vote, state: 'moving' }, '77', { leads: [], owner, holders: {} }, NOW).yours, false, 'voted already: not on them');
+});
+
+test('an ask nobody answers does what its "if nobody answers" line says, on nobody\'s to do', () => {
+  const lapsed = routing.routeMatter(matter({ deadline: '2026-10-08T00:00:00Z', ask: ASK }), '30', { leads: [], owner }, NOW);
+  assert.equal(lapsed.yours, false);
+  assert.deepEqual(lapsed.nobody, { why: 'lapsed', outcome: 'It stays where it is.' });
+  // before its deadline it is still the owner's
+  assert.equal(routing.routeMatter(matter({ deadline: '2026-10-10T00:00:00Z', ask: ASK }), '30', { leads: [], owner }, NOW).yours, true);
+  // a seat nobody holds (no Archon at all): nobody can answer
+  const vacant = routing.routeMatter(matter({ ask: ASK }), '30', { leads: [], owner: leads.ownerOf([]) }, NOW);
+  assert.deepEqual([vacant.yours, vacant.nobody], [false, { why: 'empty_seat', outcome: 'It stays where it is.' }]);
+  // a matter that needs nobody is never "nobody answered"
+  assert.equal(routing.routeMatter(matter({ state: 'moving', deadline: '2026-10-08T00:00:00Z' }), '30', { leads: [], owner }, NOW).nobody, null);
+  // routeAll marks each matter and counts the viewer's
+  const ms = [matter({ id: 'a:1' }), matter({ id: 'a:2', building: 'review' }), matter({ id: 'a:3', ask: ASK, deadline: '2026-10-01T00:00:00Z' })];
+  assert.equal(routing.routeAll(ms, '50', { leads: [lead('review', 50)], owner }, NOW), 1);
+  assert.deepEqual(ms.map((m) => m.route.yours), [false, true, false]);
+});
+
+test('passing an ask on: only whoever it waits on, a stored ask, never a vote, to another seat', () => {
+  const ctx = { leads: [lead('planning', 40)], owner };
+  const m = matter({ ask: { ...ASK, waits_on: 'lead:planning' } });
+  assert.equal(routing.passRefusal(m, '40', 'owner', ctx, NOW), null, 'the Lead hands it to the owner');
+  assert.equal(routing.passRefusal(m, '30', 'owner', ctx, NOW).code, 'not_yours', 'the owner cannot move what waits on the Lead');
+  assert.equal(routing.passRefusal(m, '40', 'lead:planning', ctx, NOW).code, 'same_seat');
+  assert.equal(routing.passRefusal(m, '40', 'the boss', ctx, NOW).code, 'unknown_seat');
+  assert.equal(routing.passRefusal(matter(), '40', 'owner', ctx, NOW).code, 'no_ask');
+  assert.equal(routing.passRefusal({ ...m, id: 'board:3', source: 'board' }, '40', 'owner', ctx, NOW).code, 'vote_not_passable');
+  // to an unseated building's Lead is to the owner: already there
+  assert.equal(routing.passRefusal(matter({ ask: ASK }), '30', 'lead:rules', ctx, NOW).code, 'same_seat');
+  assert.equal(routing.passRefusal(matter({ ask: ASK }), '30', 'lead:planning', ctx, NOW), null, 'the owner hands it to a seated Lead');
+});

package/tests/government_seed.mjs

@@ -46,6 +46,11 @@ const NON_GRANT_MIGRATIONS = new Set([
   'government_020_genesis_stage_subject.sql',      // BV2.PS04 genesis_stage board subject CHECK (task 1004429)
   'government_023_decision_rules.sql',             // who decides what: the decision-rules table, matters (task 1004529)
   'government_026_board_outcome_withdrawn.sql',    // board outcome CHECK widened: withdrawn, expired (task 1004564)
+  'government_027_laws.sql',                       // standing orders: the laws table, amendment kind 'laws' (task 1004706)
+  'government_028_asks.sql',                       // the ask: one stored shape per docket matter (task 1004703)
+  'government_029_leads.sql',                      // the Lead of each building, seated by a passed People matter (task 1004709)
+  'government_030_buildouts.sql',                  // a Lead's build-outs, on the record at once or by a passed vote (task 1004711)
+  'government_031_treasury.sql',                   // the treasury: a pot per goal and the loans a dry pot asks the reserve for (task 1004712)
 ]);
 
 // Permission keys RENAMED after the grant migrations that first granted them.