@bongos/core 1.19.223 → 1.19.225

package/tests/government_board_vote.mjs

@@ -0,0 +1,247 @@
+// tests/government_board_vote.mjs — cast a vote: open ballot, anti-self, live
+// re-check, karma (BV1.R08 of goal 1000069, ADR 0175 §§4/6/9).
+//
+// DB-free (db monkeypatched, the sibling board tests' idiom) — and deliberately
+// NOT membership-stubbed: castVote runs the REAL board-membership parse against
+// the item's snapshotted constitution, with only the db row lookups stubbed, so
+// the "who may vote is the SNAPSHOT's rule" property is exercised rather than
+// assumed. The invariants:
+//
+//   1. THE SECTION KEYS ARE ONE LIST IN THREE PLACES — board.js's validation,
+//      government_003's CHECK, and the ideas template declaration. A module may
+//      not require a sibling (ADR 0083), so they are held equal HERE.
+//   2. ANTI-SELF IS SERVER-SIDE AND UNCONDITIONAL — the bright line that keeps
+//      ratification from being ceremonial.
+//   3. MEMBERSHIP IS RE-CHECKED LIVE, AGAINST THE SNAPSHOT — a demotion between
+//      open and vote refuses the vote; an amendment mid-sitting cannot change
+//      who votes on an already-open item.
+//   4. IDEMPOTENT, AND KARMA RIDES ONLY THE FRESH INSERT — a double-cast is one
+//      vote and one +1, never two.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+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 board = require(path.join(GOV, 'board.js'));
+const db = require(path.join(GOV, 'db.js'));
+const { fieldOrder, templateFor } = require(path.join(ROOT, 'modules', 'ideas', 'templates.js'));
+
+const { FULL_IDEA_SECTION_KEYS, VOTE_KARMA_DELTA, AUTHOR_RATIFY_KARMA_DELTA, awardAuthorRatifyKarma, validateVote, castVote } = board;
+
+// ── invariant 1: one list, three places ─────────────────────────────────────
+
+test('the objection section keys ARE the Full Idea template fields (no second list that drifts)', () => {
+  assert.deepEqual([...FULL_IDEA_SECTION_KEYS], fieldOrder(templateFor('base-v1')),
+    'board.js must flag against the same five sections the template declares');
+  const migration = fs.readFileSync(
+    path.join(GOV, 'migrations', 'government_003_board_tables.sql'), 'utf8');
+  for (const key of FULL_IDEA_SECTION_KEYS) {
+    assert.ok(migration.includes(`'${key}'`), `the government_003 CHECK must carry '${key}'`);
+  }
+});
+
+// ── the pure payload validation ──────────────────────────────────────────────
+
+test('a yes carries nothing; a no carries a reason AND exactly one section', () => {
+  assert.deepEqual(validateVote({ direction: 'yes' }),
+    { ok: true, direction: 'yes', reasonMd: null, sectionKey: null });
+  assert.equal(validateVote({ direction: 'yes', reasonMd: 'but…' }).reason, 'yes_carries_nothing');
+  assert.equal(validateVote({ direction: 'yes', sectionKey: 'fit' }).reason, 'yes_carries_nothing');
+
+  const no = validateVote({ direction: 'no', reasonMd: '  needs a real fit story  ', sectionKey: 'fit' });
+  assert.deepEqual(no, { ok: true, direction: 'no', reasonMd: 'needs a real fit story', sectionKey: 'fit' });
+  assert.equal(validateVote({ direction: 'no', sectionKey: 'fit' }).reason, 'objection_needs_reason');
+  assert.equal(validateVote({ direction: 'no', reasonMd: '   ', sectionKey: 'fit' }).reason, 'objection_needs_reason');
+  assert.equal(validateVote({ direction: 'no', reasonMd: 'x' }).reason, 'objection_needs_section');
+  assert.equal(validateVote({ direction: 'no', reasonMd: 'x', sectionKey: 'vibes' }).reason, 'objection_needs_section');
+  for (const bad of [undefined, null, 'YES', 'abstain', 1]) {
+    assert.equal(validateVote({ direction: bad }).reason, 'bad_direction', `${String(bad)} is not a ballot`);
+  }
+});
+
+// ── castVote against a stubbed db (membership logic REAL) ───────────────────
+
+const MONARCHY = { membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true };
+const openItem = (over = {}) => ({
+  id: '11', subject_type: 'full_idea', subject_id: '7', opened_by: null,
+  closed_at: null, expired: false, constitution: MONARCHY, ...over,
+});
+
+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; }
+}
+
+test('the happy path: a member yes is recorded fresh, with its +1 karma', async () => {
+  const karma = [];
+  let insertArgs = null;
+  await withDb({
+    getBoardItemForVote: async () => openItem(),
+    builderHoldsRankActive: async (builderId, rankKey) =>
+      builderId === '42' && rankKey === 'archon', // the REAL membership parse chose 'archon' from the snapshot
+    getBoardItemAuthor: async () => '7',          // someone else authored the idea
+    insertBoardVote: async (args) => { insertArgs = args; return { id: '1', ...args }; },
+    insertVoteKarma: async (args) => { karma.push(args); },
+  }, async () => {
+    const out = await castVote({ itemId: 11, voterId: '42', direction: 'yes' });
+    assert.equal(out.ok, true);
+    assert.equal(out.fresh, true);
+    assert.equal(out.karma_delta, VOTE_KARMA_DELTA);
+  });
+  assert.deepEqual(insertArgs, { itemId: 11, voterId: '42', direction: 'yes', reasonMd: null, sectionKey: null });
+  assert.deepEqual(karma, [{ voterId: '42', itemId: 11, delta: VOTE_KARMA_DELTA }]);
+});
+
+test('membership is the SNAPSHOT\'s rule: a rank the snapshot does not name is refused', async () => {
+  // The live config could say anything; the item was opened under monarchy, so
+  // only an archon-holder votes on it. A metic-holder is refused even though
+  // they hold A rank — just not the snapshotted one.
+  await withDb({
+    getBoardItemForVote: async () => openItem(),
+    builderHoldsRankActive: async (builderId, rankKey) => rankKey === 'metic', // holds metic, not archon
+    getBoardItemAuthor: async () => { throw new Error('must not be reached'); },
+    insertBoardVote: async () => { throw new Error('must not be reached'); },
+  }, async () => {
+    const out = await castVote({ itemId: 11, voterId: '42', direction: 'yes' });
+    assert.deepEqual(out, { ok: false, reason: 'not_board_member' });
+  });
+});
+
+test('the demotion between open and vote refuses the vote — live re-check, uncached', async () => {
+  let demoted = false;
+  await withDb({
+    getBoardItemForVote: async () => openItem(),
+    builderHoldsRankActive: async () => !demoted,
+    getBoardItemAuthor: async () => '7',
+    insertBoardVote: async (args) => ({ id: '1', ...args }),
+    insertVoteKarma: async () => {},
+  }, async () => {
+    assert.equal((await castVote({ itemId: 11, voterId: '42', direction: 'yes' })).ok, true);
+    demoted = true;
+    assert.deepEqual(await castVote({ itemId: 11, voterId: '42', direction: 'yes' }),
+      { ok: false, reason: 'not_board_member' }, 'off the board on the very next request');
+  });
+});
+
+test('anti-self: the author cannot vote on their own item — number/string ids compare equal', async () => {
+  await withDb({
+    getBoardItemForVote: async () => openItem(),
+    builderHoldsRankActive: async () => true,
+    getBoardItemAuthor: async () => 42, // Postgres hands back a number; the voter carries a string
+    insertBoardVote: async () => { throw new Error('must not be reached'); },
+  }, async () => {
+    const out = await castVote({ itemId: 11, voterId: '42', direction: 'yes' });
+    assert.deepEqual(out, { ok: false, reason: 'anti_self_vote' });
+  });
+});
+
+test('closed and expired items refuse a vote, each with its own name', async () => {
+  await withDb({
+    getBoardItemForVote: async () => openItem({ closed_at: 't', outcome: 'passed' }),
+  }, async () => {
+    assert.deepEqual(await castVote({ itemId: 11, voterId: '42', direction: 'yes' }),
+      { ok: false, reason: 'item_closed' });
+  });
+  await withDb({
+    getBoardItemForVote: async () => openItem({ expired: true }),
+  }, async () => {
+    // The gap between expiry and the R11 sweep: a vote after time never lands.
+    assert.deepEqual(await castVote({ itemId: 11, voterId: '42', direction: 'yes' }),
+      { ok: false, reason: 'vote_window_expired' });
+  });
+  await withDb({ getBoardItemForVote: async () => null }, async () => {
+    assert.deepEqual(await castVote({ itemId: 999, voterId: '42', direction: 'yes' }),
+      { ok: false, reason: 'item_not_found' });
+  });
+});
+
+test('idempotent: a double-cast is ONE vote and ONE karma line', async () => {
+  const karma = [];
+  const standing = { id: '1', item_id: '11', voter_id: '42', direction: 'yes' };
+  let hasVote = false;
+  await withDb({
+    getBoardItemForVote: async () => openItem(),
+    builderHoldsRankActive: async () => true,
+    getBoardItemAuthor: async () => '7',
+    insertBoardVote: async (args) => (hasVote ? null : (hasVote = true, { ...standing, ...args })),
+    getBoardVote: async () => standing,
+    insertVoteKarma: async (args) => { karma.push(args); },
+  }, async () => {
+    const first = await castVote({ itemId: 11, voterId: '42', direction: 'yes' });
+    const second = await castVote({ itemId: 11, voterId: '42', direction: 'yes' });
+    assert.equal(first.fresh, true);
+    assert.equal(second.fresh, false);
+    assert.deepEqual(second.vote, standing, 'the re-cast returns the standing vote');
+    assert.equal(karma.length, 1, 'karma rode the fresh insert only');
+  });
+});
+
+test('an invalid payload is refused before ANY db read', async () => {
+  await withDb({
+    getBoardItemForVote: async () => { throw new Error('must not be reached'); },
+  }, async () => {
+    assert.equal((await castVote({ itemId: 11, voterId: '42', direction: 'no', reasonMd: 'x' })).reason,
+      'objection_needs_section');
+    assert.equal((await castVote({ itemId: 'nope', voterId: '42', direction: 'yes' })).reason,
+      'item_not_found');
+  });
+});
+
+// ── the structural pins ──────────────────────────────────────────────────────
+
+test('the vote INSERT targets UNIQUE(item_id, voter_id) — idempotency is the schema', () => {
+  const src = fs.readFileSync(path.join(GOV, 'db.js'), 'utf8');
+  const block = src.slice(src.indexOf('async function insertBoardVote'));
+  assert.match(block, /ON CONFLICT \(item_id, voter_id\) DO NOTHING/);
+});
+
+test('the route pin exists and names the XENOS-floored atom (the R04-carried pin)', () => {
+  const rrc = require(path.join(ROOT, 'src', 'bongos', 'route-rank-check.js'));
+  assert.equal(rrc.MODULE_EXPECTED_RANKS.government['POST /government/board/items/:itemId/votes'],
+    `${rrc.PERM_PIN_PREFIX}board.vote.cast`,
+    'the coarse gate is board.vote.cast; membership is the in-handler wall');
+});
+
+// ── author karma on ratification (declared here, fired by R10's close) ───────
+
+test('the author-ratification karma mirrors KARMA_RATIFY_DELTA (+3, not the stale +5)', () => {
+  const { KARMA_RATIFY_DELTA } = require(path.join(ROOT, 'modules', 'ideas', 'inbox.js'));
+  assert.equal(AUTHOR_RATIFY_KARMA_DELTA, KARMA_RATIFY_DELTA,
+    'board ratification pays what criterion-proposal ratification pays — one number, held equal here');
+  assert.equal(AUTHOR_RATIFY_KARMA_DELTA, 3, 'V3.R28 tuned this down from +5; do not copy the stale docs');
+});
+
+test('awardAuthorRatifyKarma pays once per item, and nobody when there is no author', async () => {
+  const paid = [];
+  await withDb({
+    getBoardItemAuthor: async () => '7',
+    insertAuthorRatifyKarma: async (args) => { paid.push(args); return paid.length === 1; }, // second call: reason exists
+  }, async () => {
+    const first = await awardAuthorRatifyKarma({ id: '11', subject_type: 'full_idea', subject_id: '7' });
+    const second = await awardAuthorRatifyKarma({ id: '11', subject_type: 'full_idea', subject_id: '7' });
+    assert.deepEqual(first, { paid: true, karma_delta: AUTHOR_RATIFY_KARMA_DELTA });
+    assert.deepEqual(second, { paid: false, reason: 'already_paid' }, 'a re-driven close never double-pays');
+  });
+  assert.deepEqual(paid[0], { authorId: '7', itemId: '11', delta: AUTHOR_RATIFY_KARMA_DELTA });
+
+  await withDb({
+    getBoardItemAuthor: async () => null,
+    insertAuthorRatifyKarma: async () => { throw new Error('must not be reached'); },
+  }, async () => {
+    assert.deepEqual(await awardAuthorRatifyKarma({ id: '12' }), { paid: false, reason: 'no_author' });
+  });
+});
+
+test('the ratify-karma INSERT is one atomic WHERE-NOT-EXISTS statement (idempotency in the SQL)', () => {
+  const src = fs.readFileSync(path.join(GOV, 'db.js'), 'utf8');
+  const block = src.slice(src.indexOf('async function insertAuthorRatifyKarma'), src.indexOf('async function insertVoteKarma'));
+  assert.match(block, /WHERE NOT EXISTS/, 'the predicate is the guard — karma_log has no unique constraint');
+  assert.match(block, /board\.item\.ratified:/, 'the per-item reason key is the idempotency key');
+});

