@bongos/core 1.21.113 → 1.21.115

package/scripts/gds/government-walk.js

@@ -5,7 +5,7 @@
 // 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 four sections:
+// 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,
@@ -15,6 +15,17 @@
 //   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
@@ -71,6 +82,7 @@ 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`, {}],
@@ -104,6 +116,8 @@ const REQUESTS = Object.freeze({
 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'],
@@ -131,6 +145,9 @@ const ROUTERS = Object.freeze([
   '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 ──────────────────────────────────────────
@@ -150,6 +167,9 @@ function makeStore(catalog) {
     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(),
@@ -307,7 +327,125 @@ function makeStore(catalog) {
       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 }));
     },
@@ -337,6 +475,119 @@ function installStore(govDb, fns, unexpected) {
   }
 }
 
+// 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() {
@@ -373,6 +624,9 @@ async function runWalk() {
 
   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();
@@ -412,10 +666,13 @@ async function runWalk() {
 
   // 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;
@@ -429,10 +686,10 @@ async function runWalk() {
   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) {
+  async function call(as, method, p, body, session = 'web') {
     const res = await fetch(`${BASE}${p}`, {
       method,
-      headers: { [asHeader]: as, ...(body === undefined ? {} : { 'content-type': 'application/json' }) },
+      headers: { [asHeader]: as, [sessionHeader]: session, ...(body === undefined ? {} : { 'content-type': 'application/json' }) },
       body: body === undefined ? undefined : JSON.stringify(body),
     });
     let json = null;
@@ -620,6 +877,7 @@ async function runWalk() {
       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' };
       });
     }
@@ -707,6 +965,8 @@ async function runWalk() {
   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'),
@@ -747,6 +1007,9 @@ async function runWalk() {
     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 () => {
@@ -759,6 +1022,372 @@ async function runWalk() {
   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 = {
@@ -766,6 +1395,11 @@ const SECTION_TITLES = {
   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, ' ');
@@ -778,7 +1412,7 @@ function renderTable({ mode, rows }) {
   out.push('');
   out.push('One repeatable walk over a throwaway test project\'s government (task 1004658, goal 1000111). Re-run it with `node scripts/gds/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. A real-database run of this walk is not built yet.`);
+  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('');