@bongos/core 1.21.113 → 1.21.115

package/tests/government_leads.mjs

@@ -0,0 +1,375 @@
+// tests/government_leads.mjs — THE LEAD OF EACH BUILDING: who leads it, held as a
+// position the government appoints and removes by vote (task 1004709, goal
+// 1000111; ADR 0374).
+//
+// What this pins (the task's done-when lines, and the walls behind them):
+//   1. A LEAD IS APPOINTED AND REMOVED BY VOTE. appoint_lead / remove_lead are
+//      People matter actions, validated strictly (a building of the nine, an
+//      active builder, a one-line charter or the building's default). Where
+//      People names a sitting the matter sits there; where People is decided as
+//      today it sits under the board IN FORCE (the government appoints), never
+//      refused; a vacant People refuses. A passed matter seats or unseats the
+//      Lead; a returned one does nothing; a departed appointee is not seated.
+//   2. A LEAD SHOWS ON THEIR BUILDING. GET /government/leads reads the nine
+//      buildings, each with its Lead in office (who, charter, since, the sitting).
+//   3. UNSEATED BUILDINGS ROUTE TO THE OWNER. answerFor (the one rule) and the
+//      read say who answers for each building: its Lead, else the owner seat
+//      (every active Archon, the founding one — the lowest id — first).
+//   4. NOTHING ELSE WRITES A LEAD. One SQL writer (db.applyLeadAct), called from
+//      one place (decision-board.js), only for a passed People matter;
+//      government_029's trigger refuses every other INSERT/UPDATE and every
+//      DELETE; no Lead is seeded; every government route, driven for real,
+//      reaches no write.
+// DB-free: db reads/writes are monkeypatched by property.
+//
+// Run:  node --test tests/government_leads.mjs
+
+import { strict as assert } from 'node:assert';
+import { test, after } from 'node:test';
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const GOV = path.join(ROOT, 'modules', 'government');
+const leads = require(path.join(GOV, 'leads.js'));
+const decisionBoard = require(path.join(GOV, 'decision-board.js'));
+const board = require(path.join(GOV, 'board.js'));
+const dr = require(path.join(GOV, 'decision-rules.js'));
+const db = require(path.join(GOV, 'db.js'));
+
+const MIGRATION = fs.readFileSync(path.join(GOV, 'migrations', 'government_029_leads.sql'), 'utf8');
+const MIGRATION_CODE = MIGRATION.replace(/--[^\n]*/g, '');
+
+async function withDb(stubs, fn) {
+  const originals = {};
+  for (const [k, v] of Object.entries(stubs)) { originals[k] = db[k]; db[k] = v; }
+  try { return await fn(); } finally { for (const [k, v] of Object.entries(originals)) db[k] = v; }
+}
+const never = async () => { throw new Error('must not be reached'); };
+const sittingRow = (area, decidedBy, rule) => ({ area, decided_by: decidedBy, rule, who: null, set_by_item_id: '1' });
+const ARCHONS = [
+  { id: '9', github_login: 'late', display_name: 'Late Archon' },
+  { id: '3', github_login: 'ada', display_name: 'Ada' },
+];
+const DEE = { id: '45', github_login: 'dee', display_name: 'Dee' };
+const leadRow = (over = {}) => ({
+  id: '1', building: 'planning', builder_id: '45', charter: 'Goals, priorities and the order of work.', appointed_by_item_id: '40',
+  appointed_at: '2026-10-09T12:00:00.000Z', removed_by_item_id: null, removed_at: null, github_login: 'dee', display_name: 'Dee', ...over,
+});
+
+// ── 1. the shape of an appointment ─────────────────────────────────────────
+
+test('appoint_lead and remove_lead are People matter actions, validated strictly; a charter is one line or the building\'s default', () => {
+  const v = (a) => decisionBoard.validateMatterAction('people', a);
+  assert.deepEqual(v({ type: 'appoint_lead', building: 'planning', builder_id: '45', charter: '  Goals first.  ' }).action,
+    { type: 'appoint_lead', building: 'planning', builder_id: 45, charter: 'Goals first.' }, 'trimmed, the id a number');
+  assert.equal(v({ type: 'appoint_lead', building: 'treasury', builder_id: 45 }).action.charter, leads.DEFAULT_CHARTERS.treasury, 'no charter: the building\'s own');
+  assert.deepEqual(v({ type: 'remove_lead', building: 'review' }).action, { type: 'remove_lead', building: 'review' });
+  for (const k of dr.AREA_KEYS) assert.ok(leads.DEFAULT_CHARTERS[k] && leads.charterLine(leads.DEFAULT_CHARTERS[k], k), `${k} has a default charter that keeps the rule`);
+  const refused = [
+    [{ type: 'appoint_lead', building: 'kitchen', builder_id: 45 }, 'action.building'],
+    [{ type: 'appoint_lead', building: 'planning', builder_id: 0 }, 'action.builder_id'],
+    [{ type: 'appoint_lead', building: 'planning', builder_id: 45, charter: 'no' }, 'action.charter'],
+    [{ type: 'appoint_lead', building: 'planning', builder_id: 45, charter: 'x'.repeat(leads.CHARTER_MAX + 1) }, 'action.charter'],
+    [{ type: 'appoint_lead', building: 'planning', builder_id: 45, charter: 'Two\nlines' }, 'action.charter'],
+    [{ type: 'appoint_lead', building: 'planning', builder_id: 45, can_build_without_vote: true }, 'action.can_build_without_vote'],
+    [{ type: 'remove_lead' }, 'action.building'],
+  ];
+  for (const [action, field] of refused) {
+    const out = v(action);
+    assert.equal(out.ok, false, JSON.stringify(action));
+    assert.equal(out.field, field, JSON.stringify(out));
+  }
+  assert.equal(decisionBoard.validateMatterAction('rules', { type: 'appoint_lead', building: 'rules', builder_id: 45 }).ok, false, 'a Lead is a People matter, at no other building');
+});
+
+// ── 1. filed as a People matter, decided by the government ─────────────────
+
+test('People decided as today: a Lead matter sits under the board IN FORCE, never refused as "decided by the gate"', async () => {
+  let made = null; let opened = null;
+  await withDb({
+    listDecisionRules: async () => [],
+    listLeads: async () => [],
+    getActiveBuilder: async (id) => (String(id) === '45' ? DEE : null),
+    createMatter: async (args) => { made = args; return { id: '8', ...args }; },
+    openBoardItem: async (args) => { opened = args; return { id: '40', subject_type: args.subjectType, subject_id: args.subjectId, constitution: args.constitution }; },
+  }, async () => {
+    const out = await board.openMatter({ area: 'people', title: 'Dee leads Planning', action: { type: 'appoint_lead', building: 'planning', builder_id: 45 }, proposedBy: '42' });
+    assert.equal(out.ok, true, JSON.stringify(out));
+    assert.equal(out.decided.sat_under, 'board');
+    // a rank assignment there is still decided on its own page, as before
+    const rank = await board.openMatter({ area: 'people', title: 'Make Dee a tester', action: { type: 'assign_rank', builder_id: 45, rank_key: 'tester' }, proposedBy: '42' });
+    assert.equal(rank.reason, 'decided_by_gate', 'only the Lead acts take the board');
+  });
+  assert.equal(made.area, 'people');
+  assert.deepEqual(made.action, { type: 'appoint_lead', building: 'planning', builder_id: 45, charter: leads.DEFAULT_CHARTERS.planning });
+  assert.equal(opened.subjectType, 'people_matter', 'a People matter, on the board');
+  assert.equal(opened.constitution.pass_rule, 'first_ratifier', 'decided under the board in force (this checkout: monarchy)');
+  assert.equal(opened.constitution.membership, 'rank:archon');
+});
+
+test('People handed to a sitting: the Lead matter sits under the ROW; a vacant People cannot appoint', async () => {
+  let opened = null;
+  await withDb({
+    listDecisionRules: async () => [sittingRow('people', 'rank:council', 'consent')],
+    listLeads: async () => [],
+    getActiveBuilder: async () => DEE,
+    createMatter: async (args) => ({ id: '8', ...args }),
+    openBoardItem: async (args) => { opened = args; return { id: '40', subject_type: args.subjectType, subject_id: args.subjectId, constitution: args.constitution }; },
+  }, async () => {
+    const out = await board.openMatter({ area: 'people', title: 'Dee leads Planning', action: { type: 'appoint_lead', building: 'planning', builder_id: 45 }, proposedBy: '42' });
+    assert.equal(out.ok, true, JSON.stringify(out));
+  });
+  assert.equal(opened.constitution.membership, 'rank:council');
+  assert.equal(opened.constitution.rule, 'consent');
+  await withDb({ listDecisionRules: async () => [sittingRow('people', 'nobody', 'vacant')], listLeads: async () => [], getActiveBuilder: async () => DEE, createMatter: never, openBoardItem: never }, async () => {
+    assert.equal((await board.openMatter({ area: 'people', title: 'Dee leads Planning', action: { type: 'appoint_lead', building: 'planning', builder_id: 45 }, proposedBy: '42' })).reason, 'no_one_holds_this');
+  });
+});
+
+test('refused before any write: an appointee who is not an active builder, a Lead already in office on that charter, removing nobody', async () => {
+  await withDb({
+    listDecisionRules: async () => [],
+    listLeads: async () => [leadRow()],
+    getActiveBuilder: async (id) => (String(id) === '45' ? DEE : null),
+    createMatter: never,
+    openBoardItem: never,
+  }, async () => {
+    const open = (action) => board.openMatter({ area: 'people', title: 'A Lead', action, proposedBy: '42' });
+    assert.equal((await open({ type: 'appoint_lead', building: 'planning', builder_id: 77 })).reason, 'unknown_builder');
+    assert.equal((await open({ type: 'appoint_lead', building: 'planning', builder_id: 45 })).reason, 'already_lead');
+    assert.equal((await open({ type: 'remove_lead', building: 'review' })).reason, 'no_lead');
+  });
+  // a new charter for the same Lead, or someone else, is a fresh appointment
+  let filed = 0;
+  await withDb({
+    listDecisionRules: async () => [],
+    listLeads: async () => [leadRow()],
+    getActiveBuilder: async () => DEE,
+    createMatter: async (a) => { filed += 1; return { id: String(8 + filed), ...a }; },
+    openBoardItem: async (a) => ({ id: '41', subject_type: a.subjectType, subject_id: a.subjectId, constitution: a.constitution }),
+  }, async () => {
+    assert.equal((await board.openMatter({ area: 'people', title: 'A new charter', action: { type: 'appoint_lead', building: 'planning', builder_id: 45, charter: 'Goals only.' }, proposedBy: '42' })).ok, true);
+    assert.equal((await board.openMatter({ area: 'people', title: 'Dee steps down', action: { type: 'remove_lead', building: 'planning' }, proposedBy: '42' })).ok, true);
+  });
+  assert.equal(filed, 2);
+});
+
+// ── 1. passed: carried out; returned: nothing ──────────────────────────────
+
+function closeWith({ action, outcome = 'passed', active = true, stubs = {} }) {
+  const writes = [];
+  const run = withDb({
+    getVotesForItem: async () => [{ voter_id: '9', direction: outcome === 'passed' ? 'yes' : 'no' }],
+    closeBoardItem: async ({ outcome: o, afterClose }) => { assert.equal(afterClose, null, 'a matter books nothing in the close'); return { id: '40', subject_type: 'people_matter', subject_id: '8', opened_by: '42', closed_at: 'T', outcome: o }; },
+    getMatter: async () => ({ id: '8', area: 'people', title: 'A Lead', action, proposed_by: '42' }),
+    getActiveBuilder: async () => (active ? DEE : null),
+    applyLeadAct: async (args) => { writes.push(args); return { done: true, lead: null, ended: null }; },
+    insertAuthorRatifyKarma: never,
+    getBoardItemAuthor: async () => '42',
+    ...stubs,
+  }, async () => {
+    const item = { id: '40', subject_type: 'people_matter', subject_id: '8', opened_by: '42', closed_at: null, constitution: { membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true } };
+    return board.closeItem(item);
+  });
+  return run.then((out) => ({ out, writes }));
+}
+
+test('a passed appointment seats the Lead, through the one write, naming the sitting that passed it', async () => {
+  const action = { type: 'appoint_lead', building: 'planning', builder_id: 45, charter: 'Goals, priorities and the order of work.' };
+  const { out, writes } = await closeWith({ action });
+  assert.equal(out.outcome, 'passed');
+  assert.equal(out.author_karma, null, 'a matter pays nobody');
+  assert.deepEqual(out.acted, { area: 'people', matter_id: '8', action: 'appoint_lead', done: true, building: 'planning', builder_id: '45' });
+  assert.deepEqual(writes, [{ itemId: '40', action }]);
+});
+
+test('a passed removal unseats the Lead; a returned matter and a departed appointee seat nobody', async () => {
+  const removed = await closeWith({ action: { type: 'remove_lead', building: 'planning' } });
+  assert.equal(removed.out.acted.done, true);
+  assert.deepEqual(removed.writes, [{ itemId: '40', action: { type: 'remove_lead', building: 'planning' } }]);
+
+  const returned = await closeWith({ action: { type: 'appoint_lead', building: 'planning', builder_id: 45, charter: 'Goals first.' }, outcome: 'returned' });
+  assert.equal(returned.out.outcome, 'returned');
+  assert.deepEqual(returned.writes, [], 'a returned matter carries out nothing');
+
+  const gone = await closeWith({ action: { type: 'appoint_lead', building: 'planning', builder_id: 45, charter: 'Goals first.' }, active: false });
+  assert.equal(gone.out.outcome, 'passed', 'the decision stands');
+  assert.equal(gone.out.acted.done, false);
+  assert.equal(gone.out.acted.reason, 'builder_gone');
+  assert.deepEqual(gone.writes, [], 'a builder who left is not seated');
+
+  const nobody = await closeWith({ action: { type: 'remove_lead', building: 'planning' }, stubs: { applyLeadAct: async () => ({ done: false, reason: 'no_lead' }) } });
+  assert.equal(nobody.out.acted.done, false);
+  assert.equal(nobody.out.acted.reason, 'no_lead', 'someone else removed them first: said, not hidden');
+});
+
+// ── 2 + 3. who leads, who answers ──────────────────────────────────────────
+
+test('answerFor is the one rule: a building\'s Lead answers for it; an unseated building falls to the owner', () => {
+  const owner = { seat: 'owner', builders: [{ id: '3' }, { id: '9' }] };
+  assert.deepEqual(leads.answerFor('planning', [leadRow()], owner), { seat: 'lead:planning', builder_ids: ['45'], fell_to_owner: false });
+  assert.deepEqual(leads.answerFor('review', [leadRow()], owner), { seat: 'owner', builder_ids: ['3', '9'], fell_to_owner: true });
+  assert.deepEqual(leads.answerFor('review', [], { seat: 'owner', builders: [] }).builder_ids, [], 'no active Archon: nobody, never a guess');
+  assert.deepEqual(leads.answerFor('planning', [leadRow({ removed_at: 'T' })], owner).seat, 'owner', 'a Lead who left office answers for nothing');
+  assert.equal(leads.answerFor('kitchen', [], owner), null);
+});
+
+test('the read: nine buildings in street order, each Lead with their charter and sitting, the rest answered by the owner seat', () => {
+  const v = leads.leadsView([leadRow()], ARCHONS);
+  assert.deepEqual(v.buildings.map((b) => b.building), dr.AREA_KEYS.slice());
+  assert.deepEqual(v.owner.builders.map((b) => b.id), ['3', '9'], 'every active Archon holds the owner seat, the founding one first');
+  assert.deepEqual(v.owner.builders[0], { id: '3', login: 'ada', name: 'Ada' });
+  assert.equal(v.seated, 1);
+  const planning = v.buildings.find((b) => b.building === 'planning');
+  assert.deepEqual(planning.lead.builder, { id: '45', login: 'dee', name: 'Dee' });
+  assert.equal(planning.lead.charter, 'Goals, priorities and the order of work.');
+  assert.equal(planning.lead.since, '2026-10-09T12:00:00.000Z');
+  assert.deepEqual(planning.lead.appointed_by, { item_id: '40', href: '/board-room?item=40' });
+  assert.equal(planning.answers.seat, 'lead:planning');
+  for (const b of v.buildings.filter((x) => x.building !== 'planning')) {
+    assert.equal(b.lead, null, `${b.building}: unseated`);
+    assert.deepEqual(b.answers, { seat: 'owner', builder_ids: ['3', '9'], fell_to_owner: true }, `${b.building}: the owner answers`);
+  }
+  assert.match(v.changed_by, /passed People matter only/);
+  // the record keeps who led before
+  const past = leads.leadsView([leadRow({ removed_at: 'T2', removed_by_item_id: '44' })], ARCHONS, { includePast: true });
+  assert.equal(past.seated, 0);
+  assert.deepEqual(past.past[0].removed_by, { item_id: '44', href: '/board-room?item=44' });
+});
+
+// ── 4. the walls ────────────────────────────────────────────────────────────
+
+test('government_029: a Lead is written only by a passed People matter that says so; no delete; one in office per building', () => {
+  assert.match(MIGRATION_CODE, /CREATE TABLE IF NOT EXISTS government_leads/);
+  assert.match(MIGRATION_CODE, /CREATE UNIQUE INDEX IF NOT EXISTS government_leads_in_office_uniq\s+ON government_leads \(building\) WHERE removed_at IS NULL/, 'one Lead in office per building');
+  assert.match(MIGRATION_CODE, /i\.subject_type = 'people_matter'\s+AND i\.outcome = 'passed'\s+AND m\.area = 'people'/, 'only a passed People matter');
+  assert.match(MIGRATION_CODE, /act->>'type' IS DISTINCT FROM 'appoint_lead'\s+OR act->>'building' IS DISTINCT FROM NEW\.building\s+OR act->>'builder_id' IS DISTINCT FROM NEW\.builder_id::text\s+OR act->>'charter' IS DISTINCT FROM NEW\.charter THEN\s+RAISE EXCEPTION/, 'an appointment is exactly what the matter said');
+  assert.match(MIGRATION_CODE, /act->>'type' NOT IN \('remove_lead', 'appoint_lead'\)\s+OR act->>'building' IS DISTINCT FROM OLD\.building THEN\s+RAISE EXCEPTION/, 'leaving office names a matter for this building');
+  assert.match(MIGRATION_CODE, /IF TG_OP = 'DELETE' THEN\s+RAISE EXCEPTION/, 'no delete');
+  assert.match(MIGRATION_CODE, /IF OLD\.removed_at IS NOT NULL THEN\s+RAISE EXCEPTION/, 'an ended appointment never changes again');
+  assert.match(MIGRATION_CODE, /NEW\.charter IS DISTINCT FROM OLD\.charter/, 'a Lead in office cannot be edited');
+  assert.match(MIGRATION_CODE, /NEW\.appointed_at := now\(\)/, 'when is the database clock');
+  assert.match(MIGRATION_CODE, /BEFORE INSERT OR UPDATE OR DELETE ON government_leads/);
+  assert.doesNotMatch(MIGRATION_CODE, /INSERT INTO government_leads/, 'no Lead is seeded: every building starts with the owner');
+});
+
+test('one writer, one caller: db.applyLeadAct names the sitting; only decision-board calls it; no route does', () => {
+  const dbSrc = fs.readFileSync(path.join(GOV, 'db.js'), 'utf8');
+  assert.equal((dbSrc.match(/INSERT INTO government_leads/g) || []).length, 1, 'one INSERT');
+  assert.equal((dbSrc.match(/UPDATE government_leads/g) || []).length, 1, 'one UPDATE');
+  const callers = [];
+  const walk = (dir) => {
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+      const p = path.join(dir, e.name);
+      if (e.isDirectory()) { if (e.name !== 'node_modules' && e.name !== 'migrations') walk(p); continue; }
+      if (e.name.endsWith('.js') && /applyLeadAct\(/.test(fs.readFileSync(p, 'utf8'))) callers.push(path.relative(ROOT, p).replace(/\\/g, '/'));
+    }
+  };
+  walk(path.join(ROOT, 'modules'));
+  walk(path.join(ROOT, 'src'));
+  assert.deepEqual(callers.sort(), ['modules/government/db.js', 'modules/government/decision-board.js']);
+});
+
+// ── the routes, through the real router ─────────────────────────────────────
+
+const api = require(path.join(ROOT, 'src', 'module-api.js'));
+const seams = require(path.join(ROOT, 'src', 'module-seams.js'));
+const rrc = require(path.join(ROOT, 'src', 'bongos', 'route-rank-check.js'));
+const { attachFail } = require(path.join(ROOT, 'src', 'bongos', 'middleware', 'error-envelope.js'));
+const express = require('express');
+
+test('GET /government/leads is pinned where the room reads; the matters route files the appointment', () => {
+  const pins = rrc.MODULE_EXPECTED_RANKS.government;
+  assert.equal(pins['GET /government/leads'], 'perm:board.vote.cast');
+  assert.equal(pins['POST /government/board/matters'], 'perm:board.item.open');
+});
+
+const realRequireBuilder = api.requireBuilder;
+api.requireBuilder = (req, res, next) => { req.builder = { id: 42, rank: 'archon' }; next(); };
+seams._reset();
+let held = ['government.manage', 'board.item.open', 'board.vote.cast'];
+seams.registerProvider('government', { resolveBuilderPermissions: async () => held });
+const buildGovernmentRouter = require(path.join(GOV, 'routes', 'government.js'));
+const app = express();
+app.use(express.json());
+app.use(attachFail);
+app.use(buildGovernmentRouter());
+const server = http.createServer(app);
+await new Promise((r) => server.listen(0, '127.0.0.1', r));
+const BASE = `http://127.0.0.1:${server.address().port}`;
+after(() => { server.close(); api.requireBuilder = realRequireBuilder; seams._reset(); });
+
+async function call(method, p, body) {
+  const res = await fetch(`${BASE}${p}`, { method, headers: body === undefined ? {} : { 'content-type': 'application/json' }, body: body === undefined ? undefined : JSON.stringify(body) });
+  let json = null; try { json = await res.json(); } catch { /* none */ }
+  return { status: res.status, json };
+}
+
+test('GET /government/leads: the Lead on their building, the owner answering for the rest; 403 without the atom', async () => {
+  let asked = null;
+  await withDb({ listLeads: async (o) => { asked = o; return [leadRow()]; }, listActiveArchons: async () => ARCHONS, listDecisionRules: async () => [], getActiveBuildersWithRank: async () => [] }, async () => {
+    const r = await call('GET', '/government/leads');
+    assert.equal(r.status, 200, JSON.stringify(r.json));
+    // what each holder may build without a vote rides the read (task 1004710; tests/government_build_rights.mjs)
+    assert.deepEqual(Object.keys(r.json.buildings.find((b) => b.building === 'planning').build_rights.capsules), ['committee', 'floor', 'annex', 'district']);
+    assert.deepEqual(asked, { includePast: false });
+    assert.equal(r.json.buildings.length, 9);
+    assert.equal(r.json.buildings.find((b) => b.building === 'planning').lead.builder.name, 'Dee');
+    assert.equal(r.json.buildings.find((b) => b.building === 'release').answers.seat, 'owner');
+    await call('GET', '/government/leads?include=past');
+    assert.deepEqual(asked, { includePast: true });
+  });
+  held = ['board.item.open'];
+  try { assert.equal((await call('GET', '/government/leads')).status, 403); } finally { held = ['government.manage', 'board.item.open', 'board.vote.cast']; }
+});
+
+test('POST /government/board/matters files an appointment (201) and refuses a removal of nobody (409)', async () => {
+  await withDb({
+    listDecisionRules: async () => [],
+    listLeads: async () => [],
+    getActiveBuilder: async () => DEE,
+    createMatter: async (a) => ({ id: '8', ...a }),
+    openBoardItem: async (a) => ({ id: '40', subject_type: a.subjectType, subject_id: a.subjectId, constitution: a.constitution }),
+  }, async () => {
+    const ok = await call('POST', '/government/board/matters', { area: 'people', title: 'Dee leads Planning', action: { type: 'appoint_lead', building: 'planning', builder_id: 45 } });
+    assert.equal(ok.status, 201, JSON.stringify(ok.json));
+    assert.equal(ok.json.item.subject_type, 'people_matter');
+    const none = await call('POST', '/government/board/matters', { area: 'people', title: 'Nobody leads Review', action: { type: 'remove_lead', building: 'review' } });
+    assert.equal(none.status, 409);
+    assert.equal(none.json.error.code, 'no_lead');
+    const bad = await call('POST', '/government/board/matters', { area: 'people', title: 'A Lead for the kitchen', action: { type: 'appoint_lead', building: 'kitchen', builder_id: 45 } });
+    assert.equal(bad.status, 400);
+    assert.equal(bad.json.error.code, 'invalid_matter');
+  });
+});
+
+test('every government route, driven for real, reaches no Lead write', async () => {
+  const router = buildGovernmentRouter();
+  const routes = [];
+  for (const layer of router.stack) {
+    if (!layer.route) continue;
+    for (const m of Object.keys(layer.route.methods)) routes.push([m.toUpperCase(), layer.route.path]);
+  }
+  assert.ok(routes.some(([m, p]) => m === 'GET' && p === '/government/leads'), 'the read is mounted');
+  const writes = [];
+  const stubs = {};
+  for (const k of Object.keys(db)) if (typeof db[k] === 'function') stubs[k] = async () => [];
+  stubs.applyLeadAct = async () => { writes.push('applyLeadAct'); return { done: true }; };
+  stubs.createMatter = async (a) => ({ id: '8', ...a });
+  stubs.openBoardItem = async (a) => ({ id: '40', subject_type: a.subjectType, subject_id: a.subjectId, constitution: a.constitution });
+  stubs.getActiveBuilder = async () => DEE;
+  const lead = { type: 'appoint_lead', building: 'planning', builder_id: 45 };
+  await withDb(stubs, async () => {
+    for (const [method, p] of routes) {
+      const url = p.replace(/:[A-Za-z]+/g, '1');
+      const bodies = method === 'GET' ? [undefined] : [{ area: 'people', title: 'Dee leads Planning', action: lead }, { action: lead }, lead, { direction: 'yes' }];
+      for (const body of bodies) await call(method, url, body);
+    }
+  });
+  assert.deepEqual(writes, [], 'opening a matter seats nobody; only a passed sitting does');
+});