package/tests/government_board_window.mjs

@@ -0,0 +1,144 @@
+// tests/government_board_window.mjs — a window opens automatically when a Full
+// Idea passes the grade (BV1.R07 of goal 1000069, ADR 0175 §5).
+//
+// DB-free: the pure bar gate is exercised directly; the open path runs against
+// a monkeypatched db module (the government_board_membership.mjs idiom). The
+// invariants that matter:
+//
+//   1. THE BAR IS THE SAME ONE THE CREDIT LANE USES — ADR 0175 §5 pins the
+//      window gate to economy's IDEA_FULL_PASS_BAR. board.js may not import
+//      economy (ADR 0083), so the two constants are held equal HERE — the
+//      no-second-list-that-drifts discipline, enforced by test.
+//   2. A SUB-BAR IDEA NEVER REACHES THE BOARD — refused inside board.js, not
+//      by trusting the caller, and without touching the db.
+//   3. THE CONSTITUTION IS SNAPSHOTTED — the open passes R05's sanitized board
+//      block, so an amendment cannot rewrite how an already-open item closes.
+//   4. THE IDEMPOTENCY IS STRUCTURAL — the INSERT targets government_003's
+//      partial unique index; a losing racer gets the existing open item back.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+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 board = require(path.join(GOV, 'board.js'));
+const db = require(path.join(GOV, 'db.js'));
+const { BOARD_DEFAULTS } = require(path.join(GOV, 'config.js'));
+const credits = require(path.join(ROOT, 'modules', 'economy', 'credits.js'));
+
+const { FULL_IDEA_PASS_BAR, ideaPassesBar, openWindowForFullIdea } = board;
+
+// ── invariant 1: one bar, two modules, held equal by this line ──────────────
+
+test('the window bar IS the credit-lane bar (ADR 0175 §5 — no second list that drifts)', () => {
+  assert.equal(FULL_IDEA_PASS_BAR, credits.IDEA_FULL_PASS_BAR,
+    'board.js and economy/credits.js must gate on the SAME completeness bar; '
+    + 'if the bar becomes policy, move BOTH reads to one config surface in the same change');
+});
+
+// ── invariant 2: the pure gate, fail-closed ─────────────────────────────────
+
+test('ideaPassesBar: the bar passes at exactly 60, and every unscorable shape fails closed', () => {
+  assert.equal(ideaPassesBar(FULL_IDEA_PASS_BAR), true, 'the bar itself passes (>=)');
+  assert.equal(ideaPassesBar(100), true);
+  assert.equal(ideaPassesBar(FULL_IDEA_PASS_BAR - 1), false);
+  for (const bad of [null, undefined, NaN, 'sixty', '', {}, [], -1, Infinity]) {
+    assert.equal(ideaPassesBar(bad), Number.isFinite(Number(bad)) && Number(bad) >= FULL_IDEA_PASS_BAR ? true : false,
+      `${String(bad)} must not reach the board`);
+  }
+  // "not scored" and "could not be scored" look the same (R142) — both stay off the board.
+  assert.equal(ideaPassesBar(null), false);
+});
+
+// ── the open path, against a stubbed db ─────────────────────────────────────
+
+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; }
+}
+
+test('a sub-bar idea is refused WITHOUT touching the db', async () => {
+  await withDb({
+    openBoardItem: async () => { throw new Error('must not be called'); },
+    getOpenBoardItem: async () => { throw new Error('must not be called'); },
+  }, async () => {
+    assert.deepEqual(await openWindowForFullIdea({ ideaId: 7, completenessScore: 59 }),
+      { opened: false, reason: 'below_bar' });
+    assert.deepEqual(await openWindowForFullIdea({ ideaId: 7, completenessScore: null }),
+      { opened: false, reason: 'below_bar' });
+  });
+});
+
+test('an unidentifiable idea id is refused before the bar is even consulted', async () => {
+  await withDb({ openBoardItem: async () => { throw new Error('must not be called'); } }, async () => {
+    for (const bad of [undefined, null, 0, -3, 'seven', NaN]) {
+      assert.deepEqual(await openWindowForFullIdea({ ideaId: bad, completenessScore: 100 }),
+        { opened: false, reason: 'bad_subject' }, `${String(bad)} names no subject`);
+    }
+  });
+});
+
+test('a passing idea opens a window carrying the SANITIZED constitution snapshot', async () => {
+  let got = null;
+  await withDb({
+    openBoardItem: async (args) => { got = args; return { id: '11', subject_type: 'full_idea', subject_id: '7', closes_at: null }; },
+  }, async () => {
+    const out = await openWindowForFullIdea({ ideaId: 7, completenessScore: 82 });
+    assert.equal(out.opened, true);
+    assert.equal(out.item.id, '11');
+  });
+  assert.equal(got.subjectType, 'full_idea');
+  assert.equal(got.subjectId, 7);
+  assert.equal(got.openedBy, null, 'the grade opened this, nobody did (government_003)');
+  // This checkout has no config/government.json, so the snapshot is the neutral
+  // starter's board block — which R05 pins equal to BOARD_DEFAULTS (monarchy).
+  assert.deepEqual(got.constitution, BOARD_DEFAULTS,
+    'the snapshot is R05\'s sanitized board block, not raw file contents');
+  assert.equal(got.windowMinutes, BOARD_DEFAULTS.window_minutes,
+    'monarchy has no clock — closes_at stays NULL until a project configures a sitting');
+});
+
+test('a lost race returns the EXISTING open item, opened:false', async () => {
+  const existing = { id: '4', subject_type: 'full_idea', subject_id: '7', closed_at: null };
+  await withDb({
+    openBoardItem: async () => null, // the partial-unique-index conflict path
+    getOpenBoardItem: async (type, id) => {
+      assert.equal(type, 'full_idea'); assert.equal(id, 7);
+      return existing;
+    },
+  }, async () => {
+    const out = await openWindowForFullIdea({ ideaId: 7, completenessScore: 82 });
+    assert.deepEqual(out, { opened: false, reason: 'already_open', item: existing });
+  });
+});
+
+// ── the structural idempotency + clock, pinned as SQL source ────────────────
+
+test('the INSERT targets the partial unique index and the DATABASE clock', () => {
+  const src = fs.readFileSync(path.join(GOV, 'db.js'), 'utf8');
+  const start = src.indexOf('async function openBoardItem');
+  assert.ok(start > -1);
+  const block = src.slice(start, src.indexOf('async function getOpenBoardItem'));
+  assert.match(block, /ON CONFLICT \(subject_type, subject_id\) WHERE closed_at IS NULL DO NOTHING/,
+    'idempotency must be the partial unique index, not a SELECT-then-INSERT race');
+  assert.match(block, /now\(\) \+ make_interval/,
+    'closes_at comes from the database clock — absolute, so a config change never moves an open deadline');
+});
+
+// ── the port carries it ──────────────────────────────────────────────────────
+
+test('the government port exposes openBoardWindowForIdea for the ideas capture path', () => {
+  const routes = require(path.join(GOV, 'routes', 'government.js'));
+  routes(); // registration is hasProvider-guarded — safe to call again
+  const api = require(path.join(ROOT, 'src', 'module-api.js'));
+  const port = api.resolveOptional('government');
+  assert.equal(typeof port.openBoardWindowForIdea, 'function');
+  assert.equal(port.openBoardWindowForIdea, board.openWindowForFullIdea,
+    'the port method IS board.js\'s — no wrapper that could drift the bar gate');
+});

