@bongos/core 1.21.175 → 1.21.176

package/scripts/bongos/government-walk.js

@@ -0,0 +1,1477 @@
+#!/usr/bin/env node
+'use strict';
+
+// scripts/bongos/government-walk.js — THE GOVERNMENT WALK: one repeatable end-to-end
+// pass over a throwaway test project's government, producing a pass/fail table
+// (task 1004658, goal 1000111, criterion gov-proven-and-kept-proven).
+//
+// WHAT IT WALKS, in nine sections:
+//   1. Genesis — start founding, decide with a chosen government, close all five
+//      stages, come alive; the constitution reads as the choice.
+//   2. Every available form (Monarchy / BDFL, Timocratic Republic, Direct Democracy,
+//      Foundation with a council rank) plus the two pass rules no form uses
+//      (majority, unanimous): switch to it through a charter amendment, then confirm
+//      who can vote and what passes.
+//   3. Every building: set it to decide by vote (a decision-rules amendment), try to
+//      act alone on each of its bound routes (refused), restore it (reachable again).
+//   4. Every matter action: open the matter, pass it, confirm the effect happened.
+//   5. Laws (task 1004719): proposed, passed by the board in force, read into every
+//      session (the government port GET /me carries), a lock refused on write and
+//      applied on read, repealed; strictness presets switched by one vote each.
+//   6. Leads and build-outs: a Lead appointed by a People vote, then under each
+//      form of government what the Lead may build at once and what goes to a vote.
+//   7. Asks: the shape enforced, ask_required for an AI session's blocker, the ask
+//      routed to its seat and passed on, and GET /government/counts agreeing with
+//      the docket and the hall's own count rule.
+//   8. The treasury: a pot given, run dry, the sweep files one borrow, answered once.
+//   9. Positions: the seats GET /me carries and the governing tab they gate; the
+//      Lead removed by a vote; nothing the walk put up is left standing.
+//
+// HOW REAL IT IS. Every request is real HTTP through the real routers (government,
+// onboarding/genesis, and every building's own router), with the real
+// requirePermission gate resolving the real government port, and every decision is
+// the real code: the board, membership, the tally, the close, the charter apply
+// (written to a throwaway instance folder), the decision-rules apply, act-alone, and
+// each module's matter act. What is NOT real is the storage under them: there is no
+// Postgres on the machine this was built on, so the government module's db layer is
+// an in-memory fake with the same row shapes and the same guards (one open sitting
+// per subject, one vote per member, single-winner close, the decision-rules write
+// only from a passed decision-rules amendment), and the few writes a passed matter
+// makes into other modules are recorded in memory instead of written to a database
+// (or, for a gate approval, sent to GitHub). The table says which mode ran.
+//
+// Usage:
+//   node scripts/bongos/government-walk.js           run it and print the table
+//   node scripts/bongos/government-walk.js --write   also write docs/governance/government-walk.md
+//   node scripts/bongos/government-walk.js --check   exit 1 if the committed table differs
+// tests/government_walk.mjs runs --check, so a change that flips any row reds CI.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const DOC_PATH = path.join(ROOT, 'docs', 'governance', 'government-walk.md');
+
+// Bugs this walk found, filed as tasks under goal 1000111. A FAIL row names its task
+// so the table reads as a worklist; a row that starts passing again just passes.
+const KNOWN_BUGS = Object.freeze({});
+
+// ── the throwaway project ───────────────────────────────────────────────────
+
+// The test project's people. 42 founds it. 47 left the project; it only ever
+// authors the probe ideas, so no probe is decided by its own author.
+const BUILDERS = Object.freeze([
+  { id: '42', rank: 'archon', github_login: 'ada', display_name: 'Ada (founder)', status: 'active' },
+  { id: '43', rank: 'metic', github_login: 'ben', display_name: 'Ben', status: 'active' },
+  { id: '44', rank: 'metic', github_login: 'cy', display_name: 'Cy', status: 'active' },
+  { id: '45', rank: 'thetes', github_login: 'dee', display_name: 'Dee', status: 'active' },
+  { id: '46', rank: 'xenos', github_login: 'eve', display_name: 'Eve', status: 'active' },
+  { id: '47', rank: 'xenos', github_login: 'fay', display_name: 'Fay (left)', status: 'left' },
+]);
+const ACTIVE_IDS = BUILDERS.filter((b) => b.status === 'active').map((b) => b.id);
+const FOUNDER = '42';
+const COUNCIL = ['43', '44'];
+
+// Each bound route as a request that, as today, stops in its handler's own first
+// check (a bad id or body) before any database write — the same requests as
+// tests/government_act_alone_buildings.mjs, with People's two carrying a real
+// custom rank and builder of this project.
+const BAD = 'x';
+const REQUESTS = Object.freeze({
+  'PATCH /project-settings/rot-days': ['PATCH', '/project-settings/rot-days', { days: 'soon' }],
+  'PATCH /project-settings/ship-mode': ['PATCH', '/project-settings/ship-mode', { mode: 'sometimes' }],
+  'PATCH /project-settings/tweak-autopickup': ['PATCH', '/project-settings/tweak-autopickup', { mode: 'sometimes' }],
+  'PATCH /project-settings/spend-cap': ['PATCH', '/project-settings/spend-cap', { usd: 'lots' }],
+  'PATCH /work-categories/:id': ['PATCH', `/work-categories/${BAD}`, {}],
+  'POST /security/reports/:id/confirm': ['POST', `/security/reports/${BAD}/confirm`, {}],
+  'POST /security/reports/:id/dispute': ['POST', `/security/reports/${BAD}/dispute`, {}],
+  'POST /security/reports/:id/fix': ['POST', `/security/reports/${BAD}/fix`, {}],
+  'POST /government/assignments': ['POST', '/government/assignments', { builder_id: 46, rank_key: 'tester' }],
+  'DELETE /government/assignments/:builderId/:rankKey': ['DELETE', '/government/assignments/46/tester'],
+  'PATCH /access-requests/:id': ['PATCH', `/access-requests/${BAD}`, { status: 'invited' }],
+  'POST /access-requests/invite': ['POST', '/access-requests/invite', {}],
+  'POST /goals': ['POST', '/goals', {}],
+  'POST /goals/reorder': ['POST', '/goals/reorder', {}],
+  'POST /work-categories': ['POST', '/work-categories', {}],
+  'PUT /versions/focus': ['PUT', '/versions/focus', { version_id: '   ' }],
+  'POST /autonomy/fence': ['POST', '/autonomy/fence', { enabled: 'yes' }],
+  'POST /autonomy/fence/goals': ['POST', '/autonomy/fence/goals', { goal_id: 0 }],
+  'DELETE /autonomy/fence/goals/:goalId': ['DELETE', `/autonomy/fence/goals/${BAD}`],
+  'POST /autonomy/fence/priority': ['POST', '/autonomy/fence/priority', {}],
+  'POST /autonomy/builders/:builderId/pause': ['POST', `/autonomy/builders/${BAD}/pause`, { paused: false }],
+  'POST /done-when/:criterionId/satisfy': ['POST', `/done-when/${BAD}/satisfy`, {}],
+  'POST /done-when/:criterionId/unsatisfy': ['POST', `/done-when/${BAD}/unsatisfy`, {}],
+  'POST /gate-approvals/:pr/approve': ['POST', `/gate-approvals/${BAD}/approve`, {}],
+  'POST /override-requests/:id/decide': ['POST', `/override-requests/${BAD}/decide`, { decision: 'approve' }],
+  'POST /provisioning/instances/:id/core-upgrade': ['POST', `/provisioning/instances/${BAD}/core-upgrade`, { to: '1.2.3' }],
+  'POST /provisioning/instances/:id/update-channel': ['POST', `/provisioning/instances/${BAD}/update-channel`, { channel: 'nightly' }],
+  'POST /render-deploy/act': ['POST', '/render-deploy/act', { action: 'launch' }],
+  'POST /npm-release/release': ['POST', '/npm-release/release', { version: 'v-next' }],
+  'PATCH /builders/:id/budget': ['PATCH', `/builders/${BAD}/budget`, { monthly_budget_usd: 5 }],
+});
+
+// Every matter action, as the matter the walk opens and passes: [area, title, action,
+// the effect in words]. runWalk observes each effect (its HAPPENED table).
+const MATTER_PLAN = Object.freeze([
+  ['people', 'Give Eve the tester rank', { type: 'assign_rank', builder_id: 46, rank_key: 'tester' }, 'Eve holds tester'],
+  ['people', 'Take the tester rank from Eve', { type: 'unassign_rank', builder_id: 46, rank_key: 'tester' }, 'Eve no longer holds tester'],
+  ['people', 'Dee leads Planning', { type: 'appoint_lead', building: 'planning', builder_id: 45, charter: 'Goals, priorities and the order of work.' }, 'Dee leads Planning'],
+  ['people', 'Planning has no Lead', { type: 'remove_lead', building: 'planning' }, 'Planning has no Lead'],
+  ['automation', 'Switch unattended building on', { type: 'switch_on' }, 'fence on'],
+  ['automation', 'Switch unattended building off', { type: 'switch_off' }, 'fence off'],
+  ['automation', 'Allow goal 77 to build unattended', { type: 'allow_goal', goal_id: 77 }, 'goal 77 allowed'],
+  ['release', 'Approve override request 5', { type: 'approve_override', request_id: 5 }, 'request 5 approved'],
+  ['release', 'Clear the gate on PR 1500', { type: 'approve_gate', pr: 1500 }, 'PR 1500 cleared'],
+  ['review', 'Sign off criterion 9', { type: 'satisfy_criterion', criterion_id: 9 }, 'criterion 9 satisfied'],
+  ['treasury', 'Dee gets $50 a month', { type: 'set_budget', builder_id: 45, monthly_usd: 50 }, 'Dee\'s limit is $50'],
+]);
+
+// Every router the walk drives, mounted as the server mounts them.
+const ROUTERS = Object.freeze([
+  'modules/government/routes/government.js',
+  'modules/onboarding/routes/onboarding.js',
+  'modules/autonomy/routes/autonomy.js',
+  // no HTTP surface; it contributes the Release and Review matter acts, as at boot
+  'modules/lifecycle/routes/lifecycle.js',
+  'modules/lifecycle/routes/done-when.js',
+  'modules/lifecycle/routes/gate-approvals.js',
+  'modules/lifecycle/routes/tasks.js',
+  'modules/lifecycle/routes/goals.js',
+  'modules/lifecycle/routes/versions.js',
+  'modules/lifecycle/routes/project-settings.js',
+  'modules/render-deploy/routes/act.js',
+  'modules/npm-release/routes/release.js',
+  'modules/provisioning/routes/core-upgrade.js',
+  'src/bongos/routes/builders.js',
+  'modules/security/routes/reports.js',
+  // the new machinery's other doors: a blocker and its ask, a builder's settings
+  'modules/ideas/routes/blockers.js',
+  'modules/builder-settings/routes/settings.js',
+]);
+
+// ── the in-memory government store ──────────────────────────────────────────
+//
+// The government module's db.js, with the same row shapes and the same guards the
+// SQL carries. Any db function the walk did not expect throws, so a code path that
+// reaches storage this fake does not model shows up as a FAIL rather than a quiet
+// undefined.
+function makeStore(catalog) {
+  const s = {
+    seq: 100,
+    clock: 0,
+    builders: new Map(BUILDERS.map((b) => [b.id, { ...b }])),
+    customRanks: new Map(),
+    assignments: [], // { builder_id, rank_key, assigned_by }
+    items: [],
+    votes: [],
+    amendments: new Map(),
+    matters: new Map(),
+    leads: [], // { id, building, builder_id, charter, appointed_by_item_id, removed_by_item_id, removed_at }
+    laws: [], // { id, text, effect_on_ai, locks, proposed_by, passed_by_item_id, passed_at, repealed_by_item_id, repealed_at }
+    buildouts: [], // { id, building, capsule, name, line, built_by, authorised_by_item_id, ground, why, started_at }
+    rules: new Map(),
+    ideas: new Map(),
+    tasks: new Map(),
+    karma: [],
+    unexpected: [],
+  };
+  const next = () => String(++s.seq);
+  const tick = () => `T${String(++s.clock).padStart(4, '0')}`;
+  const heldRanks = (id) => {
+    const b = s.builders.get(String(id));
+    if (!b) return [];
+    return [b.rank, ...s.assignments.filter((a) => a.builder_id === String(id)).map((a) => a.rank_key)];
+  };
+  const isLive = (b) => b && b.status === 'active';
+  const copy = (x) => (x == null ? x : JSON.parse(JSON.stringify(x)));
+  const withExpiry = (i) => ({ ...copy(i), expired: false, remaining_seconds: null });
+  const voteRow = (v) => {
+    const b = s.builders.get(v.voter_id) || {};
+    return { ...copy(v), github_login: b.github_login || null, display_name: b.display_name || null };
+  };
+
+  const fns = {
+    async getPermissionKeysForBuilder(id) {
+      const keys = new Set();
+      for (const r of heldRanks(id)) for (const k of catalog.RANK_SEED[r] || []) keys.add(k);
+      return [...keys];
+    },
+    async getRankKeysForBuilder(id) { return heldRanks(id).sort(); },
+    async getRankByKey(k) {
+      if (catalog.RANK_SEED[k]) return { rank_key: k, label: k, is_system: true, seeded_rank: k };
+      return copy(s.customRanks.get(k)) || null;
+    },
+    async createRank({ rankKey, label, description, createdBy }) {
+      if (catalog.RANK_SEED[rankKey] || s.customRanks.has(rankKey)) throw Object.assign(new Error('dup'), { code: '23505' });
+      const row = { rank_key: rankKey, label, description: description ?? null, is_system: false, seeded_rank: null, created_by: String(createdBy) };
+      s.customRanks.set(rankKey, row);
+      return copy(row);
+    },
+    async assignRank({ builderId, rankKey, assignedBy }) {
+      const id = String(builderId);
+      if (!s.builders.has(id)) throw Object.assign(new Error('fk'), { code: '23503' });
+      if (s.assignments.some((a) => a.builder_id === id && a.rank_key === rankKey)) return false;
+      s.assignments.push({ builder_id: id, rank_key: rankKey, assigned_by: assignedBy == null ? null : String(assignedBy) });
+      return true;
+    },
+    async unassignRank({ builderId, rankKey }) {
+      const before = s.assignments.length;
+      s.assignments = s.assignments.filter((a) => !(a.builder_id === String(builderId) && a.rank_key === rankKey));
+      return s.assignments.length < before;
+    },
+    async listAssignments() { return copy(s.assignments); },
+    async getActiveBuildersWithRank(rankKeys) {
+      return [...s.builders.values()]
+        .filter((b) => isLive(b) && heldRanks(b.id).some((r) => rankKeys.includes(r)))
+        .sort((a, b) => Number(a.id) - Number(b.id))
+        .map((b) => ({ builder_id: b.id, github_login: b.github_login, display_name: b.display_name }));
+    },
+    async builderHoldsRankActive(id, rankKeys) {
+      const b = s.builders.get(String(id));
+      return isLive(b) && heldRanks(id).some((r) => rankKeys.includes(r));
+    },
+    async countActiveBuilders() { return [...s.builders.values()].filter(isLive).length; },
+    async openBoardItem({ subjectType, subjectId, openedBy = null, constitution, windowMinutes = null }) {
+      if (s.items.some((i) => i.subject_type === subjectType && i.subject_id === String(subjectId) && !i.closed_at)) return null;
+      const row = {
+        id: next(), subject_type: subjectType, subject_id: String(subjectId),
+        opened_by: openedBy == null ? null : String(openedBy), opened_at: tick(),
+        closes_at: windowMinutes == null ? null : `in ${windowMinutes} minutes`,
+        closed_at: null, outcome: null, constitution: copy(constitution || {}),
+      };
+      s.items.push(row);
+      return copy(row);
+    },
+    async getOpenBoardItem(type, subjectId) {
+      return copy(s.items.find((i) => i.subject_type === type && i.subject_id === String(subjectId) && !i.closed_at)) || null;
+    },
+    async getBoardItemForVote(id) {
+      const i = s.items.find((x) => x.id === String(id));
+      return i ? withExpiry(i) : null;
+    },
+    async getBoardItemAuthor(item) {
+      if (!item) return null;
+      if (item.subject_type === 'full_idea') {
+        const idea = s.ideas.get(String(item.subject_id));
+        return idea ? idea.captured_by : null;
+      }
+      return item.opened_by ?? null;
+    },
+    async insertBoardVote({ itemId, voterId, direction, reasonMd = null, sectionKey = null }) {
+      if (s.votes.some((v) => v.item_id === String(itemId) && v.voter_id === String(voterId))) return null;
+      const row = { id: next(), item_id: String(itemId), voter_id: String(voterId), direction, reason_md: reasonMd, section_key: sectionKey, cast_at: tick() };
+      s.votes.push(row);
+      return copy(row);
+    },
+    async getBoardVote(itemId, voterId) {
+      return copy(s.votes.find((v) => v.item_id === String(itemId) && v.voter_id === String(voterId))) || null;
+    },
+    async insertVoteKarma({ voterId, itemId, delta }) { s.karma.push({ builder_id: String(voterId), reason: `vote:${itemId}`, delta }); },
+    async getVotesForItem(id) { return s.votes.filter((v) => v.item_id === String(id)).map(copy); },
+    async getVotesForItems(ids) { const want = ids.map(String); return s.votes.filter((v) => want.includes(v.item_id)).map(voteRow); },
+    async closeBoardItem({ itemId, outcome, afterClose = null }) {
+      const i = s.items.find((x) => x.id === String(itemId) && !x.closed_at);
+      if (!i) return null;
+      // A transaction: the close and whatever rides it land together or not at all.
+      const rulesBefore = new Map(s.rules);
+      i.closed_at = tick();
+      i.outcome = outcome;
+      if (typeof afterClose === 'function') {
+        try {
+          await afterClose({ query: async () => { throw new Error('walk store: no raw SQL inside a close'); } }, copy(i));
+        } catch (err) {
+          i.closed_at = null;
+          i.outcome = null;
+          s.rules = rulesBefore;
+          throw err;
+        }
+      }
+      return copy(i);
+    },
+    async createAmendment({ proposed, rationaleMd = null, proposedBy, kind = 'constitution' }) {
+      const row = { id: next(), proposed: copy(proposed), rationale_md: rationaleMd, proposed_by: String(proposedBy), kind };
+      s.amendments.set(row.id, row);
+      return copy(row);
+    },
+    async getAmendment(id) { return copy(s.amendments.get(String(id))) || null; },
+    async listAmendmentHistory(limit = 50) {
+      return s.items
+        .filter((i) => i.subject_type === 'constitutional_amendment' && i.closed_at)
+        .sort((a, b) => (a.closed_at < b.closed_at ? 1 : -1))
+        .slice(0, limit)
+        .map((i) => {
+          const a = s.amendments.get(i.subject_id) || {};
+          return {
+            item_id: i.id, amendment_id: i.subject_id, proposed: copy(a.proposed), rationale_md: a.rationale_md,
+            proposed_by: a.proposed_by, opened_at: i.opened_at, closed_at: i.closed_at, outcome: i.outcome,
+            decided_under: copy(i.constitution), kind: a.kind || 'constitution',
+          };
+        });
+    },
+    async listDecisionRules() { return [...s.rules.values()].map(copy); },
+    // The SQL's guard: written only by a PASSED decision-rules amendment item.
+    async applyDecisionRules(_client, { itemId, rules }) {
+      const i = s.items.find((x) => x.id === String(itemId));
+      const a = i && s.amendments.get(i.subject_id);
+      const allowed = i && a && i.subject_type === 'constitutional_amendment' && i.outcome === 'passed' && a.kind === 'decision_rules';
+      if (!allowed) throw new Error(`decision rules not written (item ${itemId} is not a passed decision-rules amendment)`);
+      for (const r of rules) {
+        s.rules.set(r.area, { area: r.area, decided_by: r.decided_by, rule: r.rule, who: r.who, set_by_item_id: String(itemId), updated_at: tick() });
+      }
+      return rules.length;
+    },
+    async createMatter({ area, title, detailMd = null, action = null, proposedBy }) {
+      const row = { id: next(), area, title, detail_md: detailMd, action: copy(action), proposed_by: String(proposedBy) };
+      s.matters.set(row.id, row);
+      return copy(row);
+    },
+    async getMatter(id) { return copy(s.matters.get(String(id))) || null; },
+    // The Lead of a building (task 1004709): government_029's guard — written only
+    // by a passed People matter whose action names this very building and builder.
+    async listLeads({ includePast = false } = {}) {
+      return s.leads.filter((l) => includePast || !l.removed_at).map((l) => {
+        const b = s.builders.get(l.builder_id) || {};
+        return { ...copy(l), github_login: b.github_login || null, display_name: b.display_name || null };
+      });
+    },
+    async getActiveBuilder(id) {
+      const b = s.builders.get(String(id));
+      return isLive(b) ? { id: b.id, github_login: b.github_login, display_name: b.display_name } : null;
+    },
+    async applyLeadAct({ itemId, action }) {
+      const i = s.items.find((x) => x.id === String(itemId));
+      const m = i && s.matters.get(i.subject_id);
+      const a = m && m.action;
+      const allowed = i && a && i.subject_type === 'people_matter' && i.outcome === 'passed'
+        && a.type === action.type && a.building === action.building
+        && (a.type === 'remove_lead' || (String(a.builder_id) === String(action.builder_id) && a.charter === action.charter));
+      if (!allowed) throw new Error(`lead not written (item ${itemId} is not a passed People matter that says so)`);
+      const sitting = s.leads.find((l) => l.building === action.building && !l.removed_at) || null;
+      if (action.type === 'remove_lead' && !sitting) return { done: false, reason: 'no_lead' };
+      if (s.leads.some((l) => l.appointed_by_item_id === String(itemId))) return { done: true, reason: 'already_carried_out' };
+      if (sitting) { sitting.removed_by_item_id = String(itemId); sitting.removed_at = tick(); }
+      if (action.type === 'remove_lead') return { done: true, lead: null, ended: copy(sitting) };
+      const row = { id: next(), building: action.building, builder_id: String(action.builder_id), charter: action.charter, appointed_by_item_id: String(itemId), appointed_at: tick(), removed_by_item_id: null, removed_at: null };
+      s.leads.push(row);
+      return { done: true, lead: copy(row), ended: copy(sitting) };
+    },
+    async getMatterSubjects(ids) { return ids.map((id) => s.matters.get(String(id))).filter(Boolean).map(copy); },
+    // The law book (task 1004706): government_027's guard — a law is written, or
+    // repealed, only by a PASSED laws amendment, inside the close that passes it.
+    async listLaws({ includeRepealed = false } = {}) {
+      return s.laws.filter((l) => includeRepealed || !l.repealed_at).map((l) => {
+        const i = s.items.find((x) => x.id === l.passed_by_item_id) || {};
+        const b = s.builders.get(l.proposed_by) || {};
+        return { ...copy(l), decided_under: copy(i.constitution), proposer_login: b.github_login || null, proposer_name: b.display_name || null };
+      });
+    },
+    async listYesVoters(itemIds) {
+      const want = (itemIds || []).map(String);
+      return s.votes.filter((v) => want.includes(v.item_id) && v.direction === 'yes').map(voteRow);
+    },
+    async applyLaws(_client, { itemId, enact = [], repeal = [], proposedBy = null }) {
+      const i = s.items.find((x) => x.id === String(itemId));
+      const a = i && s.amendments.get(i.subject_id);
+      if (!(i && a && i.subject_type === 'constitutional_amendment' && i.outcome === 'passed' && a.kind === 'laws')) {
+        throw new Error(`law not written (item ${itemId} is not a passed laws amendment)`);
+      }
+      const enacted = enact.map((law) => {
+        const row = { id: next(), text: law.text, effect_on_ai: law.effect_on_ai ?? null, locks: copy(law.locks || []), proposed_by: proposedBy == null ? null : String(proposedBy), passed_by_item_id: String(itemId), passed_at: tick(), repealed_by_item_id: null, repealed_at: null };
+        s.laws.push(row);
+        return copy(row);
+      });
+      const repealed = [];
+      for (const l of s.laws) {
+        if (repeal.map(String).includes(l.id) && !l.repealed_at) {
+          l.repealed_by_item_id = String(itemId);
+          l.repealed_at = tick();
+          repealed.push({ id: l.id, repealed_at: l.repealed_at });
+        }
+      }
+      return { enacted, repealed };
+    },
+    // The owner seat: every active Archon, oldest id first.
+    async listActiveArchons() {
+      return [...s.builders.values()].filter((b) => isLive(b) && b.rank === 'archon')
+        .sort((a, b) => Number(a.id) - Number(b.id))
+        .map((b) => ({ id: b.id, github_login: b.github_login, display_name: b.display_name }));
+    },
+    // A Lead's build-outs (task 1004711): government_030's guard — a vote's
+    // build-out only from a passed build_out matter that says so, and an at-once
+    // one only with the build-rights ground that allowed it, never a district.
+    async listBuildouts() {
+      return s.buildouts.map((o) => {
+        const b = s.builders.get(o.built_by) || {};
+        return { ...copy(o), github_login: b.github_login || null, display_name: b.display_name || null };
+      });
+    },
+    async listPendingBuildouts() {
+      return s.items.filter((i) => !i.closed_at && /_matter$/.test(i.subject_type)).map((i) => {
+        const m = s.matters.get(i.subject_id);
+        return m && m.action && m.action.type === 'build_out'
+          ? { item_id: i.id, matter_id: m.id, action: copy(m.action), opened_at: i.opened_at, closes_at: i.closes_at } : null;
+      }).filter(Boolean);
+    },
+    async insertBuildout({ building, capsule, name, line = '', builtBy = null, itemId = null, ground = null, why = null }) {
+      if (itemId != null) {
+        const i = s.items.find((x) => x.id === String(itemId));
+        const m = i && s.matters.get(i.subject_id);
+        const a = m && m.action;
+        const ok = i && i.outcome === 'passed' && a && a.type === 'build_out' && a.building === building && a.capsule === capsule;
+        if (!ok) throw new Error(`build-out not written (item ${itemId} is not a passed build_out matter that says so)`);
+        if (s.buildouts.some((o) => o.authorised_by_item_id === String(itemId))) return { done: true, reason: 'already_carried_out' };
+      } else if (!ground || !why || capsule === 'district') {
+        throw new Error('build-out not written (no vote and no build-rights ground)');
+      }
+      const row = { id: next(), building, capsule, name, line, built_by: builtBy == null ? null : String(builtBy), authorised_by_item_id: itemId == null ? null : String(itemId), ground, why, started_at: tick() };
+      s.buildouts.push(row);
+      return { done: true, buildout: copy(row) };
+    },
+    // The room's reads (the docket's charter floors and the board source).
+    async listRanksWithGrants() {
+      const sys = Object.keys(catalog.RANK_SEED).map((k) => ({ rank_key: k, label: k, description: null, is_system: true, seeded_rank: k, permissions: [...catalog.RANK_SEED[k]].sort() }));
+      return sys.concat([...s.customRanks.values()].map((r) => ({ ...copy(r), permissions: [] })));
+    },
+    async listOpenBoardItems() { return s.items.filter((i) => !i.closed_at).map(withExpiry).reverse(); },
+    async listClosedBoardItems(limit = 20) { return s.items.filter((i) => i.closed_at).sort((a, b) => (a.closed_at < b.closed_at ? 1 : -1)).slice(0, limit).map(copy); },
+    async getIdeaSubjects(ids) {
+      return ids.map(String).filter((id) => s.ideas.has(id)).map((id) => ({ id, title: `Idea ${id}`, captured_by: s.ideas.get(id).captured_by, field_values: {}, template_key: null, completeness_score: s.ideas.get(id).completeness, recommendation: null }));
+    },
+    async getAmendmentSubjects(ids) { return ids.map((id) => s.amendments.get(String(id))).filter(Boolean).map(copy); },
+    async openBoardItemsAwaitingVoter(voterId) {
+      return s.items.filter((i) => !i.closed_at).map((i) => ({
+        id: i.id, subject_type: i.subject_type, subject_id: i.subject_id, constitution: copy(i.constitution), opened_at: i.opened_at, closes_at: i.closes_at,
+        author_id: i.subject_type === 'full_idea' ? ((s.ideas.get(i.subject_id) || {}).captured_by || null) : i.subject_type === 'genesis_stage' ? null : i.opened_by,
+        already_voted: s.votes.some((v) => v.item_id === i.id && v.voter_id === String(voterId)),
+      }));
+    },
+    async getTaskStatuses(ids) {
+      return ids.map(String).filter((id) => s.tasks.has(id)).map((id) => ({ id, status: s.tasks.get(id).status }));
+    },
+    async listLatestGenesisStageItems() {
+      const latest = new Map();
+      for (const i of s.items.filter((x) => x.subject_type === 'genesis_stage')) latest.set(i.subject_id, i);
+      return [...latest.values()].map(withExpiry);
+    },
+    async insertAuthorRatifyKarma({ authorId, itemId, delta }) {
+      const reason = `board.item.ratified:${itemId}`;
+      if (s.karma.some((k) => k.reason === reason)) return false;
+      s.karma.push({ builder_id: String(authorId), reason, delta });
+      return true;
+    },
+    async getIdeaCompleteness(id) { const idea = s.ideas.get(String(id)); return idea ? idea.completeness : null; },
+  };
+  return { s, fns };
+}
+
+function installStore(govDb, fns, unexpected) {
+  for (const k of Object.keys(govDb)) {
+    if (typeof govDb[k] !== 'function') continue;
+    govDb[k] = fns[k] || (async () => {
+      unexpected.push(k);
+      throw new Error(`walk store: unexpected db call ${k}`);
+    });
+  }
+}
+
+// The walk's fixed clock for the treasury (mid-month), so a borrow's amount, which
+// follows the month's pace, reads the same on every run.
+const TREASURY_NOW = Date.UTC(2026, 9, 15, 12);
+const WALK_GOAL = '77';
+
+// The other stores the new machinery reads and writes, in memory: the asks
+// (government_028), the pots and borrows (government_031), each builder's
+// personal settings (builders.behavior_prefs) and the blockers. Each fake keeps
+// the guard its table carries. The shared Postgres pool itself refuses every
+// query, so a read the walk does not model fails loudly in its own building
+// (a docket floor reads as unavailable) and never reaches a real database.
+function installSideStores(req, store) {
+  const poolMod = req('src/bongos/pool.js');
+  const refuse = async () => { throw new Error('walk: no database'); };
+  poolMod.pool.query = refuse;
+  poolMod.pool.connect = refuse;
+
+  const asks = req('modules/government/asks.js');
+  const asksDb = req('modules/government/asks-db.js');
+  const asked = new Map(); // matter id → row
+  asksDb.saveAsk = async ({ matterId, ask, builderId }) => {
+    if (!asks.isMatterId(matterId)) throw Object.assign(new Error('bad matter id'), { code: 'BAD_MATTER_ID' });
+    const row = { matter_id: matterId, question: ask.question, options: JSON.parse(JSON.stringify(ask.options)), recommend_key: ask.recommend.key, recommend_why: ask.recommend.why, waits_on: ask.waits_on, if_nobody_answers: ask.if_nobody_answers, detail: ask.detail || null, written_by: builderId == null ? null : String(builderId), written_at: new Date().toISOString() };
+    asked.set(matterId, row);
+    return asks.fromRow(row);
+  };
+  asksDb.asksFor = async (ids) => {
+    const out = new Map();
+    for (const id of Array.isArray(ids) ? ids : []) if (asked.has(id)) out.set(id, asks.fromRow(asked.get(id)));
+    return out;
+  };
+
+  const treasury = req('modules/government/treasury.js');
+  const treasuryDb = req('modules/government/treasury-db.js');
+  const t = { goals: new Map([[WALK_GOAL, { id: WALK_GOAL, title: 'Walk goal', status: 'open' }]]), pots: new Map(), spend: new Map(), borrows: [], seq: 900 };
+  const borrowsOf = (month) => t.borrows.filter((b) => b.month === month || b.state === 'open').map((b) => ({ ...b }));
+  const withTitle = (b) => ({ ...b, title: (t.goals.get(b.goal_id) || {}).title || null });
+  treasuryDb.readTreasury = async () => {
+    const month = treasury.monthKey(TREASURY_NOW);
+    const total = [...t.spend.values()].reduce((a, v) => a + v, 0);
+    return treasury.buildTreasury({
+      now: TREASURY_NOW, goals: [...t.goals.values()], pots: [...t.pots.values()],
+      spend: { month_usd: total, last_month_usd: 0, by_goal: Object.fromEntries(t.spend) },
+      borrows: borrowsOf(month), cap: { usd: null, source: 'default' },
+    });
+  };
+  treasuryDb.goalById = async (id) => (t.goals.has(String(id)) ? { ...t.goals.get(String(id)) } : null);
+  treasuryDb.setPot = async ({ goalId, budget, builderId }) => {
+    const id = String(goalId);
+    if (budget == null) return { removed: t.pots.delete(id) };
+    const pot = { goal_id: id, budget_usd: budget, set_by: String(builderId), set_at: null };
+    t.pots.set(id, pot);
+    return { pot: { ...pot } };
+  };
+  // The real sweep's loop over the in-memory rows, with its one-open guard.
+  treasuryDb.fileBorrows = async () => {
+    const view = await treasuryDb.readTreasury();
+    const filed = [];
+    for (const pot of view.pots) {
+      if (!treasury.needsBorrow(pot, borrowsOf(view.month), view.month)) continue;
+      if (t.borrows.some((b) => b.goal_id === pot.goal_id && b.state === 'open')) continue;
+      const amount = treasury.borrowAmount(pot, TREASURY_NOW);
+      const ask = treasury.borrowAsk({ title: pot.title, amount_usd: amount, spent_usd: pot.spent_usd, budget_usd: pot.budget_usd, lent_usd: pot.lent_usd, cap: view.cap, month_usd: view.spend.month_usd });
+      const row = { id: String(++t.seq), goal_id: pot.goal_id, month: view.month, amount_usd: amount, budget_usd: pot.budget_usd + pot.lent_usd, spent_usd: pot.spent_usd, filed_at: new Date().toISOString(), state: 'open', lent_usd: null, answer_key: null, answered_by: null, answered_at: null };
+      t.borrows.push(row);
+      await asksDb.saveAsk({ matterId: treasury.matterId(row.id), ask, builderId: null });
+      filed.push({ goal_id: pot.goal_id, borrow_id: row.id, amount_usd: amount });
+    }
+    return filed;
+  };
+  treasuryDb.getBorrow = async (id) => {
+    const b = t.borrows.find((x) => x.id === String(id));
+    return b ? withTitle(b) : null;
+  };
+  // government_031's trigger: a borrow is answered once.
+  treasuryDb.answerBorrow = async ({ id, answer, builderId }) => {
+    const b = t.borrows.find((x) => x.id === String(id) && x.state === 'open');
+    if (!b || !answer) return null;
+    Object.assign(b, { state: answer.state, lent_usd: answer.lent_usd, answer_key: answer.answer_key, answered_by: String(builderId), answered_at: new Date().toISOString() });
+    return { ...b };
+  };
+  treasuryDb.openBorrowRows = async () => {
+    const open = t.borrows.filter((b) => b.state === 'open');
+    const stored = await asksDb.asksFor(open.map((b) => treasury.matterId(b.id)));
+    return open.map((b) => ({ row: withTitle(b), ask: stored.get(treasury.matterId(b.id)) || null }));
+  };
+
+  // Each builder's personal settings (builders.behavior_prefs).
+  const prefs = new Map();
+  const settingsDb = req('modules/builder-settings/db.js');
+  settingsDb.getBuilderBehaviorPrefs = async (id) => JSON.parse(JSON.stringify(prefs.get(String(id)) || {}));
+  settingsDb.setBuilderBehaviorPrefs = async (id, p) => { prefs.set(String(id), JSON.parse(JSON.stringify(p || {}))); return JSON.parse(JSON.stringify(p || {})); };
+  const api = req('src/module-api.js');
+  api.getBuilderById = async (id) => {
+    const b = store.builders.get(String(id));
+    return b ? { id: Number(b.id), rank: b.rank, github_login: b.github_login, display_name: b.display_name, status: b.status } : null;
+  };
+
+  // The blockers (ideas): open ones are the docket's Planning matters.
+  const blockers = req('modules/ideas/blockers.js');
+  const filedBlockers = [];
+  blockers.createBlocker = async ({ title, bodyMd, source, sourceRef }) => {
+    const row = { id: String(++t.seq), title, body_md: bodyMd || '', status: 'open', created_at: new Date().toISOString(), source: source || null, source_ref: sourceRef || null, blocking_task_ids: [] };
+    filedBlockers.push(row);
+    return { ...row };
+  };
+  blockers.getBlocker = async (id) => { const b = filedBlockers.find((x) => x.id === String(id)); return b ? { ...b } : null; };
+  blockers.listOpenBlockers = async () => filedBlockers.filter((b) => b.status === 'open').map((b) => ({ ...b }));
+  blockers.countOpenBlockers = async () => filedBlockers.filter((b) => b.status === 'open').length;
+
+  return { asked, treasury: t, prefs, blockers: filedBlockers };
+}
+
+// ── the walk ────────────────────────────────────────────────────────────────
+
+async function runWalk() {
+  // The constitution is host content: point the instance root at a throwaway folder
+  // BEFORE anything reads it, so a ratified charter is written there (the real
+  // applyBoardAmendment) and never into this checkout.
+  const instanceRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'government-walk-'));
+  process.env.BONGOS_INSTANCE_ROOT = instanceRoot;
+  delete process.env.DATABASE_URL; // the walk never touches a real database
+  // The modules' info lines (a fence switched, a budget set) would bury the table.
+  if (!process.env.LOG_LEVEL) process.env.LOG_LEVEL = 'warn';
+
+  const req = (rel) => require(path.join(ROOT, rel));
+  const api = req('src/module-api.js');
+  const seams = req('src/module-seams.js');
+  const authMod = req('src/bongos/auth.js');
+  const projectSettings = req('src/bongos/project-settings.js');
+  const { attachFail } = req('src/bongos/middleware/error-envelope.js');
+  const catalog = req('modules/government/catalog.js');
+  const govDb = req('modules/government/db.js');
+  const config = req('modules/government/config.js');
+  const board = req('modules/government/board.js');
+  const charter = req('modules/government/charter.js');
+  const membership = req('modules/government/board-membership.js');
+  const dr = req('modules/government/decision-rules.js');
+  const genesis = req('modules/onboarding/genesis-home.js');
+  const autoDb = req('modules/autonomy/db.js');
+  const lifeDb = req('modules/lifecycle/db.js');
+  const doneWhen = req('modules/lifecycle/done-when.js');
+  const doneWhenRoutes = req('modules/lifecycle/routes/done-when.js');
+  const gateRoutes = req('modules/lifecycle/routes/gate-approvals.js');
+  const express = require('express');
+  const http = require('http');
+
+  const { s: store, fns } = makeStore(catalog);
+  installStore(govDb, fns, store.unexpected);
+  // The new machinery's own tables (laws, asks, build-outs, pots), and the rows
+  // other modules keep (a builder's settings, the blockers), in memory too.
+  const side = installSideStores(req, store);
+
+  // Project settings (founding mode + the plan) live in memory.
+  const settings = new Map();
+  projectSettings.getSetting = async (k) => (settings.has(k) ? { key: k, value: settings.get(k) } : null);
+  projectSettings.setSetting = async (k, v) => { settings.set(k, String(v)); return { key: k, value: String(v) }; };
+
+  // What passed matters write into other modules, recorded.
+  const effects = { fence: null, allowedGoals: [], overrides: [], gates: [], criteria: new Map([['9', false]]), budgets: new Map() };
+  autoDb.setFenceEnabled = async ({ enabled }) => { effects.fence = enabled; return { enabled }; };
+  autoDb.allowGoal = async ({ goalId }) => { effects.allowedGoals.push(String(goalId)); return { goal_id: goalId }; };
+  lifeDb.decideOverrideRequest = async ({ requestId, decision }) => { effects.overrides.push([String(requestId), decision]); return {}; };
+  gateRoutes.approveGatePr = async ({ number }) => { effects.gates.push(String(number)); return { ok: true, body: {} }; };
+  doneWhen.getCriterion = async (id) => (effects.criteria.has(String(id)) ? { id, satisfied: effects.criteria.get(String(id)) } : null);
+  doneWhenRoutes.satisfyByOverride = async ({ criterionId }) => { effects.criteria.set(String(criterionId), true); return { updated: {}, goalResult: {} }; };
+
+  // Ports the routers would otherwise reach a database for: the genesis seeder and
+  // the Treasury write. Registered first, so the routers' own registrations step aside.
+  const STAGE_TASK_IDS = { scope: '9001', strategize: '9002', charter: '9003', legalize: '9004', legislation: '9005' };
+  seams.registerProvider('lifecycle.kickoffSeed', {
+    seedGenesis: async () => {
+      for (const [stage, id] of Object.entries(STAGE_TASK_IDS)) store.tasks.set(id, { id, stage, title: `${stage} (walk)`, status: 'ready' });
+      return { seeded: 5 };
+    },
+    genesisTasks: async () => {
+      const out = {};
+      for (const t of store.tasks.values()) (out[t.stage] = out[t.stage] || []).push({ id: t.id, title: t.title, status: t.status });
+      return out;
+    },
+  });
+  seams.registerProvider('reward', {
+    setBuilderMonthlyBudget: async (id, usd) => {
+      if (!store.builders.has(String(id))) return null;
+      effects.budgets.set(String(id), usd);
+      return { id, monthly_budget_usd: usd };
+    },
+  });
+
+  // The session: whoever the request says it is, from this project's people.
+  const asHeader = 'x-walk-builder';
+  const sessionHeader = 'x-walk-session';
+  const fakeBuilder = (r, res, nextFn) => {
+    const b = store.builders.get(String(r.headers[asHeader] || ''));
+    if (!b || b.status !== 'active') return res.status(401).json({ error: { code: 'not_signed_in' } });
+    r.builder = { id: Number(b.id), rank: b.rank, github_login: b.github_login, display_name: b.display_name };
+    // an AI session's CLI token, or a person in the hall (task 1004704's line)
+    r.gdsSession = { source: r.headers[sessionHeader] === 'cli' ? 'cli' : 'web' };
+    return nextFn();
+  };
+  api.requireBuilder = fakeBuilder;
+  authMod.requireBuilder = fakeBuilder;
+
+  const app = express();
+  app.use(express.json());
+  app.use(attachFail);
+  for (const rel of ROUTERS) app.use(req(rel)());
+  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}`;
+
+  async function call(as, method, p, body, session = 'web') {
+    const res = await fetch(`${BASE}${p}`, {
+      method,
+      headers: { [asHeader]: as, [sessionHeader]: session, ...(body === undefined ? {} : { 'content-type': 'application/json' }) },
+      body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    let json = null;
+    try { json = await res.json(); } catch (_) { /* no body */ }
+    return { status: res.status, json };
+  }
+  const code = (r) => (r.json && r.json.error && r.json.error.code) || null;
+  const vote = (as, itemId, direction = 'yes') => call(as, 'POST', `/government/board/items/${itemId}/votes`,
+    direction === 'yes' ? { direction } : { direction, reason_md: 'Not yet: the walk objects.', section_key: 'purpose' });
+  const itemOf = (id) => store.items.find((i) => i.id === String(id)) || null;
+  const constitution = async () => (await call(FOUNDER, 'GET', '/government/constitution')).json;
+  const live = () => config.loadGovernmentConfig().board;
+  const stateOf = (id) => { const i = itemOf(id); return !i ? 'missing' : i.closed_at ? i.outcome : 'open'; };
+
+  // ── the table ──
+  const rows = [];
+  let current = '';
+  const section = (name) => { current = name; };
+  async function check(name, expected, fn) {
+    let got;
+    let pass = false;
+    try {
+      const out = await fn();
+      got = out.got;
+      pass = out.pass === true;
+    } catch (err) {
+      got = `threw: ${err && err.message}`;
+    }
+    const n = rows.filter((r) => r.section === current).length + 1;
+    rows.push({ section: current, key: `${current.split(' ')[0]}${n}`, name, expected, got: String(got), pass });
+    return pass;
+  }
+  const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+
+  // Every voter in `voters` votes; returns the state after each vote.
+  async function voteAll(itemId, voters, direction = 'yes') {
+    const after = [];
+    for (const v of voters) {
+      const r = await vote(v, itemId, direction);
+      after.push(r.status === 201 ? stateOf(itemId) : `${r.status} ${code(r)}`);
+      if (stateOf(itemId) !== 'open') break;
+    }
+    return after;
+  }
+
+  // ── setup: the council and the rank People's acts give ──
+  await call(FOUNDER, 'POST', '/government/ranks', { rank_key: 'council', label: 'Council' });
+  await call(FOUNDER, 'POST', '/government/ranks', { rank_key: 'tester', label: 'Tester' });
+  for (const id of COUNCIL) await call(FOUNDER, 'POST', '/government/assignments', { builder_id: Number(id), rank_key: 'council' });
+
+  // ══ 1. Genesis ══
+  section('G Genesis');
+  const CHOSEN = 'timocratic-republic';
+  await check('The test project is born a Monarchy (the state every genesis starts from)', 'reads as monarchy', async () => {
+    const f = charter.readCharter(live()).form;
+    return { got: `reads as ${f}`, pass: f === 'monarchy' };
+  });
+  await check('Founding starts', '200, stage decide', async () => {
+    const r = await call(FOUNDER, 'POST', '/founding/start');
+    const stage = r.json && r.json.mode && r.json.mode.stage;
+    return { got: `${r.status}, stage ${stage}`, pass: r.status === 200 && stage === 'decide' };
+  });
+  let charterItem = null;
+  await check(`Deciding with ${CHOSEN} saves the plan and files the pick as a charter amendment`, 'plan saved, charter sitting, one vote decides', async () => {
+    const r = await call(FOUNDER, 'POST', '/founding/plan', { government: CHOSEN });
+    const c = (r.json && r.json.charter) || {};
+    charterItem = c.item_id || null;
+    return { got: `${r.status}, charter ${c.state}, one vote decides ${c.one_vote_decides}`, pass: r.status === 200 && c.state === 'sitting' && c.one_vote_decides === true };
+  });
+  await check('Saving the plan moved the project to its first stage', 'stage scope', async () => {
+    const g = await genesis.readGenesis();
+    return { got: `stage ${g && g.stage}`, pass: !!g && g.stage === 'scope' };
+  });
+  await check('The founder\'s one yes ratifies the pick under the Monarchy it is born with', 'passed', async () => {
+    const r = await vote(FOUNDER, charterItem);
+    return { got: `${r.status} ${r.json && r.json.outcome}`, pass: r.status === 201 && r.json.outcome === 'passed' };
+  });
+  await check('The constitution now reads as the government chosen at decide', `reads as ${CHOSEN}, no divergence`, async () => {
+    const c = await constitution();
+    const f = c && c.charter && c.charter.reads_as && c.charter.reads_as.form;
+    return { got: `reads as ${f}, divergence ${c && c.divergence ? 'yes' : 'none'}`, pass: f === CHOSEN && !c.divergence };
+  });
+  await check('A stage with unfinished tasks cannot be put to the board', '409 stage_tasks_unfinished', async () => {
+    const r = await call(FOUNDER, 'POST', '/founding/stages/scope/close');
+    return { got: `${r.status} ${code(r)}`, pass: r.status === 409 && code(r) === 'stage_tasks_unfinished' };
+  });
+  const timocrats = ['42', '43', '44'];
+  for (const stage of genesis.PROPER) {
+    store.tasks.get(STAGE_TASK_IDS[stage]).status = 'shipped';
+    let itemId = null;
+    await check(`${stage}: its finished stage is put to the board`, 'a sitting under the chosen government', async () => {
+      const r = await call(FOUNDER, 'POST', `/founding/stages/${stage}/close`);
+      itemId = r.json && r.json.item_id;
+      const snap = itemId && itemOf(itemId) ? itemOf(itemId).constitution : {};
+      const reads = charter.readCharter(snap).form;
+      return { got: `${r.status}, sitting under ${reads}`, pass: r.status === 200 && !!itemId && reads === CHOSEN };
+    });
+    await check(`${stage}: the founder alone cannot close it; every trusted member's yes does`, 'open, open, passed', async () => {
+      const after = await voteAll(itemId, timocrats);
+      return { got: after.join(', '), pass: same(after, ['open', 'open', 'passed']) };
+    });
+    const nextStage = genesis.PROPER[genesis.PROPER.indexOf(stage) + 1];
+    await check(`${stage}: a pass moves the project on`, nextStage ? `stage ${nextStage}` : 'come-alive door opens', async () => {
+      const g = await genesis.readGenesis();
+      if (nextStage) return { got: `stage ${g && g.stage}`, pass: !!g && g.stage === nextStage };
+      return { got: `can come alive ${g && g.can_come_alive}`, pass: !!g && g.can_come_alive === true };
+    });
+  }
+  await check('The project comes alive', '200, founding over', async () => {
+    const r = await call(FOUNDER, 'POST', '/founding/alive');
+    const g = await genesis.readGenesis();
+    return { got: `${r.status}, founding ${g ? 'still on' : 'over'}`, pass: r.status === 200 && g === null };
+  });
+  await check('Alive, it is still governed by the choice', `reads as ${CHOSEN}`, async () => {
+    const f = charter.readCharter(live()).form;
+    return { got: `reads as ${f}`, pass: f === CHOSEN };
+  });
+
+  // ══ 2. Every form ══
+  section('F Forms');
+  let ideaSeq = 500;
+  // A probe: a Full Idea (by someone who left, so no author rule bends the count)
+  // put to the board in force, voted on to show who may vote and what passes.
+  async function probe() {
+    const id = String(++ideaSeq);
+    store.ideas.set(id, { captured_by: '47', completeness: 80 });
+    const out = await board.openWindowForFullIdea({ ideaId: id, completenessScore: 80 });
+    return out.item.id;
+  }
+  const FORMS = [
+    // key, how to switch, who is seated, the yes-path states, the objection path (voter order + states)
+    { key: 'timocratic-republic', label: 'Timocratic Republic (in force from genesis)', body: null,
+      seated: ['42', '43', '44'], outsider: '45', yes: ['open', 'open', 'passed'], no: { voters: ['43', '42', '44'], dir: ['no', 'yes', 'yes'], states: ['open', 'open', 'returned'] },
+      rule: 'consent: a yes does not end it; full turnout passes; one objection returns it' },
+    { key: 'direct-democracy', label: 'Direct Democracy', body: { form: 'direct-democracy' },
+      seated: ACTIVE_IDS, outsider: null, yes: ['open', 'open', 'open', 'open', 'passed'], no: { voters: ['46', '42', '43', '44', '45'], dir: ['no', 'yes', 'yes', 'yes', 'yes'], states: ['open', 'open', 'open', 'open', 'returned'] },
+      rule: 'consent over every builder' },
+    { key: 'foundation', label: 'Foundation (council rank)', body: { form: 'foundation', council_rank: 'council' }, selfRemoval: true,
+      seated: COUNCIL, outsider: '42', yes: ['open', 'passed'], no: { voters: ['44', '43'], dir: ['no', 'yes'], states: ['open', 'returned'] },
+      rule: 'consent over the council only' },
+    { key: 'custom', label: 'Every builder, majority (no named form)', body: { franchise: 'everyone', pass_rule: 'majority' }, passRule: 'majority',
+      seated: ACTIVE_IDS, outsider: null, yes: ['open', 'open', 'passed'], no: { voters: ['42', '43', '44'], dir: ['no', 'no', 'no'], states: ['open', 'open', 'returned'] },
+      rule: 'majority: 3 of 5 yes carries; 3 of 5 no makes it unreachable' },
+    { key: 'custom', label: 'Every builder, unanimous (no named form)', body: { pass_rule: 'unanimous' }, passRule: 'unanimous',
+      seated: ACTIVE_IDS, outsider: null, yes: ['open', 'open', 'open', 'open', 'passed'], no: { voters: ['43'], dir: ['no'], states: ['returned'] },
+      rule: 'unanimous: one yes does not end it; full turnout passes; one objection returns it at once' },
+    { key: 'monarchy', label: 'Monarchy / BDFL', body: { form: 'monarchy' },
+      seated: ['42'], outsider: '43', yes: ['passed'], no: { voters: ['42'], dir: ['no'], states: ['returned'] },
+      rule: 'first yes: the founder\'s one vote decides' },
+  ];
+  let seatedNow = ['42', '43', '44']; // who sits under the form in force
+  for (const form of FORMS) {
+    const tag = form.label;
+    if (form.body) {
+      let itemId = null;
+      await check(`${tag}: the switch is filed as a charter amendment`, form.selfRemoval ? '409 proposer_would_lose_their_seat, then 201 once acknowledged' : '201', async () => {
+        let r = await call(FOUNDER, 'POST', '/government/board/charter', form.body);
+        let got = `${r.status}`;
+        if (form.selfRemoval) {
+          const first = `${r.status} ${code(r)}`;
+          r = await call(FOUNDER, 'POST', '/government/board/charter', { ...form.body, acknowledge_self_removal: true });
+          got = `${first}, then ${r.status}`;
+          itemId = r.json && r.json.item && r.json.item.id;
+          return { got, pass: first === '409 proposer_would_lose_their_seat' && r.status === 201 && !!itemId };
+        }
+        itemId = r.json && r.json.item && r.json.item.id;
+        return { got, pass: r.status === 201 && !!itemId };
+      });
+      await check(`${tag}: the government in force decides the switch`, 'passed once every seated member has said yes', async () => {
+        const after = await voteAll(itemId, seatedNow);
+        return { got: after.join(', '), pass: after[after.length - 1] === 'passed' };
+      });
+    }
+    await check(`${tag}: the constitution reads as it`, form.key === 'custom' ? `reads as Custom, pass rule ${form.passRule}` : `reads as ${form.key}`, async () => {
+      const c = await constitution();
+      const ra = (c && c.charter && c.charter.reads_as) || {};
+      const ok = ra.form === form.key && (!form.passRule || ra.pass_rule === form.passRule) && !c.divergence;
+      return { got: `reads as ${ra.form === 'custom' ? 'Custom' : ra.form}${form.passRule ? `, pass rule ${ra.pass_rule}` : ''}${c.divergence ? ', DIVERGES' : ''}`, pass: ok };
+    });
+    await check(`${tag}: who is seated`, `builders ${form.seated.join(', ')}`, async () => {
+      const members = (await membership.resolveBoardMembers(live())).map((m) => String(m.builder_id));
+      return { got: `builders ${members.join(', ') || 'none'}`, pass: same(members, form.seated) };
+    });
+    if (form.outsider) {
+      await check(`${tag}: someone not seated cannot vote`, '403 not_board_member', async () => {
+        const id = await probe();
+        const r = await vote(form.outsider, id);
+        await voteAll(id, form.seated, 'no'); // close the probe: the walk leaves no sitting open
+        return { got: `${r.status} ${code(r)}`, pass: r.status === 403 && code(r) === 'not_board_member' };
+      });
+    }
+    await check(`${tag}: what passes (${form.rule})`, form.yes.join(', '), async () => {
+      const id = await probe();
+      const after = await voteAll(id, form.seated);
+      return { got: after.join(', '), pass: same(after, form.yes) };
+    });
+    await check(`${tag}: what returns`, form.no.states.join(', '), async () => {
+      const id = await probe();
+      const after = [];
+      for (let k = 0; k < form.no.voters.length; k += 1) {
+        const r = await vote(form.no.voters[k], id, form.no.dir[k]);
+        after.push(r.status === 201 ? stateOf(id) : `${r.status} ${code(r)}`);
+        if (stateOf(id) !== 'open') break;
+      }
+      return { got: after.join(', '), pass: same(after, form.no.states) };
+    });
+    seatedNow = form.seated;
+  }
+
+  // ══ 3. Every building ══
+  section('B Buildings');
+  // Who decides at a building is changed by an amendment, decided here under the
+  // Monarchy the walk restored: the founder's one yes.
+  async function setRules(rules) {
+    const r = await call(FOUNDER, 'POST', '/government/board/decision-rules', { rules });
+    const itemId = r.json && r.json.item && r.json.item.id;
+    if (r.status !== 201 || !itemId) return { ok: false, why: `${r.status} ${code(r)}` };
+    const v = await vote(FOUNDER, itemId);
+    return { ok: v.status === 201 && v.json.outcome === 'passed', why: `vote ${v.status} ${v.json && v.json.outcome}` };
+  }
+  const rowOf = async (area) => {
+    const c = await constitution();
+    return ((c.decision_rules && c.decision_rules.areas) || []).find((a) => a.area === area) || {};
+  };
+  for (const area of dr.AREAS.filter((a) => a.acts.length)) {
+    await check(`${area.name}: set to decide by vote (council, majority) by a passed amendment`, 'sitting, majority vote', async () => {
+      const out = await setRules([{ area: area.key, decided_by: 'rank:council', rule: 'majority' }]);
+      const row = await rowOf(area.key);
+      return { got: `${out.ok ? 'passed' : out.why}; ${row.sitting ? 'sitting' : 'as today'}, ${row.rule_words}`, pass: out.ok && row.sitting === true && row.rule === 'majority' };
+    });
+    for (const act of area.acts) {
+      await check(`${area.name}: acting alone on ${act} is refused`, `409 decided_by_sitting (${area.key})`, async () => {
+        const [method, p, body] = REQUESTS[act];
+        const r = await call(FOUNDER, method, p, body);
+        const d = (r.json && r.json.error && (r.json.error.details || r.json.error)) || {};
+        return { got: `${r.status} ${code(r)} (${d.area})`, pass: r.status === 409 && code(r) === 'decided_by_sitting' && d.area === area.key };
+      });
+    }
+    await check(`${area.name}: restored to as today, every one of its ${area.acts.length} routes reaches its own handler again`, 'none refused', async () => {
+      const out = await setRules([{ area: area.key, decided_by: 'gate' }]);
+      const bad = [];
+      for (const act of area.acts) {
+        const [method, p, body] = REQUESTS[act];
+        const r = await call(FOUNDER, method, p, body);
+        const reached = act.includes('/government/assignments') ? r.status < 300 : (r.status >= 400 && r.status < 500 && r.status !== 403 && code(r) !== 'decided_by_sitting');
+        if (!reached) bad.push(`${act} ${r.status} ${code(r)}`);
+      }
+      return { got: `${out.ok ? 'restored' : out.why}; ${bad.length ? bad.join('; ') : 'none refused'}`, pass: out.ok && bad.length === 0 };
+    });
+  }
+
+  // ══ 4. Every matter action ══
+  section('M Matters');
+  const SITTINGS = {
+    people: 'consent', automation: 'majority', release: 'unanimous', review: 'signoff', treasury: 'first',
+  };
+  await check('Each acting building is put to the council by one passed amendment', Object.entries(SITTINGS).map(([a, r]) => `${a} ${r}`).join(', '), async () => {
+    const out = await setRules(Object.entries(SITTINGS).map(([area, rule]) => ({ area, decided_by: 'rank:council', rule })));
+    const got = [];
+    for (const area of Object.keys(SITTINGS)) got.push(`${area} ${(await rowOf(area)).rule}`);
+    return { got: `${out.ok ? '' : `${out.why}; `}${got.join(', ')}`, pass: out.ok && same(got, Object.entries(SITTINGS).map(([a, r]) => `${a} ${r}`)) };
+  });
+  // Open a matter as the founder (not on the council), pass it with council votes.
+  async function passMatter(area, title, action, voters = COUNCIL, direction = 'yes') {
+    const r = await call(FOUNDER, 'POST', '/government/board/matters', { area, title, action });
+    const itemId = r.json && r.json.item && r.json.item.id;
+    if (r.status !== 201 || !itemId) return { outcome: `not opened: ${r.status} ${code(r)}` };
+    const after = await voteAll(itemId, voters, direction);
+    return { outcome: stateOf(itemId), after };
+  }
+  const holds = (id, rank) => store.assignments.some((a) => a.builder_id === id && a.rank_key === rank);
+  // Did the act happen? One observation per matter action in MATTER_PLAN.
+  const HAPPENED = {
+    'people.assign_rank': () => holds('46', 'tester'),
+    'people.unassign_rank': () => !holds('46', 'tester'),
+    'people.appoint_lead': () => store.leads.some((l) => l.building === 'planning' && l.builder_id === '45' && !l.removed_at),
+    'people.remove_lead': () => !store.leads.some((l) => l.building === 'planning' && !l.removed_at),
+    'automation.switch_on': () => effects.fence === true,
+    'automation.switch_off': () => effects.fence === false,
+    'automation.allow_goal': () => effects.allowedGoals.includes('77'),
+    'release.approve_override': () => effects.overrides.some(([id, d]) => id === '5' && d === 'approve'),
+    'release.approve_gate': () => effects.gates.includes('1500'),
+    'review.satisfy_criterion': () => effects.criteria.get('9') === true,
+    'treasury.set_budget': () => effects.budgets.get('45') === 50,
+  };
+  const MATTERS = MATTER_PLAN.map(([area, title, action, effect]) => [area, title, action, effect, HAPPENED[`${area}.${action.type}`]]);
+  // How each building's sitting closes as Ben then Cy say yes, under its rule: the
+  // two-member consent, majority and unanimous sittings need both; first yes and
+  // sign-off (by someone who did not propose it) close on the first.
+  const CLOSES = { people: 'open, passed', automation: 'open, passed', release: 'open, passed', review: 'passed', treasury: 'passed' };
+  await check('Someone the building\'s row does not seat cannot vote on its matter', '403 not_board_member', async () => {
+    const r = await call(FOUNDER, 'POST', '/government/board/matters', { area: 'automation', title: 'Who may vote here?' });
+    const itemId = r.json && r.json.item && r.json.item.id;
+    const v = await vote(FOUNDER, itemId);
+    await voteAll(itemId, COUNCIL, 'no'); // close the probe so it carries out nothing
+    return { got: `${r.status}, then ${v.status} ${code(v)}`, pass: r.status === 201 && v.status === 403 && code(v) === 'not_board_member' };
+  });
+  for (const [area, title, action, effect, happened] of MATTERS) {
+    await check(`${area} ${action.type}: "${title}" passes under ${SITTINGS[area]} and is carried out`, `${CLOSES[area]}; ${effect}`, async () => {
+      const out = await passMatter(area, title, action);
+      const done = happened();
+      const steps = out.after ? out.after.join(', ') : out.outcome;
+      return { got: `${steps}; ${done ? effect : `NOT ${effect}`}`, pass: out.outcome === 'passed' && steps === CLOSES[area] && done };
+    });
+  }
+  await check('A returned matter carries out nothing', 'returned; fence unchanged', async () => {
+    const before = effects.fence;
+    const out = await passMatter('automation', 'Switch it on again', { type: 'switch_on' }, COUNCIL, 'no');
+    return { got: `${out.outcome}; fence ${effects.fence === before ? 'unchanged' : 'CHANGED'}`, pass: out.outcome === 'returned' && effects.fence === before };
+  });
+  await check('Every building restored to as today', 'all as today', async () => {
+    const out = await setRules(Object.keys(SITTINGS).map((area) => ({ area, decided_by: 'gate' })));
+    const c = await constitution();
+    const sitting = c.decision_rules.areas.filter((a) => a.sitting).map((a) => a.area);
+    return { got: `${out.ok ? '' : `${out.why}; `}${sitting.length ? `still sitting: ${sitting.join(', ')}` : 'all as today'}`, pass: out.ok && sitting.length === 0 };
+  });
+
+  // ══ 5–9. The new machinery (task 1004719) ══
+  await walkNewMachinery({ call, code, vote, voteAll, check, section, stateOf, store, side, req });
+
+  // Any storage the fake did not model is a finding about the walk itself.
+  section('S Store');
+  await check('No code path reached storage the walk does not model', 'none', async () => {
+    const u = [...new Set(store.unexpected)];
+    return { got: u.length ? u.join(', ') : 'none', pass: u.length === 0 };
+  });
+
+  await new Promise((r) => server.close(r));
+  try { fs.rmSync(instanceRoot, { recursive: true, force: true }); } catch (_) { /* best effort */ }
+  return { mode: 'in-memory', rows };
+}
+
+// ── the new machinery (task 1004719) ────────────────────────────────────────
+//
+// Laws and presets, Leads and build-outs, asks and routing, the treasury, and
+// positions with the counts, walked on the same throwaway project after section
+// 4 left it a Monarchy with every building decided as today. Everything it
+// puts up it takes down again: no law, Lead, pot or open borrow survives it.
+
+// A card in the one ask shape (asks.js), and a wall of text that is not one.
+const GOOD_ASK = Object.freeze({
+  question: 'Ship the walk table today?',
+  options: [
+    { key: 'ship', label: 'Ship it', result: 'The table lands today.' },
+    { key: 'wait', label: 'Wait a day', result: 'It lands tomorrow instead.' },
+  ],
+  recommend: { key: 'ship', why: 'Every row of it passes.' },
+  waits_on: 'lead:planning',
+  if_nobody_answers: 'It ships tomorrow as planned.',
+});
+const SLOP_ASK = Object.freeze({
+  question: 'I have been looking into this for a while and wanted to check with you about what we should do about the walk table and whether it is ready?',
+  options: [{ key: 'ok', label: 'ok', result: 'ok' }],
+  recommend: { key: 'maybe', why: '' },
+  waits_on: 'someone',
+  if_nobody_answers: '',
+});
+// A law that locks a personal setting: every agent answers short.
+const SHORT_LAW = Object.freeze({ text: 'Answer in plain, short words', effect_on_ai: 'Replies lead with the answer and stop.', locks: [{ setting: 'verbosity', value: 'concise' }] });
+
+async function walkNewMachinery({ call, code, vote, voteAll, check, section, stateOf, store, side, req }) {
+  const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+  const FOUNDER_ID = '42';
+  const BEN = '43';
+  const CY = '44';
+  const EVE = '46';
+  const positionsPort = () => req('src/module-seams.js').resolveOptional('government');
+  const GovPositions = req('modules/hall-ui/public/gov-positions.js');
+  const GovLiving = req('modules/hall-ui/public/gov-living.js');
+  const treasuryMod = req('modules/government/treasury.js');
+  const sweep = req('modules/government/pollers/treasury-borrow.js');
+  const lawsInForce = async () => (await call(FOUNDER_ID, 'GET', '/government/laws')).json;
+  const itemIdOf = (r) => r.json && r.json.item && r.json.item.id;
+
+  // ══ 5. Laws and strictness presets ══
+  section('L Laws');
+  let lawItem = null;
+  await check('Before any law the book is empty and no session is handed a laws block', '0 in force; no laws block', async () => {
+    const book = await lawsInForce();
+    const s = await positionsPort().lawsForSession();
+    return { got: `${book.in_force} in force; ${s.inject ? 'a laws block' : 'no laws block'}`, pass: book.in_force === 0 && s.inject === false };
+  });
+  await check('A law is proposed: filed as a laws amendment, and proposing writes nothing', '201, sitting open; still 0 in force', async () => {
+    const r = await call(FOUNDER_ID, 'POST', '/government/board/laws', { enact: [SHORT_LAW] });
+    lawItem = itemIdOf(r);
+    const book = await lawsInForce();
+    return { got: `${r.status}, sitting ${stateOf(lawItem)}; still ${book.in_force} in force`, pass: r.status === 201 && stateOf(lawItem) === 'open' && book.in_force === 0 };
+  });
+  await check('Someone the board does not seat cannot pass it', '403 not_board_member', async () => {
+    const r = await vote(BEN, lawItem);
+    return { got: `${r.status} ${code(r)}`, pass: r.status === 403 && code(r) === 'not_board_member' };
+  });
+  let lawId = null;
+  await check('The government in force passes it, and the law book names the vote', 'passed; 1 in force, passed under Monarchy / BDFL with yes from ada', async () => {
+    const v = await vote(FOUNDER_ID, lawItem);
+    const book = await lawsInForce();
+    const law = (book.laws || [])[0] || {};
+    lawId = law.id || null;
+    const pb = law.passed_by || {};
+    const yes = (pb.yes || []).map((x) => (x && (x.login || x.github_login)) || String(x && x.id));
+    const ok = v.json && v.json.outcome === 'passed' && book.in_force === 1 && law.text === SHORT_LAW.text;
+    return { got: `${v.json && v.json.outcome}; ${book.in_force} in force${ok ? `, passed under ${pb.government} with yes from ${yes.join(', ') || 'nobody'}` : ''}`, pass: ok && pb.government === 'Monarchy / BDFL' && same(yes, ['ada']) };
+  });
+  await check('Every AI session is handed the law, with its lock, ahead of its own settings', 'a laws block naming the law and "verbosity is fixed at concise"', async () => {
+    const s = await positionsPort().lawsForSession();
+    const ok = s.inject === true && s.contract.includes(SHORT_LAW.text) && s.contract.includes('verbosity is fixed at concise');
+    return { got: ok ? 'a laws block naming the law and "verbosity is fixed at concise"' : `inject ${s.inject}: ${s.contract.slice(0, 80)}`, pass: ok };
+  });
+  await check('The lock bites on a write: a builder cannot set what the law forbids', '409 locked_by_law', async () => {
+    const r = await call(BEN, 'PATCH', '/me/interaction', { verbosity: 'detailed' });
+    return { got: `${r.status} ${code(r)}`, pass: r.status === 409 && code(r) === 'locked_by_law' };
+  });
+  await check('The lock bites on a read: a value stored before the law reads as the law says', 'stored detailed, reads concise', async () => {
+    side.prefs.set(CY, { interaction: { verbosity: 'detailed' } });
+    const r = await call(CY, 'GET', '/me/interaction');
+    const eff = r.json && (r.json.effective ? r.json.effective.verbosity : r.json.verbosity);
+    return { got: `stored detailed, reads ${eff}`, pass: r.status === 200 && eff === 'concise' };
+  });
+  await check('A value the law allows still saves', '200', async () => {
+    const r = await call(BEN, 'PATCH', '/me/interaction', { verbosity: 'concise' });
+    return { got: `${r.status}`, pass: r.status === 200 };
+  });
+  await check('Repealed by a vote, the law leaves every session and unlocks the setting', 'passed; 0 in force; no laws block; 200', async () => {
+    const r = await call(FOUNDER_ID, 'POST', '/government/board/laws', { repeal: [lawId] });
+    const v = await vote(FOUNDER_ID, itemIdOf(r));
+    const book = await lawsInForce();
+    const s = await positionsPort().lawsForSession();
+    const w = await call(BEN, 'PATCH', '/me/interaction', { verbosity: 'detailed' });
+    return { got: `${v.json && v.json.outcome}; ${book.in_force} in force; ${s.inject ? 'a laws block' : 'no laws block'}; ${w.status}`, pass: v.json && v.json.outcome === 'passed' && book.in_force === 0 && !s.inject && w.status === 200 };
+  });
+  const presetNow = async () => (await call(FOUNDER_ID, 'GET', '/government/presets')).json;
+  await check('With no laws, no strictness preset is in force', 'none', async () => {
+    const p = await presetNow();
+    return { got: p.current || 'none', pass: p.current == null };
+  });
+  // [to, from, what an exploratory wandering write answers once it is in force]
+  for (const [key, from, wander] of [['guild', 'none', '409 locked_by_law'], ['factory', 'guild', '409 locked_by_law'], ['open', 'factory', '200']]) {
+    await check(`Strictness: ${from} to ${key} is one vote, and its locks bite`, `one sitting; passed; ${key} in force; exploratory wandering ${wander}`, async () => {
+      const r = await call(FOUNDER_ID, 'POST', '/government/board/presets', { preset: key });
+      const id = itemIdOf(r);
+      const v = await vote(FOUNDER_ID, id);
+      const p = await presetNow();
+      const w = await call(BEN, 'PATCH', '/me/wandering', { wandering: 3 });
+      const ws = `${w.status}${w.status === 200 ? '' : ` ${code(w)}`}`;
+      return { got: `${r.status === 201 && id ? 'one sitting' : `${r.status} ${code(r)}`}; ${v.json && v.json.outcome}; ${p.current || 'none'} in force; exploratory wandering ${ws}`, pass: r.status === 201 && v.json && v.json.outcome === 'passed' && p.current === key && ws === wander };
+    });
+  }
+  await check('Every preset law is repealed by one more vote, so the book ends empty', 'passed; 0 in force; no preset', async () => {
+    const ids = ((await lawsInForce()).laws || []).map((l) => l.id);
+    const r = await call(FOUNDER_ID, 'POST', '/government/board/laws', { repeal: ids });
+    const v = await vote(FOUNDER_ID, itemIdOf(r));
+    const book = await lawsInForce();
+    const p = await presetNow();
+    return { got: `${v.json && v.json.outcome}; ${book.in_force} in force; ${p.current ? `${p.current} in force` : 'no preset'}`, pass: book.in_force === 0 && p.current == null };
+  });
+
+  // ══ 6. Leads and build-outs ══
+  section('D Leads');
+  const leads = async () => (await call(FOUNDER_ID, 'GET', '/government/leads')).json;
+  const building = async (key) => ((await leads()).buildings || []).find((b) => b.building === key) || {};
+  await check('Ben is appointed Planning\'s Lead by a People vote', 'passed; Planning led by ben, by that vote', async () => {
+    const r = await call(FOUNDER_ID, 'POST', '/government/board/matters', { area: 'people', title: 'Ben leads Planning', action: { type: 'appoint_lead', building: 'planning', builder_id: Number(BEN), charter: 'Goals, priorities and the order of work.' } });
+    const id = itemIdOf(r);
+    const v = await vote(FOUNDER_ID, id);
+    const p = await building('planning');
+    const lead = p.lead || {};
+    const by = lead.appointed_by && (lead.appointed_by.item_id || lead.appointed_by.id);
+    const login = lead.builder && (lead.builder.login || lead.builder.github_login);
+    return { got: `${v.json && v.json.outcome}; Planning led by ${login || 'nobody'}${String(by) === String(id) ? ', by that vote' : ''}`, pass: v.json && v.json.outcome === 'passed' && login === 'ben' && String(by) === String(id) };
+  });
+  await check('An unseated building answers to the owner', 'Rules answers to the owner: builder 42', async () => {
+    const a = (await building('rules')).answers || {};
+    return { got: `Rules answers to ${a.fell_to_owner ? 'the owner' : a.label}: builder ${(a.builder_ids || []).join(', ')}`, pass: a.fell_to_owner === true && same(a.builder_ids, [FOUNDER_ID]) };
+  });
+  await check('Someone who does not hold Planning cannot grow it', '403 not_the_holder', async () => {
+    const r = await call(CY, 'POST', '/government/buildouts', { building: 'planning', capsule: 'committee', name: 'Not mine' });
+    return { got: `${r.status} ${code(r)}`, pass: r.status === 403 && code(r) === 'not_the_holder' };
+  });
+  await check('A district always goes to a vote, even under a Monarchy', 'vote (city); returned, nothing built', async () => {
+    const before = store.buildouts.length;
+    const r = await call(BEN, 'POST', '/government/buildouts', { building: 'planning', capsule: 'district', name: 'Planning quarter' });
+    const id = itemIdOf(r);
+    if (id) await vote(FOUNDER_ID, id, 'no');
+    return { got: `${r.json && r.json.path} (${r.json && r.json.rights && r.json.rights.ground}); ${stateOf(id)}, ${store.buildouts.length === before ? 'nothing built' : 'BUILT'}`, pass: r.status === 201 && r.json.path === 'vote' && stateOf(id) === 'returned' && store.buildouts.length === before };
+  });
+  // Under each form, what the form says Planning's Lead may build without a vote:
+  // [label, the switch (null: in force already), who sits once it is in force, the path].
+  const BUILD_FORMS = [
+    ['Monarchy / BDFL', null, [FOUNDER_ID], 'at_once'],
+    ['Timocratic Republic (the Lead sits on the board)', { form: 'timocratic-republic' }, [FOUNDER_ID, BEN, CY], 'at_once'],
+    ['Direct Democracy', { form: 'direct-democracy' }, ACTIVE_IDS, 'vote'],
+    ['Foundation (council rank)', { form: 'foundation', council_rank: 'council', acknowledge_self_removal: true }, COUNCIL, 'vote'],
+  ];
+  let seated = [FOUNDER_ID];
+  for (const [label, body, seats, want] of BUILD_FORMS) {
+    if (body) {
+      const r = await call(FOUNDER_ID, 'POST', '/government/board/charter', body);
+      await voteAll(itemIdOf(r), seated);
+      seated = seats;
+    }
+    await check(`${label}: Planning's Lead adds a committee room`, want === 'at_once' ? 'rights at once (form); built at once' : 'rights a vote (form); filed as a vote, which passed and built it', async () => {
+      const rights = (((await building('planning')).build_rights || {}).capsules || {}).committee || {};
+      const r = await call(BEN, 'POST', '/government/buildouts', { building: 'planning', capsule: 'committee', name: `${label.split(' ')[0]} room` });
+      const took = r.json && r.json.path;
+      let got = `rights ${rights.without_vote ? 'at once' : 'a vote'} (${rights.ground}); `;
+      let built = false;
+      if (took === 'at_once') {
+        built = !!(r.json.buildout && r.json.buildout.ground === 'form');
+        got += built ? 'built at once' : 'NOT built';
+      } else if (took === 'vote') {
+        const id = itemIdOf(r);
+        await voteAll(id, seated);
+        built = store.buildouts.some((o) => o.authorised_by_item_id === String(id));
+        got += `filed as a vote, which ${stateOf(id)}${built ? ' and built it' : ''}`;
+      } else got += `${r.status} ${code(r)}`;
+      return { got, pass: took === want && rights.without_vote === (want === 'at_once') && rights.ground === 'form' && built };
+    });
+  }
+  // back to the Monarchy the rest of the walk runs under
+  {
+    const r = await call(FOUNDER_ID, 'POST', '/government/board/charter', { form: 'monarchy' });
+    await voteAll(itemIdOf(r), seated);
+  }
+  await check('Back under a Monarchy, the build-outs stand on the record with what allowed each', '2 at once (form), 2 by a vote', async () => {
+    const mine = store.buildouts.filter((o) => o.building === 'planning');
+    const atOnce = mine.filter((o) => !o.authorised_by_item_id && o.ground === 'form').length;
+    const voted = mine.filter((o) => o.authorised_by_item_id).length;
+    const form = charterForm(req);
+    return { got: `${atOnce} at once (form), ${voted} by a vote${form === 'monarchy' ? '' : `; form ${form}`}`, pass: atOnce === 2 && voted === 2 && form === 'monarchy' };
+  });
+
+  // ══ 7. Asks and routing ══
+  section('A Asks');
+  await check('A slop ask is refused, every fix named, nothing stored', '400 ask_refused', async () => {
+    const before = side.asked.size;
+    const r = await call(BEN, 'POST', '/government/asks/check', SLOP_ASK, 'cli');
+    const n = (((r.json || {}).error || {}).details || {}).errors;
+    return { got: `${r.status} ${code(r)}${Array.isArray(n) && n.length ? '' : ' (no fixes named)'}${side.asked.size === before ? '' : ', STORED'}`, pass: r.status === 400 && code(r) === 'ask_refused' && Array.isArray(n) && n.length > 0 && side.asked.size === before };
+  });
+  await check('A card in the ask shape passes the check', '200 ok', async () => {
+    const r = await call(BEN, 'POST', '/government/asks/check', GOOD_ASK, 'cli');
+    return { got: `${r.status} ${r.json && r.json.ok ? 'ok' : code(r)}`, pass: r.status === 200 && r.json.ok === true };
+  });
+  await check('An AI session filing a blocker without an ask is refused, and nothing is filed', '400 ask_required; no blocker', async () => {
+    const before = side.blockers.length;
+    const r = await call(CY, 'POST', '/blockers', { title: 'Walk needs a decision', body_md: 'A long explanation.' }, 'cli');
+    return { got: `${r.status} ${code(r)}; ${side.blockers.length === before ? 'no blocker' : 'FILED'}`, pass: r.status === 400 && code(r) === 'ask_required' && side.blockers.length === before };
+  });
+  await check('A slop ask on a blocker files nothing', '400 ask_refused; no blocker', async () => {
+    const before = side.blockers.length;
+    const r = await call(CY, 'POST', '/blockers', { title: 'Walk needs a decision', ask: SLOP_ASK }, 'cli');
+    return { got: `${r.status} ${code(r)}; ${side.blockers.length === before ? 'no blocker' : 'FILED'}`, pass: r.status === 400 && code(r) === 'ask_refused' && side.blockers.length === before };
+  });
+  let matter = null;
+  await check('With an ask, the AI session\'s blocker is filed and carries its card', '201; the blocker reads back with its question', async () => {
+    const r = await call(CY, 'POST', '/blockers', { title: 'Walk needs a decision', ask: GOOD_ASK }, 'cli');
+    const id = r.json && r.json.blocker && r.json.blocker.id;
+    matter = id ? `blockers:${id}` : null;
+    const back = await call(CY, 'GET', `/blockers/${id}`);
+    const q = back.json && back.json.blocker && back.json.blocker.ask && back.json.blocker.ask.question;
+    return { got: `${r.status}; ${q === GOOD_ASK.question ? 'the blocker reads back with its question' : `read back ${q}`}`, pass: r.status === 201 && q === GOOD_ASK.question };
+  });
+  const routeFor = async (as) => {
+    const d = (await call(as, 'GET', '/government/docket')).json || {};
+    const m = (d.matters || []).find((x) => x.id === matter) || null;
+    return { d, m, route: (m && m.route) || {} };
+  };
+  await check('Routed to its seat: the ask waits on Planning\'s Lead, and is on Ben, not the owner', 'routed; the Planning Lead; Ben yes, founder no', async () => {
+    const ben = await routeFor(BEN);
+    const ada = await routeFor(FOUNDER_ID);
+    return { got: `${ben.d.routed ? 'routed' : 'NOT routed'}; ${ben.route.label}; Ben ${ben.route.yours ? 'yes' : 'no'}, founder ${ada.route.yours ? 'yes' : 'no'}`, pass: ben.d.routed === true && ben.route.seat === 'lead:planning' && ben.route.yours === true && ada.route.yours === false };
+  });
+  await check('Only whoever it waits on may pass it on', '403 not_yours', async () => {
+    const r = await call(FOUNDER_ID, 'POST', `/government/asks/${matter}/pass`, { seat: 'owner' });
+    return { got: `${r.status} ${code(r)}`, pass: r.status === 403 && code(r) === 'not_yours' };
+  });
+  await check('Ben passes it on to the owner: word for word, it leaves Ben and lands on the founder', '200; same question; Ben no, founder yes', async () => {
+    const r = await call(BEN, 'POST', `/government/asks/${matter}/pass`, { seat: 'owner' });
+    const ben = await routeFor(BEN);
+    const ada = await routeFor(FOUNDER_ID);
+    const kept = r.json && r.json.ask && r.json.ask.question === GOOD_ASK.question;
+    return { got: `${r.status}; ${kept ? 'same question' : 'CHANGED'}; Ben ${ben.route.yours ? 'yes' : 'no'}, founder ${ada.route.yours ? 'yes' : 'no'}`, pass: r.status === 200 && kept && ben.route.yours === false && ada.route.yours === true };
+  });
+  await check('The counts agree: GET /government/counts, the docket and the hall all say what is on each of them', 'founder 1 to do, Ben 0 to do; the hall reads the same', async () => {
+    const out = [];
+    let ok = true;
+    for (const [who, want] of [[FOUNDER_ID, 1], [BEN, 0]]) {
+      const c = (await call(who, 'GET', '/government/counts')).json || {};
+      const d = (await call(who, 'GET', '/government/docket')).json || {};
+      const me = { builder: { id: Number(who), rank: store.builders.get(who).rank } };
+      const hallServed = GovLiving.countsOf(GovLiving.livingModel({ counts: c, me, now: Date.now() }));
+      const hallDocket = GovLiving.countsOf(GovLiving.livingModel({ docket: d, me, now: Date.now() }));
+      const docketYours = (d.counts && d.counts.yours);
+      const agree = c.on_you === want && docketYours === want && hallServed.on_you === want && hallDocket.on_you === want;
+      ok = ok && agree;
+      out.push(agree ? `${who === FOUNDER_ID ? 'founder' : 'Ben'} ${want} to do` : `${who}: counts ${c.on_you}, docket ${docketYours}, hall ${hallServed.on_you}/${hallDocket.on_you}`);
+    }
+    return { got: `${out.join(', ')}${ok ? '; the hall reads the same' : ''}`, pass: ok };
+  });
+
+  // ══ 8. The treasury ══
+  section('T Treasury');
+  const treasuryAs = async (as) => (await call(as, 'GET', '/government/treasury')).json || {};
+  await check('No pots, no spend limit, and the unseated Treasury answers to the owner', '0 pots; limit off; owner seat, not Eve\'s', async () => {
+    const t = await treasuryAs(EVE);
+    const a = t.answers || {};
+    return { got: `${(t.pots || []).length} pots; limit ${t.cap && t.cap.on ? 'ON' : 'off'}; ${a.fell_to_owner ? 'owner seat' : a.label}, ${a.yours ? 'Eve\'s' : 'not Eve\'s'}`, pass: (t.pots || []).length === 0 && t.cap && t.cap.on === false && a.fell_to_owner === true && a.yours === false };
+  });
+  await check('Someone who does not answer for the Treasury cannot give a goal a pot', '403 not_the_holder', async () => {
+    const r = await call(EVE, 'PUT', `/government/treasury/pots/${WALK_GOAL}`, { budget_usd: 100 });
+    return { got: `${r.status} ${code(r)}`, pass: r.status === 403 && code(r) === 'not_the_holder' };
+  });
+  await check('The owner gives the walk goal a $100 pot', '200, $100', async () => {
+    const r = await call(FOUNDER_ID, 'PUT', `/government/treasury/pots/${WALK_GOAL}`, { budget_usd: 100 });
+    return { got: `${r.status}, $${r.json && r.json.pot && r.json.pot.budget_usd}`, pass: r.status === 200 && r.json.pot.budget_usd === 100 };
+  });
+  await check('Spending $150 on it runs the pot dry', 'dry, $50 over', async () => {
+    side.treasury.spend.set(WALK_GOAL, 150);
+    const pot = ((await treasuryAs(FOUNDER_ID)).pots || [])[0] || {};
+    return { got: `${pot.dry ? 'dry' : 'not dry'}, $${-pot.left_usd} over`, pass: pot.dry === true && pot.left_usd === -50 };
+  });
+  let borrow = null;
+  await check('The sweep files one borrow from the reserve, its ask waiting on the Treasury; a second sweep files none', 'filed 1 for $250, waiting on lead:treasury; then 0', async () => {
+    const first = await sweep.runSweep({ now: () => TREASURY_NOW, log: () => {}, error: () => {} });
+    borrow = side.treasury.borrows[0] || null;
+    const ask = borrow ? side.asked.get(treasuryMod.matterId(borrow.id)) : null;
+    const second = await sweep.runSweep({ now: () => TREASURY_NOW, log: () => {}, error: () => {} });
+    return { got: `filed ${first.filed}${borrow ? ` for $${borrow.amount_usd}` : ''}, waiting on ${ask ? ask.waits_on : 'nothing'}; then ${second.filed}`, pass: first.filed === 1 && !!ask && ask.waits_on === 'lead:treasury' && second.filed === 0 };
+  });
+  await check('The borrow is on the owner\'s to-do, and only waits on others for Eve', 'founder: to do; Eve: on others', async () => {
+    const mid = borrow && treasuryMod.matterId(borrow.id);
+    const a = (await call(FOUNDER_ID, 'GET', '/government/counts')).json || {};
+    const e = (await call(EVE, 'GET', '/government/counts')).json || {};
+    const where = (c) => ((c.yours || []).includes(mid) ? 'to do' : (c.others || []).includes(mid) ? 'on others' : 'absent');
+    return { got: `founder: ${where(a)}; Eve: ${where(e)}`, pass: where(a) === 'to do' && where(e) === 'on others' };
+  });
+  await check('Someone it does not wait on cannot answer the borrow', '403 not_yours', async () => {
+    const r = await call(EVE, 'POST', `/government/treasury/borrows/${borrow && borrow.id}/answer`, { key: 'lend' });
+    return { got: `${r.status} ${code(r)}`, pass: r.status === 403 && code(r) === 'not_yours' };
+  });
+  await check('The owner lends it all: the pot refills; a second answer is refused', '200 lent $250; pot not dry; then 409 already_answered', async () => {
+    const r = await call(FOUNDER_ID, 'POST', `/government/treasury/borrows/${borrow && borrow.id}/answer`, { key: 'lend' });
+    const pot = ((await treasuryAs(FOUNDER_ID)).pots || [])[0] || {};
+    const again = await call(FOUNDER_ID, 'POST', `/government/treasury/borrows/${borrow && borrow.id}/answer`, { key: 'no' });
+    const b = (r.json && r.json.borrow) || {};
+    return { got: `${r.status} ${b.state} $${b.lent_usd}; pot ${pot.dry ? 'dry' : 'not dry'}; then ${again.status} ${code(again)}`, pass: r.status === 200 && b.state === 'lent' && b.lent_usd === 250 && pot.dry === false && again.status === 409 && code(again) === 'already_answered' };
+  });
+  await check('The pot is taken away again', '200 removed; 0 pots', async () => {
+    const r = await call(FOUNDER_ID, 'PUT', `/government/treasury/pots/${WALK_GOAL}`, { budget_usd: null });
+    const t = await treasuryAs(FOUNDER_ID);
+    return { got: `${r.status} ${r.json && r.json.removed ? 'removed' : 'KEPT'}; ${(t.pots || []).length} pots`, pass: r.status === 200 && r.json.removed === true && (t.pots || []).length === 0 };
+  });
+
+  // ══ 9. Positions and the governing tabs ══
+  section('P Positions');
+  const SHELL = fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'shell.js'), 'utf8');
+  const cityGated = /\{ id: 'city',[^}]*position: true/.test(SHELL);
+  const held = async (id) => {
+    const p = await positionsPort().positionsFor(id);
+    const b = store.builders.get(id);
+    const view = GovPositions.positionsFor({ me: { builder: { id: Number(id), rank: b.rank }, positions: p } });
+    return { p, view, kinds: ((p && p.held) || []).map((x) => x.kind) };
+  };
+  // The shell's rule (shell.js): a governing tab needs a held seat once the seats are known.
+  const tabShows = (view) => !(cityGated && view.known && !view.has_position);
+  for (const [who, name, want, kinds] of [[FOUNDER_ID, 'The founder', 'owner, board; the City tab shows', ['owner', 'board']], [BEN, 'Ben, Planning\'s Lead', 'lead (Planning Lead); the City tab shows', ['lead']], [EVE, 'Eve, who holds no seat', 'none; the City tab is hidden', []]]) {
+    await check(`${name}: the seats GET /me carries, and the governing tab`, want, async () => {
+      const h = await held(who);
+      const title = h.p && h.p.title;
+      const shows = tabShows(h.view);
+      const got = `${h.kinds.join(', ') || 'none'}${who === BEN ? ` (${title})` : ''}; the City tab ${shows ? 'shows' : 'is hidden'}`;
+      return { got, pass: cityGated && same(h.kinds, kinds) && shows === kinds.length > 0 && (who !== BEN || title === 'Planning Lead') };
+    });
+  }
+  await check('Ben is removed by a People vote and holds no seat; Planning falls to the owner', 'passed; Ben none; Planning answers to the owner', async () => {
+    const r = await call(FOUNDER_ID, 'POST', '/government/board/matters', { area: 'people', title: 'Planning has no Lead', action: { type: 'remove_lead', building: 'planning' } });
+    const v = await vote(FOUNDER_ID, itemIdOf(r));
+    const h = await held(BEN);
+    const a = (await building('planning')).answers || {};
+    return { got: `${v.json && v.json.outcome}; Ben ${h.kinds.join(', ') || 'none'}; Planning answers to ${a.fell_to_owner ? 'the owner' : a.label}`, pass: v.json && v.json.outcome === 'passed' && h.kinds.length === 0 && a.fell_to_owner === true };
+  });
+  await check('Nothing the walk put up is left standing: no law, Lead, pot, open borrow or open sitting', 'none left', async () => {
+    const left = [];
+    if (store.laws.some((l) => !l.repealed_at)) left.push('a law');
+    if (store.leads.some((l) => !l.removed_at)) left.push('a Lead');
+    if (side.treasury.pots.size) left.push('a pot');
+    if (side.treasury.borrows.some((b) => b.state === 'open')) left.push('an open borrow');
+    if (store.items.some((i) => !i.closed_at)) left.push('an open sitting');
+    return { got: left.length ? left.join(', ') : 'none left', pass: left.length === 0 };
+  });
+}
+
+function charterForm(req) {
+  const charter = req('modules/government/charter.js');
+  const config = req('modules/government/config.js');
+  return charter.readCharter(config.loadGovernmentConfig().board).form;
+}
+
+// ── the table, as Markdown ──────────────────────────────────────────────────
+
+const SECTION_TITLES = {
+  G: '1. Genesis: founded, decided, five stages closed, alive',
+  F: '2. Every form: who can vote and what passes',
+  B: '3. Every building: decide by vote refuses acting alone',
+  M: '4. Every matter action: passed and carried out',
+  L: '5. Laws: passed by a vote, read in every session, locks enforced; strictness presets',
+  D: '6. Leads and build-outs under each form of government',
+  A: '7. Asks: the shape enforced, routed to a seat, passed on, counted',
+  T: '8. The treasury: a pot runs dry and borrows from the reserve',
+  P: '9. Positions: the seats GET /me carries and the governing tabs',
+  S: 'The walk itself',
+};
+const cell = (v) => String(v).replace(/\|/g, '\\|').replace(/\n/g, ' ');
+
+function renderTable({ mode, rows }) {
+  const out = [];
+  out.push('<!-- GENERATED by scripts/bongos/government-walk.js - do not hand-edit. Regenerate: node scripts/bongos/government-walk.js --write -->');
+  out.push('');
+  out.push('# The government walk');
+  out.push('');
+  out.push('One repeatable walk over a throwaway test project\'s government (task 1004658, goal 1000111). Re-run it with `node scripts/bongos/government-walk.js`; `tests/government_walk.mjs` re-runs it in CI and fails if any row below changes, so this table is kept true, not just written once.');
+  out.push('');
+  out.push(`**Mode: ${mode}.** Every request is real HTTP through the real routers, and every decision is the real code: the permission gate, board membership, the vote, the tally, the close, the charter apply (written to a throwaway folder), the decision-rules apply, the act-alone gate on every building, and each module's matter act. The storage underneath is an in-memory stand-in for the government tables with the same guards (no Postgres was available where this was built), and the writes a passed matter makes into other modules (the automation fence, override requests, criteria, the GitHub gate approval, budgets) are recorded in memory. So are the new machinery's own tables (laws, asks, build-outs, pots and borrows), a builder's personal settings and the blockers; the shared database pool refuses every query. The treasury runs on a fixed mid-month clock, so a borrow's amount reads the same every run. Everything the walk puts up it takes down again: no law, Lead, pot, open borrow or open sitting is left standing (P5). A real-database run of this walk is not built yet.`);
+  out.push('');
+  out.push('The test project: Ada founds it (Archon); Ben and Cy are trusted builders (Metic) and sit on a Council rank; Dee (Thetes) and Eve (Xenos) are newer builders; Fay has left and only authors the probe ideas, so no probe is decided by its own author.');
+  out.push('');
+  const keys = Object.keys(SECTION_TITLES).filter((k) => rows.some((r) => r.section.startsWith(k)));
+  out.push('| Section | Pass | Fail |');
+  out.push('|---|---|---|');
+  for (const k of keys) {
+    const rs = rows.filter((r) => r.section.startsWith(k));
+    out.push(`| ${SECTION_TITLES[k]} | ${rs.filter((r) => r.pass).length} | ${rs.filter((r) => !r.pass).length} |`);
+  }
+  out.push(`| **All** | **${rows.filter((r) => r.pass).length}** | **${rows.filter((r) => !r.pass).length}** |`);
+  for (const k of keys) {
+    out.push('');
+    out.push(`## ${SECTION_TITLES[k]}`);
+    out.push('');
+    out.push('| # | Check | Expected | Got | Result |');
+    out.push('|---|---|---|---|---|');
+    for (const r of rows.filter((x) => x.section.startsWith(k))) {
+      const bug = KNOWN_BUGS[r.key];
+      const result = r.pass ? 'PASS' : `**FAIL**${bug ? ` (${bug})` : ''}`;
+      out.push(`| ${r.key} | ${cell(r.name)} | ${cell(r.expected)} | ${cell(r.got)} | ${result} |`);
+    }
+  }
+  out.push('');
+  return out.join('\n');
+}
+
+async function main(argv) {
+  // Logs from the modules go to stderr so the table on stdout stays readable.
+  const realLog = console.log;
+  console.log = (...a) => console.error(...a);
+  const result = await runWalk();
+  const md = renderTable(result);
+  console.log = realLog;
+  const fails = result.rows.filter((r) => !r.pass);
+  if (argv.includes('--check')) {
+    const committed = fs.existsSync(DOC_PATH) ? fs.readFileSync(DOC_PATH, 'utf8').replace(/\r\n/g, '\n') : '';
+    if (committed !== md) {
+      process.stdout.write(md);
+      process.stdout.write(`\ngovernment-walk: the committed table (${path.relative(ROOT, DOC_PATH)}) differs from this run. A row changed: find it above, then regenerate with node scripts/bongos/government-walk.js --write (and file any new FAIL as a bug under goal 1000111).\n`);
+      return 1;
+    }
+    process.stdout.write(`government-walk: ${result.rows.length - fails.length} pass, ${fails.length} fail - matches the committed table.\n`);
+    return 0;
+  }
+  process.stdout.write(md);
+  if (argv.includes('--write')) {
+    fs.writeFileSync(DOC_PATH, md);
+    process.stdout.write(`\nwrote ${path.relative(ROOT, DOC_PATH)}\n`);
+  }
+  process.stdout.write(`\ngovernment-walk: ${result.rows.length - fails.length} pass, ${fails.length} fail (${result.mode}).\n`);
+  return 0;
+}
+
+if (require.main === module) {
+  main(process.argv.slice(2)).then((exitCode) => process.exit(exitCode), (err) => {
+    console.error(err);
+    process.exit(2);
+  });
+}
+
+module.exports = { runWalk, renderTable, REQUESTS, ROUTERS, MATTER_PLAN, KNOWN_BUGS };