@bongos/core 1.19.224 → 1.19.225

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`);