package/tests/government_routes.mjs

@@ -64,12 +64,34 @@ test('the routes file declares the full R110 surface', () => {
   for (const key of wanted) assert.ok(declared.has(key), `missing route ${key}`);
 });
 
-test('every /governance route gates on government.manage via REAL middleware', () => {
+test('every /governance route gates via REAL middleware on exactly its PINNED atom', () => {
+  // Until R08 every route here gated on government.manage and this test said so
+  // literally. The Board Room's vote route (R08 of goal 1000069) gates on the
+  // deliberately XENOS-floored board.vote.cast — the atom is the coarse gate,
+  // membership is the in-handler wall — so the invariant generalizes: each
+  // route's middleware must declare EXACTLY the atom its pin promises, and the
+  // rank each classifies to must be that atom's real catalog floor. This is
+  // STRICTER than the old literal: a new route cannot sneak in on a different
+  // atom without also changing the pin table, which is the reviewed surface.
   assert.ok(classified.length > 0, 'no /government routes found to classify');
+  const pins = rrc.MODULE_EXPECTED_RANKS.government;
   for (const r of classified) {
     assert.equal(r.via, 'middleware', `${r.key}: gate must be middleware, not an annotation`);
-    assert.deepEqual(r.perms, ['government.manage'], `${r.key}: must gate on exactly government.manage`);
-    assert.equal(r.rank, 'archon', `${r.key}: government.manage floors at archon`);
+    const pinned = pins[r.key];
+    assert.ok(pinned && pinned.startsWith(rrc.PERM_PIN_PREFIX), `${r.key}: must carry a perm pin`);
+    const atom = pinned.slice(rrc.PERM_PIN_PREFIX.length);
+    assert.deepEqual(r.perms, [atom], `${r.key}: must gate on exactly its pinned atom (${atom})`);
+    // The auditor speaks rank LABELS, not raw floors (route-rank-check.js
+    // FLOOR_LABEL): both sub-Metic floors collapse to 'any-builder' — a label
+    // that may under-report strictness, never over-report it.
+    const FLOOR_LABEL = { xenos: 'any-builder', thetes: 'any-builder', metic: 'metic+archon', archon: 'archon' };
+    const floor = (catalog.byKey(atom) || {}).floor;
+    assert.equal(r.rank, FLOOR_LABEL[floor], `${r.key}: classifies to ${atom}'s floor label (${FLOOR_LABEL[floor]})`);
+  }
+  // The admin surface's own rule survives the generalization, stated directly:
+  // everything that is not a board route still gates on government.manage.
+  for (const r of classified.filter((x) => !x.key.includes('/board/'))) {
+    assert.deepEqual(r.perms, ['government.manage'], `${r.key}: the admin surface gates on the manage atom`);
   }
 });
 
@@ -78,8 +100,7 @@ test('every declared /governance route is pinned, and every pin exists (both dir
   assert.ok(pins, 'MODULE_EXPECTED_RANKS has no government block');
   const declared = new Set(classified.map((r) => r.key));
   for (const key of declared) {
-    assert.equal(pins[key], `${rrc.PERM_PIN_PREFIX}government.manage`,
-      `${key} must be pinned to perm:government.manage`);
+    assert.ok(pins[key], `${key} must be pinned (atom equality is asserted above)`);
   }
   for (const key of Object.keys(pins)) {
     assert.ok(declared.has(key), `pin ${key} names a route the file no longer declares`);

package/tests/hall_palette.mjs

@@ -111,6 +111,16 @@ test('Tasks tab anchors exist in work.js makeTabs', () => {
   }
 });
 
+test('Government section anchors exist in government.js makeTabs (the R15 three-section IA)', () => {
+  const ids = [...read('government.js').matchAll(/\{ id: '([a-z-]+)', label: '[^']*', panel:/g)].map((m) => m[1]);
+  assert.ok(ids.length === 3, `sanity: found the three government tabs (${ids})`);
+  const declared = declaredHrefs((x) => x.startsWith('/government#'));
+  assert.ok(declared.length === 3, 'palette declares the three Government sections');
+  for (const h of declared) {
+    assert.ok(ids.includes(h.split('#')[1]), `${h} must be a real government.js tab id`);
+  }
+});
+
 test('Settings panel anchors exist in settings.js RAIL_GROUPS', () => {
   // RAIL_GROUPS is derived: RAIL_ITEMS.map(i => i.id).concat('extensions').
   const src = read('settings.js');