package/tests/government_positions.mjs

@@ -0,0 +1,127 @@
+// tests/government_positions.mjs — GOVERNANCE IS A HELD POSITION (task 1004713,
+// goal 1000111; ADR 0377).
+//
+// What it pins:
+//   1. positions.js folds the real seats for one builder: the owner seat (every
+//      active Archon), a Lead in office, a seat on a building's own sitting, the
+//      board. A Lead is named by their seat and outranks the rest for the title;
+//      an unseated building is the owner's, never a Lead for anybody.
+//   2. readPositions asks each read the server resolves (Leads, Archons, the
+//      board and each sitting's predicate) and answers null when any read fails —
+//      unknown, never "holds none". A craft never makes a seat.
+//   3. GET /me carries the block through the government port, and the port asks
+//      the one rule each seat already has (routing.resolveSeat via leads.answerFor,
+//      board-membership.isBoardMember) — never a second one.
+//
+// Run:  node --test --test-reporter=tap tests/government_positions.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const positions = require(path.join(ROOT, 'modules', 'government', 'positions.js'));
+const { ownerOf } = require(path.join(ROOT, 'modules', 'government', 'leads.js'));
+
+const ARCHONS = [{ id: 3, github_login: 'founder' }, { id: 7, github_login: 'second' }];
+const LEADS = [{ building: 'planning', builder_id: 42 }, { building: 'review', builder_id: 43, removed_at: '2026-10-01' }];
+const kinds = (p) => p.held.map((s) => s.kind);
+
+// ── 1. the fold ────────────────────────────────────────────────────────────────
+
+test('a Lead in office holds their building, named by the seat', () => {
+  const p = positions.positionsOf('42', { leads: LEADS, owner: ownerOf(ARCHONS) });
+  assert.deepEqual(kinds(p), ['lead']);
+  assert.equal(p.held[0].seat, 'lead:planning');
+  assert.equal(p.title, 'Planning Lead');
+  assert.equal(p.has_position, true);
+});
+
+test('a builder with no seat holds nothing, whatever their id looks like', () => {
+  for (const id of ['424242', '43', null, '']) {
+    const p = positions.positionsOf(id, { leads: LEADS, owner: ownerOf(ARCHONS), board: false, sittings: [] });
+    assert.deepEqual(p.held, [], `${id}: a removed Lead and a stranger hold nothing`);
+    assert.equal(p.title, null);
+    assert.equal(p.has_position, false);
+  }
+});
+
+test('every active Archon holds the owner seat; an unseated building never makes them its Lead', () => {
+  const p = positions.positionsOf('7', { leads: LEADS, owner: ownerOf(ARCHONS) });
+  assert.deepEqual(kinds(p), ['owner'], 'review is unseated (its Lead was removed): it falls to the owner, not a Lead seat');
+  assert.equal(p.title, 'Owner');
+});
+
+test('a Lead names the Governing mode ahead of the owner seat, a building seat and the board', () => {
+  const p = positions.positionsOf('3', {
+    leads: [{ building: 'treasury', builder_id: 3 }], owner: ownerOf(ARCHONS), board: true, sittings: ['people'],
+  });
+  assert.deepEqual(kinds(p), ['lead', 'owner', 'seat', 'board']);
+  assert.deepEqual(p.held.map((s) => s.title), ['Treasury Lead', 'Owner', 'People seat', 'Board member']);
+  assert.equal(p.title, 'Treasury Lead');
+});
+
+// ── 2. the reads ───────────────────────────────────────────────────────────────
+
+const reads = (over = {}) => ({
+  listLeads: async () => LEADS,
+  listActiveArchons: async () => ARCHONS,
+  board: () => ({ membership: 'rank:archon' }),
+  decisions: async () => [
+    { area: 'people', sitting: true, decided_by: 'rank:metic+' },
+    { area: 'rules', sitting: true, decided_by: 'board' },
+    { area: 'release', sitting: false, decided_by: 'rank:metic+' },
+    { area: 'review', sitting: true, decided_by: 'gate' },
+  ],
+  // the fake predicate: 42 is a metic, 3 and 7 archons
+  sits: async (id, membership) => (membership === 'rank:archon' ? ['3', '7'] : membership === 'rank:metic+' ? ['3', '7', '42'] : []).includes(String(id)),
+  ...over,
+});
+
+test('readPositions seats a builder on each building whose own sitting names them, and on the board', async () => {
+  const lead = await positions.readPositions('42', reads());
+  assert.deepEqual(kinds(lead), ['lead', 'seat'], 'the Planning Lead also sits on People (a metic+ sitting)');
+  assert.deepEqual(lead.held.map((s) => s.seat), ['lead:planning', 'board:people'],
+    'a sitting the board holds (rules), one that is not a sitting (release) and a fixed gate (review) seat nobody');
+  const archon = await positions.readPositions('3', reads());
+  assert.deepEqual(kinds(archon), ['owner', 'seat', 'board']);
+  const stranger = await positions.readPositions('424242', reads());
+  assert.equal(stranger.has_position, false);
+  assert.deepEqual(stranger.held, []);
+});
+
+test('readPositions is unknown (null) when any read fails, or with no builder — never "holds none"', async () => {
+  for (const broken of ['listLeads', 'listActiveArchons', 'decisions', 'sits']) {
+    const r = await positions.readPositions('42', reads({ [broken]: async () => { throw new Error('db down'); } }));
+    assert.equal(r, null, `${broken} failed`);
+  }
+  assert.equal(await positions.readPositions('42', reads({ board: () => { throw new Error('config'); } })), null);
+  assert.equal(await positions.readPositions(null, reads()), null);
+});
+
+test('a craft never makes a seat: positions.js reads no discipline', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules', 'government', 'positions.js'), 'utf8').replace(/^\s*\/\/.*$/gm, '');
+  assert.doesNotMatch(src, /disciplin|preferred_/i, 'no craft field is read');
+});
+
+// ── 3. the wiring ──────────────────────────────────────────────────────────────
+
+test('GET /me carries positions through the government port', () => {
+  const me = fs.readFileSync(path.join(ROOT, 'src', 'bongos', 'routes', 'me.js'), 'utf8');
+  assert.match(me, /government\.positionsFor\(req\.builder\.id\)/, '/me asks the port for the requesting builder');
+  assert.match(me, /positions: govPositions,/, '/me answers a positions block');
+});
+
+test('the port asks the rules each seat already has, never a second one', () => {
+  const gov = fs.readFileSync(path.join(ROOT, 'modules', 'government', 'routes', 'government.js'), 'utf8');
+  assert.match(gov, /positionsFor: \(builderId\) => positions\.readPositions\(builderId, \{/);
+  assert.match(gov, /sits: \(id, membership\) => boardMembership\.isBoardMember\(id, \{ membership \}\)/);
+  const src = fs.readFileSync(path.join(ROOT, 'modules', 'government', 'positions.js'), 'utf8');
+  assert.match(src, /require\('\.\/routing'\)/, 'Lead and owner seats are routing.resolveSeat\'s answer');
+  assert.match(src, /resolveSeat\('owner'/);
+  assert.match(src, /resolveSeat\(`lead:\$\{b\}`/);
+});