@bongos/core 1.19.251 → 1.19.253

package/tests/government_board_membership_db.mjs

@@ -0,0 +1,150 @@
+// tests/government_board_membership_db.mjs — the board franchise against a REAL
+// Postgres (task 1003094).
+//
+// WHY THIS EXISTS BESIDE THE DB-FREE government_board_membership.mjs. That file
+// covers the pure parser and the resolvers against a stubbed db, which is where
+// the grammar lives. It cannot cover the half this task actually changed: the
+// SQL. `WHERE rank_key = $1` became `WHERE rank_key = ANY($1)` plus a DISTINCT,
+// and a FRANCHISE bug is precisely the kind a stub agrees with and the database
+// does not — the stub returns whatever the test author imagined the query means.
+//
+// What only real SQL can answer:
+//   * does `rank:metic+` genuinely seat the Archon (the regression that cost an
+//     owner their seat on their own constitution);
+//   * do the two STRUCTURAL filters survive the rewrite — a deactivated builder
+//     and a machine principal must still never govern, because a widened
+//     franchise that also admits a bot is a worse bug than the one being fixed;
+//   * does DISTINCT actually hold when a builder matches through two keys — a
+//     double-counted member silently raises the bar a consent vote must clear.
+//
+// It SELF-SKIPS (exit 0) with no reachable Postgres, and is listed in
+// run-unit-tests.js's INTEGRATION set so the DB-free lane never runs it.
+//
+// Run:  DATABASE_URL=postgres://... node tests/government_board_membership_db.mjs
+//
+// It creates its own throwaway `builders` / `government_builder_ranks` rows at
+// ids far above any real row, and deletes them at the end.
+
+import pg from 'pg';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL || undefined });
+
+try {
+  await pool.query('SELECT 1');
+} catch (e) {
+  console.log(`government_board_membership_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}). Set DATABASE_URL to run.`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+let passed = 0, failed = 0;
+async function t(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL ${name}\n     ${e.message}`); }
+}
+const assert = (await import('node:assert')).strict;
+
+// Minimal stand-ins ONLY when the real tables are absent (throwaway container);
+// against a migrated database these are no-ops and the real tables are used.
+await pool.query(`
+  CREATE TABLE IF NOT EXISTS builders (
+    id bigserial PRIMARY KEY, github_login text, display_name text,
+    status text DEFAULT 'active', system_role text);
+  CREATE TABLE IF NOT EXISTS government_builder_ranks (
+    builder_id bigint, rank_key text);
+`);
+
+// Ids far above any real row, and every login prefixed, so cleanup is exact and
+// this can never touch a real builder or a real rank assignment.
+const B = 990000000;
+const ID = { xenos: B + 1, thetes: B + 2, metic: B + 3, archon: B + 4, gone: B + 5, bot: B + 6, ops: B + 7 };
+const cleanup = async () => {
+  await pool.query('DELETE FROM government_builder_ranks WHERE builder_id >= $1', [B]);
+  await pool.query('DELETE FROM builders WHERE id >= $1', [B]);
+};
+await cleanup();
+await pool.query(`INSERT INTO builders (id, github_login, display_name, status, system_role) VALUES
+  ($1,'gbmdb-x','Xenos','active',NULL),($2,'gbmdb-t','Thetes','active',NULL),
+  ($3,'gbmdb-m','Metic','active',NULL),($4,'gbmdb-a','Archon','active',NULL),
+  ($5,'gbmdb-gone','Deactivated Archon','inactive',NULL),
+  ($6,'gbmdb-bot','A Machine','active','bfg'),
+  ($7,'gbmdb-ops','Custom Ops','active',NULL)`,
+[ID.xenos, ID.thetes, ID.metic, ID.archon, ID.gone, ID.bot, ID.ops]);
+await pool.query(`INSERT INTO government_builder_ranks (builder_id, rank_key) VALUES
+  ($1,'xenos'),($2,'thetes'),($3,'metic'),($4,'archon'),($5,'archon'),($6,'archon'),($7,'gbmdb-ops-rank')`,
+[ID.xenos, ID.thetes, ID.metic, ID.archon, ID.gone, ID.bot, ID.ops]);
+
+const api = require(process.cwd() + '/src/module-api.js');
+api.pool.query = (...a) => pool.query(...a);
+const { resolveBoardMembers, isBoardMember } = require(process.cwd() + '/modules/government/board-membership.js');
+
+const board = (membership) => ({ membership, pass_rule: 'consent', window_minutes: null, close_early_on_full_turnout: true });
+const logins = async (m) => (await resolveBoardMembers(board(m)))
+  .filter((r) => Number(r.builder_id) >= B)          // ignore any real rows on a migrated db
+  .map((r) => r.github_login.replace('gbmdb-', ''));
+
+console.log('the predicate against real SQL');
+
+await t('bare rank:archon is unchanged — exactly archons', async () => {
+  assert.deepEqual(await logins('rank:archon'), ['a']);
+});
+
+await t('THE BUG: bare rank:metic seats metics ONLY (still true, deliberately)', async () => {
+  assert.deepEqual(await logins('rank:metic'), ['m']);
+});
+
+await t('THE FIX: rank:metic+ seats metic AND archon', async () => {
+  assert.deepEqual(await logins('rank:metic+'), ['m', 'a']);
+});
+
+await t('rank:xenos+ is how you say everyone', async () => {
+  assert.deepEqual(await logins('rank:xenos+'), ['x', 't', 'm', 'a']);
+});
+
+await t('bare rank:xenos really does seat NEWCOMERS ONLY — the library\'s lie', async () => {
+  assert.deepEqual(await logins('rank:xenos'), ['x']);
+});
+
+await t('a comma union works, and composes with the ladder', async () => {
+  assert.deepEqual(await logins('rank:metic,archon'), ['m', 'a']);
+  assert.deepEqual(await logins('rank:metic+,gbmdb-ops-rank'), ['m', 'a', 'ops']);
+});
+
+await t('the deactivated and the machine are STILL excluded under the widened form', async () => {
+  // The two structural filters must survive the ANY() rewrite — a widened
+  // franchise that also admits a bot or a departed builder is a worse bug.
+  const l = await logins('rank:xenos+');
+  assert.ok(!l.includes('gone'), 'a deactivated builder never governs');
+  assert.ok(!l.includes('bot'), 'a machine principal never governs');
+});
+
+await t('no duplicate rows when a builder matches through two keys', async () => {
+  await pool.query('INSERT INTO government_builder_ranks (builder_id, rank_key) VALUES ($1, $2)', [ID.archon, 'gbmdb-ops-rank']);
+  try {
+    const l = await logins('rank:archon,gbmdb-ops-rank');
+    assert.deepEqual(l.filter((x) => x === 'a').length, 1,
+      'DISTINCT holds — a double-counted member silently raises the consent bar');
+  } finally {
+    await pool.query("DELETE FROM government_builder_ranks WHERE builder_id=$1 AND rank_key='gbmdb-ops-rank'", [ID.archon]);
+  }
+});
+
+await t('isBoardMember agrees with resolveBoardMembers on every form', async () => {
+  assert.equal(await isBoardMember(ID.archon, board('rank:metic+')), true, 'THE REGRESSION: the Archon keeps their seat');
+  assert.equal(await isBoardMember(ID.archon, board('rank:metic')), false, 'and the bare form still excludes them');
+  assert.equal(await isBoardMember(ID.metic, board('rank:metic+')), true);
+  assert.equal(await isBoardMember(ID.xenos, board('rank:xenos+')), true);
+  assert.equal(await isBoardMember(ID.gone, board('rank:xenos+')), false, 'deactivated');
+  assert.equal(await isBoardMember(ID.bot, board('rank:xenos+')), false, 'machine');
+});
+
+await t('an unparseable predicate still seats nobody against a real db', async () => {
+  assert.deepEqual(await logins('rank:ops+'), [], '+ on a non-ladder rank fails closed');
+  assert.deepEqual(await logins('nonsense'), []);
+});
+
+await cleanup();
+console.log(`\n${passed} passed, ${failed} failed`);
+await pool.end();
+process.exit(failed ? 1 : 0);

package/tests/government_board_vote.mjs

@@ -84,8 +84,10 @@ test('the happy path: a member yes is recorded fresh, with its +1 karma', async
   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
+    builderHoldsRankActive: async (builderId, rankKeys) =>
+      // The db read takes a SET since task 1003094; the REAL membership parse
+      // resolved 'rank:archon' from the snapshot to the one-element set ['archon'].
+      builderId === '42' && rankKeys.includes('archon'),
     getBoardItemAuthor: async () => '7',          // someone else authored the idea
     insertBoardVote: async (args) => { insertArgs = args; return { id: '1', ...args }; },
     insertVoteKarma: async (args) => { karma.push(args); },
@@ -105,7 +107,7 @@ test('membership is the SNAPSHOT\'s rule: a rank the snapshot does not name is r
   // they hold A rank — just not the snapshotted one.
   await withDb({
     getBoardItemForVote: async () => openItem(),
-    builderHoldsRankActive: async (builderId, rankKey) => rankKey === 'metic', // holds metic, not archon
+    builderHoldsRankActive: async (builderId, rankKeys) => rankKeys.includes('metic'), // holds metic, not archon
     getBoardItemAuthor: async () => { throw new Error('must not be reached'); },
     insertBoardVote: async () => { throw new Error('must not be reached'); },
   }, async () => {

package/tests/government_charter_library.mjs

@@ -67,7 +67,12 @@ test('the library presents all seven structures with honest selectable marks (cl
   assert.equal(selectableTrue, 4, 'monarchy, timocratic republic, direct democracy, foundation — the config-expressible four');
   const trueBlocks = lib.split('selectable: true').slice(1);
   for (const b of trueBlocks) {
-    assert.ok(b.slice(0, 200).includes('how:'), 'a selectable structure names its configuration');
+    // Window widened from 200 (task 1003095): a selectable entry now also carries
+    // `predicate` + `seatsRanks` ahead of `how`, which the test below checks
+    // against the real parser. Cut to the next entry rather than a magic length,
+    // so adding another field cannot silently push `how` out of view again.
+    const entry = b.split('{ key:')[0];
+    assert.ok(entry.includes('how:'), 'a selectable structure names its configuration');
   }
   assert.match(client, /recommended at your headcount/, 'the one live datum is rendered');
   assert.match(client, /c\.key === recommendedKey/, "the pill is driven by the SERVER's recommendation, never re-derived client-side");
@@ -75,3 +80,104 @@ test('the library presents all seven structures with honest selectable marks (cl
     assert.ok(client.includes(`name: '${t}'`), `trajectory ${t} present`);
   }
 });
+
+
+// ── R26's ask, made mechanical (task 1003095) ───────────────────────────────
+//
+// The library is the ONLY place in the product that tells an owner WHAT TO TYPE.
+// That makes a wrong `how` line worse than no library: an owner who followed
+// `membership rank:xenos (everyone)` under the old exact-match grammar handed
+// the board to newcomers and locked themselves out. R26's done-when asks for
+// "selectable-today is honestly marked" — prose cannot be honest by assertion,
+// so this checks every selectable charter's predicate against the REAL parser.
+//
+// Deliberately NOT a copy of the intent: it imports
+// modules/government/membership-predicate.js, the same module the resolver and
+// the config sanitizer use. If the grammar moves underneath this page again,
+// this test reds instead of the page quietly lying.
+
+function charterEntries() {
+  const client = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/government.js'), 'utf8');
+  const lib = client.slice(client.indexOf('const CHARTERS'), client.indexOf('const TRAJECTORIES'));
+  const out = [];
+  for (const block of lib.split('{ key:').slice(1)) {
+    const key = /^\s*'([a-z-]+)'/.exec(block);
+    if (!key) continue;
+    const selectable = /selectable: (true|false)/.exec(block);
+    const predicate = /predicate: (?:'([^']*)'|null)/.exec(block);
+    const seats = /seatsRanks: (?:\[([^\]]*)\]|null)/.exec(block);
+    const how = /how: '([^']*)'/.exec(block) || /how: "([^"]*)"/.exec(block);
+    out.push({
+      key: key[1],
+      selectable: selectable ? selectable[1] === 'true' : null,
+      predicate: predicate ? (predicate[1] ?? null) : undefined,
+      seatsRanks: seats ? (seats[1] ? seats[1].split(',').map((x) => x.trim().replace(/'/g, '')) : null) : undefined,
+      how: how ? how[1] : null,
+    });
+  }
+  return out;
+}
+
+test('every SELECTABLE charter names a predicate the real resolver would actually seat as described', () => {
+  const { parseMembershipPredicate } = require(path.join(GOV, 'membership-predicate.js'));
+  const entries = charterEntries();
+  assert.equal(entries.length, 7, 'sanity: parsed all seven structures');
+
+  for (const c of entries.filter((e) => e.selectable)) {
+    assert.notEqual(c.predicate, undefined, `${c.key}: a selectable charter must declare a predicate field (null = owner-chosen)`);
+    assert.notEqual(c.seatsRanks, undefined, `${c.key}: a selectable charter must declare seatsRanks`);
+
+    if (c.predicate === null) {
+      // Owner-chosen (Foundation's custom trustee rank). Honest rather than
+      // unchecked: it must SAY the predicate is theirs to name.
+      assert.equal(c.seatsRanks, null, `${c.key}: an owner-chosen predicate cannot claim a fixed seat list`);
+      assert.match(c.how, /custom/i, `${c.key}: must say the rank is one the owner creates`);
+      continue;
+    }
+
+    const parsed = parseMembershipPredicate(c.predicate);
+    assert.ok(parsed, `${c.key}: "${c.predicate}" does not parse — this page would tell an owner to type something that seats NOBODY`);
+    assert.deepEqual([...parsed.rankKeys], c.seatsRanks,
+      `${c.key}: "${c.predicate}" seats ${JSON.stringify([...parsed.rankKeys])}, but the library claims ${JSON.stringify(c.seatsRanks)}`);
+    assert.ok(c.how.includes(c.predicate),
+      `${c.key}: the how-line must contain the exact predicate an owner types (expected "${c.predicate}" in "${c.how}")`);
+  }
+});
+
+test('THE REGRESSION: the two lines that were untrue now seat what they say', () => {
+  const { parseMembershipPredicate } = require(path.join(GOV, 'membership-predicate.js'));
+  const by = Object.fromEntries(charterEntries().map((c) => [c.key, c]));
+
+  // Direct Democracy said "rank:xenos (everyone)" and seated NEWCOMERS ONLY.
+  const dd = by['direct-democracy'];
+  assert.equal(dd.predicate, 'rank:xenos+');
+  assert.deepEqual([...parseMembershipPredicate(dd.predicate).rankKeys], ['xenos', 'thetes', 'metic', 'archon'],
+    'every builder, which is what "everyone" has to mean');
+  assert.ok(!/rank:xenos[^+]/.test(dd.how), 'the how-line must not show the bare form that caused the bug');
+
+  // Timocratic Republic was true as far as it went and silent about Archons.
+  const tr = by['timocratic-republic'];
+  assert.equal(tr.predicate, 'rank:metic+');
+  assert.deepEqual([...parseMembershipPredicate(tr.predicate).rankKeys], ['metic', 'archon']);
+  assert.match(tr.how, /Archons included/i, 'the omission that made it quietly surprising is now stated');
+});
+
+test('the recommendation names a charter the config can actually express', () => {
+  // The library recommended "a consent circle of all trusted members" at
+  // headcount 3–8 — a phrase with no predicate behind it under exact-match. The
+  // recommendation must point at a charter this page can tell an owner to type.
+  const by = Object.fromEntries(charterEntries().map((c) => [c.key, c]));
+  for (const n of [1, 3, 8, 9, 50, 150]) {
+    const rec = recommendedCharter(n);
+    const charter = by[rec.key];
+    assert.ok(charter, `headcount ${n} recommends "${rec.key}", which is not in the library`);
+    if (charter.selectable) {
+      assert.ok(charter.predicate !== undefined,
+        `headcount ${n} recommends selectable "${rec.key}" — it must carry a checkable predicate`);
+    }
+  }
+  const circle = recommendedCharter(3);
+  assert.equal(circle.key, 'direct-democracy');
+  assert.match(circle.why, /rank:xenos\+/,
+    'the why must name the predicate that delivers it, not a phrase with nothing behind it');
+});

package/tests/government_constitution_view.mjs

@@ -86,3 +86,56 @@ test('the read rides the vote atom, and the client renders the SERVER value (sou
   assert.ok(!/'first_ratifier'[^]*hardcod/i.test(client), 'sanity');
   assert.match(client, /loadConstitution\(\)/, 'the panel loads for everyone the page admits');
 });
+
+// ── the hall's membership prose mirrors the server parser (task 1003094) ─────
+//
+// Browser code cannot import the server module (the established pattern here —
+// the five Full Idea section labels are mirrored the same way), so the hall
+// re-implements the predicate grammar to render it in plain language. Two copies
+// of a grammar is exactly the drift that produced the bug this task fixes, so
+// they are held equal here over every form.
+//
+// This matters more than a normal mirror: the Constitution panel is where an
+// owner READS who governs before deciding whether to change it. A panel that
+// misdescribes the franchise is the same failure as a resolver that mis-seats
+// it, one layer up.
+test('the hall renders every predicate form the server actually resolves', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/government.js'), 'utf8');
+
+  // Lift the browser mirror out of the IIFE and run it.
+  const ladder = /const STANDARD_LADDER = (\[[^\]]*\]);/.exec(src);
+  assert.ok(ladder, 'the hall must declare the standard ladder it expands `+` against');
+  const fn = /function membershipRankKeys\(predicate\) \{[\s\S]*?\n  \}/.exec(src);
+  assert.ok(fn, 'membershipRankKeys must be findable — this test lifts it');
+  // eslint-disable-next-line no-new-func
+  const browserKeys = new Function(`const STANDARD_LADDER = ${ladder[1]}; ${fn[0]}; return membershipRankKeys;`)();
+
+  const { parseMembershipPredicate } = require(path.join(ROOT, 'modules/government/membership-predicate.js'));
+
+  const forms = [
+    'rank:archon', 'rank:metic', 'rank:xenos', 'rank:custom-rank',
+    'rank:metic+', 'rank:xenos+', 'rank:archon+',
+    'rank:metic,archon', 'rank:metic+,ops', 'rank:archon,archon',
+    'rank:custom+', 'rank:', 'rank:metic++', 'rank:+metic', 'nonsense', '',
+    'rank:archon,', 'rank:,archon', 'rank:archon,,metic',
+  ];
+  for (const f of forms) {
+    const server = parseMembershipPredicate(f);
+    const browser = browserKeys(f);
+    assert.deepEqual(
+      browser === null ? null : browser,
+      server === null ? null : [...server.rankKeys],
+      `the hall and the server disagree about ${JSON.stringify(f)}`,
+    );
+  }
+});
+
+test('the ladder the hall expands against IS the government ladder', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/government.js'), 'utf8');
+  const { RANK_ORDER } = require(path.join(ROOT, 'modules/government/catalog.js'));
+  const m = /const STANDARD_LADDER = \[([^\]]*)\]/.exec(src);
+  assert.ok(m);
+  const hall = m[1].split(',').map((x) => x.trim().replace(/['"]/g, '')).filter(Boolean);
+  assert.deepEqual(hall, [...RANK_ORDER],
+    'a hall ladder that drifts from catalog.RANK_ORDER renders a franchise nobody has');
+});

package/tests/rank_tier_single_source.mjs

@@ -107,6 +107,15 @@ const STATIC_LADDER_FILES = [
   'modules/hall-ui/public/ranks.js',
   'modules/hall-ui/public/profile.js',
   'modules/hall-ui/public/watch.js',
+  // task 1003094: the Constitution panel expands the `rank:<key>+` membership
+  // form ("that rank and above") to render who governs in plain language, so it
+  // needs the ladder to expand against. Browser code cannot require the server
+  // module — the established mirror pattern here — and listing it in this array
+  // is what makes the copy provable rather than merely allowed. A second,
+  // government-specific pin lives in tests/government_constitution_view.mjs,
+  // which holds it against catalog.RANK_ORDER and holds the whole browser parser
+  // equal to the server one.
+  'modules/hall-ui/public/government.js',
 ];
 test('static ladder copies carry the exact canonical ladder', () => {
   for (const rel of STATIC_LADDER_FILES) {