@bongos/core 1.20.26 → 1.20.27

package/tests/government_charter_forms.mjs

@@ -0,0 +1,283 @@
+// tests/government_charter_forms.mjs — the genesis charter and legislation
+// stages, on the real constitution (task 1004427 / BV2.PS13, spec decision D10).
+//
+// DB-free (db monkeypatched; the apply runs against a REAL temp file). The
+// invariants:
+//
+//   1. THE REAL NAMES, EACH EXPLAINED — four forms available today (Monarchy /
+//      BDFL, Timocratic Republic, Direct Democracy, Foundation), three coming
+//      later (Presidential, Cooperative, Federation); seven variables with the
+//      government doc's names. Every one carries a short plain explanation.
+//      The names are held equal to the hall's charter library, so the genesis
+//      stage and the Constitution tab can never call a form two things.
+//   2. TWO VARIABLES ARE LIVE, ONE IS ALWAYS ON, THE REST COME LATER — franchise
+//      and pass rule are the real board block; loyalty of enforcement is always
+//      on; nothing that is not built claims to be.
+//   3. THE NAME FOLLOWS THE SETTINGS — read from what the constitution SEATS,
+//      so two spellings of one board read the same; anything else is "custom".
+//   4. APPLYING WRITES THE REAL CONSTITUTION THROUGH ITS AMENDMENT PATH — the
+//      choice becomes an ordinary amendment, validated strictly, decided under
+//      the rule in force; under monarchy the founder's yes applies it.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import vm from 'node:vm';
+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 charter = require(path.join(GOV, 'charter.js'));
+const board = require(path.join(GOV, 'board.js'));
+const db = require(path.join(GOV, 'db.js'));
+const config = require(path.join(GOV, 'config.js'));
+const { parseMembershipPredicate } = require(path.join(GOV, 'membership-predicate.js'));
+
+const { FORMS, VARIABLES, FRANCHISE_OPTIONS, PASS_RULE_OPTIONS, TRAJECTORIES, readCharter, buildCharterProposal } = charter;
+
+const MONARCHY = Object.freeze({
+  membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true,
+});
+
+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; }
+}
+
+// A plain explanation: present, a sentence or two, and not merely the name again.
+function assertExplained(entry, what) {
+  assert.equal(typeof entry.explanation, 'string', `${what} carries an explanation`);
+  const sentences = entry.explanation.split(/[.!?](\s|$)/).filter((s) => s && s.trim()).length;
+  assert.ok(entry.explanation.length >= 30 && sentences >= 1 && sentences <= 3,
+    `${what}: one or two plain sentences, got "${entry.explanation}"`);
+  assert.notEqual(entry.explanation.trim().toLowerCase(), String(entry.name).toLowerCase());
+}
+
+// ── invariant 1: the real names, each explained ──────────────────────────────
+
+test('the forms carry the real academic names — four today, three coming later', () => {
+  assert.deepEqual(FORMS.filter((f) => f.available).map((f) => f.name),
+    ['Monarchy / BDFL', 'Timocratic Republic', 'Direct Democracy', 'Foundation']);
+  assert.deepEqual(FORMS.filter((f) => !f.available).map((f) => f.name),
+    ['Presidential', 'Cooperative', 'Federation']);
+  for (const f of FORMS) assertExplained(f, `form ${f.key}`);
+  assert.ok(Object.isFrozen(FORMS) && FORMS.every(Object.isFrozen));
+});
+
+test('the variables are the government doc\'s seven, each with its question and explanation', () => {
+  assert.deepEqual(VARIABLES.map((v) => v.key), [
+    'franchise', 'pass_rule', 'veto_points', 'executive_legislative', 'judicial_review',
+    'loyalty_of_enforcement', 'trajectory',
+  ]);
+  assert.deepEqual(VARIABLES.map((v) => v.name), [
+    'Franchise', 'Pass rule (winning coalition)', 'Veto points', 'Executive–legislative relationship',
+    'Judicial review', 'Loyalty of enforcement', 'Trajectory',
+  ]);
+  for (const v of VARIABLES) {
+    assertExplained(v, `variable ${v.key}`);
+    assert.ok(typeof v.question === 'string' && v.question.endsWith('?'), `${v.key} asks its question plainly`);
+  }
+  for (const o of [...FRANCHISE_OPTIONS, ...PASS_RULE_OPTIONS, ...TRAJECTORIES]) assertExplained(o, `option ${o.key}`);
+  assert.deepEqual(TRAJECTORIES.map((t) => t.name), ['Locked', 'Laddered', 'Scheduled']);
+});
+
+test('the names are the hall charter library\'s names — one form, one name, everywhere', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'government.js'), 'utf8');
+  const block = src.slice(src.indexOf('const CHARTERS = ['), src.indexOf('const TRAJECTORIES = ['));
+  const hall = [...block.matchAll(/key: '([^']+)', name: '([^']+)', selectable: (true|false)/g)]
+    .map((m) => ({ key: m[1], name: m[2], selectable: m[3] === 'true' }));
+  assert.equal(hall.length, 7, 'sanity: the hall library lists seven structures');
+  const byKey = new Map(hall.map((h) => [h.key, h]));
+  for (const f of FORMS) {
+    const h = byKey.get(f.key);
+    assert.ok(h, `the hall library knows ${f.key}`);
+    assert.equal(f.name, h.name, `${f.key} has one name`);
+    assert.equal(f.available, h.selectable, `${f.key}: available here iff selectable there`);
+  }
+  const trajectories = src.slice(src.indexOf('const TRAJECTORIES = ['), src.indexOf('const LADDER ='));
+  for (const t of TRAJECTORIES) assert.ok(trajectories.includes(`name: '${t.name}'`), `trajectory ${t.name} matches the hall`);
+});
+
+// ── invariant 2: what is live, what is always on, what comes later ───────────
+
+test('franchise and pass rule are live; loyalty of enforcement is always on; the rest come later', () => {
+  const status = Object.fromEntries(VARIABLES.map((v) => [v.key, v.status]));
+  assert.deepEqual(status, {
+    franchise: 'live', pass_rule: 'live', veto_points: 'later', executive_legislative: 'later',
+    judicial_review: 'later', loyalty_of_enforcement: 'always_on', trajectory: 'later',
+  });
+  assert.deepEqual([...PASS_RULE_OPTIONS.map((o) => o.key)].sort(), [...config.PASS_RULES].sort(),
+    'every pass rule the constitution knows is offered, and nothing else');
+  for (const o of FRANCHISE_OPTIONS.filter((x) => x.predicate)) {
+    assert.ok(parseMembershipPredicate(o.predicate), `${o.key}'s predicate parses under the REAL grammar`);
+  }
+  assert.deepEqual(parseMembershipPredicate(FRANCHISE_OPTIONS.find((o) => o.key === 'everyone').predicate).rankKeys,
+    ['xenos', 'thetes', 'metic', 'archon'], '"every builder" really seats every rank (the + is load-bearing)');
+  // The band's pass-rule words (task 1004429) are these options' explanations —
+  // one sentence per rule, written once.
+  for (const o of PASS_RULE_OPTIONS) assert.equal(board.PASS_RULE_WORDS[o.key], o.explanation);
+});
+
+// ── invariant 3: the name follows the settings ───────────────────────────────
+
+test('the shipped default reads as Monarchy / BDFL, and each available form reads as itself', () => {
+  assert.equal(readCharter(config.BOARD_DEFAULTS).form, 'monarchy');
+  for (const f of FORMS.filter((x) => x.available)) {
+    const built = buildCharterProposal(MONARCHY, { form: f.key, councilRank: 'trustees' });
+    assert.equal(built.ok, true, f.key);
+    assert.equal(readCharter(built.proposal).form, f.key, `choosing ${f.key} makes the constitution read as ${f.key}`);
+  }
+});
+
+test('the name reads what the board SEATS, so two spellings of one board read the same', () => {
+  const tim = { ...MONARCHY, pass_rule: 'consent' };
+  assert.equal(readCharter({ ...tim, membership: 'rank:metic+' }).form, 'timocratic-republic');
+  assert.equal(readCharter({ ...tim, membership: 'rank:metic,archon' }).form, 'timocratic-republic');
+  assert.equal(readCharter({ ...tim, membership: 'rank:xenos+' }).form, 'direct-democracy');
+  assert.equal(readCharter({ ...tim, membership: 'rank:trustees' }).form, 'foundation');
+});
+
+test('any other combination reads "custom" — never the nearest name', () => {
+  const custom = [
+    { ...MONARCHY, pass_rule: 'consent' },                          // Archons by consent
+    { ...MONARCHY, membership: 'rank:xenos+', pass_rule: 'majority' },
+    { ...MONARCHY, membership: 'rank:metic' },                       // exactly metic, no Archons
+    { ...MONARCHY, membership: 'rank:metic+', pass_rule: 'first_ratifier' },
+    { ...MONARCHY, membership: 'not a predicate' },
+  ];
+  for (const b of custom) {
+    const r = readCharter(b);
+    assert.equal(r.form, 'custom', JSON.stringify(b));
+    assert.equal(r.name, 'Custom');
+    assertExplained(r, 'the custom reading');
+  }
+  const r = readCharter({ ...MONARCHY, membership: 'rank:xenos+', pass_rule: 'majority' });
+  assert.equal(r.franchise, 'everyone', 'the settings are still read individually');
+  assert.equal(r.pass_rule, 'majority');
+});
+
+// ── invariant 4: applying writes the real constitution via an amendment ──────
+
+test('a charter choice builds a whole, strictly-valid constitution that keeps the fields it does not set', () => {
+  const live = { ...MONARCHY, window_minutes: 90, close_early_on_full_turnout: false };
+  const out = buildCharterProposal(live, { form: 'direct-democracy' });
+  assert.equal(out.ok, true);
+  assert.deepEqual(out.proposal, {
+    membership: 'rank:xenos+', pass_rule: 'consent', window_minutes: 90, close_early_on_full_turnout: false,
+  }, 'the clock and turnout rules are not the charter\'s to change — they are kept');
+  assert.equal(board.validateProposedConstitution(out.proposal).ok, true);
+  // Legislation fine-tunes on top of a form.
+  const tuned = buildCharterProposal(live, { form: 'direct-democracy', passRule: 'majority', windowMinutes: 1440 });
+  assert.deepEqual([tuned.proposal.pass_rule, tuned.proposal.window_minutes], ['majority', 1440]);
+  assert.equal(readCharter(tuned.proposal).form, 'custom');
+});
+
+test('choices that are not real are refused by name, before anything is filed', () => {
+  const cases = [
+    [{ form: 'presidential' }, 'form_not_available'],
+    [{ form: 'anarchy' }, 'unknown_form'],
+    [{ franchise: 'the loudest' }, 'unknown_franchise'],
+    [{ franchise: 'council' }, 'council_needs_a_rank'],
+    [{ franchise: 'council', councilRank: 'metic' }, 'council_needs_a_custom_rank'],
+    [{ franchise: 'council', councilRank: 'Not A Key' }, 'council_needs_a_custom_rank'],
+    [{ passRule: 'acclamation' }, 'unknown_pass_rule'],
+    [{}, 'nothing_chosen'],
+  ];
+  for (const [choice, reason] of cases) {
+    const out = buildCharterProposal(MONARCHY, choice);
+    assert.equal(out.ok, false, JSON.stringify(choice));
+    assert.equal(out.reason, reason, JSON.stringify(choice));
+  }
+});
+
+test('the founder picks Direct Democracy and ratifies it: the amendment path writes the real constitution', async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gov-charter-'));
+  const target = path.join(dir, 'government.json');
+  const originalApply = config.applyBoardAmendment;
+  const applied = [];
+  config.applyBoardAmendment = (proposed) => { applied.push(proposed); fs.writeFileSync(target, JSON.stringify({ board: proposed })); return proposed; };
+  let filed = null;
+  const votes = [];
+  try {
+    await withDb({
+      builderHoldsRankActive: async () => true, // the founder keeps their seat either way
+      createAmendment: async (args) => { filed = args; return { id: '5', proposed: args.proposed, proposed_by: args.proposedBy }; },
+      openBoardItem: async (args) => ({ id: '21', subject_type: args.subjectType, subject_id: '5', opened_by: args.openedBy, constitution: args.constitution, closes_at: null, closed_at: null }),
+      getBoardItemForVote: async () => ({ id: '21', subject_type: 'constitutional_amendment', subject_id: '5', opened_by: '42', constitution: MONARCHY, closed_at: null, expired: false }),
+      insertBoardVote: async (row) => { const v = { voter_id: row.voterId, direction: row.direction }; votes.push(v); return v; },
+      insertVoteKarma: async () => {},
+      getVotesForItem: async () => votes,
+      getActiveBuildersWithRank: async () => [{ builder_id: '42', github_login: 'founder', display_name: 'Founder' }],
+      getBoardItemAuthor: async () => '42',
+      closeBoardItem: async ({ outcome }) => ({ id: '21', subject_type: 'constitutional_amendment', subject_id: '5', opened_by: '42', closed_at: 'T', outcome }),
+      insertAuthorRatifyKarma: async () => true,
+      getAmendment: async () => ({ id: '5', proposed: filed.proposed }),
+    }, async () => {
+      const out = await board.proposeCharter({ form: 'direct-democracy', proposedBy: '42' });
+      assert.equal(out.ok, true);
+      assert.equal(out.reads_as.form, 'direct-democracy');
+      assert.equal(filed.proposed.membership, 'rank:xenos+');
+      assert.match(filed.rationaleMd, /Direct Democracy/, 'the record says in words what was chosen');
+      assert.equal(out.item.constitution.pass_rule, config.loadGovernmentConfig().board.pass_rule,
+        'decided under the constitution IN FORCE, not the one proposed');
+      await board.castVote({ itemId: '21', voterId: '42', direction: 'yes' });
+      const closed = await board.maybeCloseAfterVote('21');
+      assert.equal(closed.outcome, 'passed');
+    });
+    assert.deepEqual(applied, [filed.proposed], 'the ratified text is exactly what was filed');
+    assert.equal(JSON.parse(fs.readFileSync(target, 'utf8')).board.membership, 'rank:xenos+');
+  } finally {
+    config.applyBoardAmendment = originalApply;
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('a charter that changes nothing files nothing, and a council must be a rank that exists', async () => {
+  // This checkout runs the neutral monarchy (a guard test pins the vanilla state).
+  assert.equal(readCharter(config.loadGovernmentConfig().board).form, 'monarchy');
+  await withDb({
+    createAmendment: async () => { throw new Error('must not be reached'); },
+    getRankByKey: async (key) => (key === 'trustees' ? { rank_key: 'trustees' } : null),
+    builderHoldsRankActive: async () => true,
+  }, async () => {
+    assert.equal((await board.proposeCharter({ form: 'monarchy', proposedBy: '42' })).reason, 'no_change',
+      'a sitting on the constitution already in force would decide nothing');
+    assert.equal((await board.proposeCharter({ form: 'foundation', councilRank: 'ghosts', proposedBy: '42' })).reason, 'unknown_council_rank');
+    assert.equal((await board.proposeCharter({ form: 'direct-democracy', proposedBy: null })).reason, 'missing_proposer');
+  });
+});
+
+// ── the surfaces ─────────────────────────────────────────────────────────────
+
+test('the constitution view carries the charter: forms, variables, and what the rule in force reads as', async () => {
+  await withDb({ listAmendmentHistory: async () => [], countActiveBuilders: async () => 1 }, async () => {
+    const view = await board.constitutionView();
+    assert.equal(view.charter.forms.length, FORMS.length);
+    assert.equal(view.charter.variables.length, VARIABLES.length);
+    assert.deepEqual(view.charter.reads_as, readCharter(view.board));
+  });
+  const routes = fs.readFileSync(path.join(GOV, 'routes', 'government.js'), 'utf8');
+  assert.match(routes, /router\.post\('\/government\/board\/charter', api\.requireBuilder, api\.requirePermission\('board\.item\.open'\)/);
+  assert.match(routes, /proposeCharter: board\.proposeCharter/);
+  const pins = fs.readFileSync(path.join(ROOT, 'src', 'bongos', 'route-rank-check.js'), 'utf8');
+  assert.match(pins, /'POST \/government\/board\/charter': 'perm:board\.item\.open'/);
+});
+
+test('the Constitution tab names the form of government in force', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'government.js'), 'utf8');
+  const start = src.indexOf('function formOfGovernmentSentence');
+  assert.ok(start > 0, 'the tab has a form-of-government line');
+  const fnSrc = src.slice(start, src.indexOf('\n  }\n', start) + 4);
+  const ctx = { escapeHtml: (s) => String(s) };
+  vm.createContext(ctx);
+  vm.runInContext(`${fnSrc}; this.f = formOfGovernmentSentence;`, ctx);
+  const monarchy = readCharter(MONARCHY);
+  assert.match(ctx.f({ reads_as: monarchy }), /Monarchy \/ BDFL/);
+  assert.match(ctx.f({ reads_as: monarchy }), new RegExp(monarchy.explanation.slice(0, 20).replace(/[.*+?^${}()|[\]\\/]/g, '\\$&')));
+  assert.match(ctx.f({ reads_as: readCharter({ ...MONARCHY, pass_rule: 'consent' }) }), /Custom/);
+  assert.equal(ctx.f({}), 'Not available from this server yet.', 'an older server without the charter block is said plainly');
+});

package/tests/pending_invite_purge_db.mjs

@@ -0,0 +1,129 @@
+// tests/pending_invite_purge_db.mjs — task 1004408 (owner decision on ADR 0353's
+// open consequence). Real DB.
+//
+// Proves migration platform_identity_028 against real SQL: it deletes the `pending`
+// rows the OLD hub invite wrote (they can lead to a locked door) and keeps every
+// notice the project wrote since the hub first ran ADR 0353. The cutoff is read from
+// the core_upgrades ledger — the earliest upgrade to 1.20.22 or later — so only a
+// real engine can show the version comparison (numeric, not lexical), the malformed
+// ledger rows it must skip without failing the deploy, and the one-shot guard.
+//
+// Each scenario builds its own tables in a throwaway schema, so the migration's
+// table-wide DELETE can never touch a shared database's rows.
+//
+// Real-DB integration test: self-skips without a reachable Postgres; in the
+// INTEGRATION set (scripts/gds/run-unit-tests.js) so the default DB-free lane
+// never runs it.
+//
+// Run:  DATABASE_URL=... node tests/pending_invite_purge_db.mjs
+
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { strict as assert } from 'node:assert';
+const require = createRequire(import.meta.url);
+const { Pool } = require('pg');
+
+const here = dirname(fileURLToPath(import.meta.url));
+const PI_MIG = join(here, '..', 'modules', 'platform-identity', 'migrations');
+const CORE_MIG = join(here, '..', 'migrations');
+const piSql = (f) => readFileSync(join(PI_MIG, `platform_identity_${f}.sql`), 'utf8');
+const PURGE = piSql('028_purge_pre_notice_invites');
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL || undefined, max: 1 });
+let client;
+try {
+  client = await pool.connect();
+} catch (e) {
+  console.log(`pending_invite_purge_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+
+const q = (sql, params) => client.query(sql, params);
+const at = (hh, mm = 0) => new Date(Date.UTC(2026, 8, 30, hh, mm)).toISOString();
+const schemas = [];
+let pass = 0;
+const ok = (cond, msg) => { assert.ok(cond, msg); pass++; console.log(`  ok - ${msg}`); };
+
+// A fresh hub in its own schema: the memberships table as it stands today (003, then
+// 010 + 021's rename), schema_migrations, and — unless `ledger` is false — the
+// core_upgrades ledger (core_189).
+async function freshHub(tag, { ledger = true } = {}) {
+  const schema = `t1004408_${tag}_${process.pid}`;
+  schemas.push(schema);
+  await q(`CREATE SCHEMA ${schema}`);
+  await q(`SET search_path TO ${schema}`);
+  await q('CREATE TABLE schema_migrations (version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())');
+  for (const f of ['003_project_memberships', '010_membership_kind', '021_drop_legacy_role']) await q(piSql(f));
+  if (ledger) await q(readFileSync(join(CORE_MIG, 'core_189_core_upgrades_ledger.sql'), 'utf8'));
+}
+const member = (client_id, github_id, kind, joinedAt) => q(
+  `INSERT INTO platform_identity_project_memberships (client_id, github_id, membership_kind, joined_at, last_active)
+   VALUES ($1, $2, $3, $4, $4)`, [client_id, github_id, kind, joinedAt]);
+const upgraded = (toVersion, appliedAt) => q(
+  'INSERT INTO core_upgrades (to_version, applied_at) VALUES ($1, $2)', [toVersion, appliedAt]);
+const rows = async () => (await q(
+  'SELECT client_id, github_id::int AS id, membership_kind AS kind FROM platform_identity_project_memberships ORDER BY github_id',
+)).rows.map((r) => `${r.id}:${r.kind}`).join(' ');
+
+try {
+  // ── The expected case: the hub has never run ADR 0353 (it served 1.19.1081). ──
+  await freshHub('never');
+  await upgraded('1.19.1081', at(8));
+  await member('spike-harbor', 1, 'pending', at(9));   // the live example's shape
+  await member('spike-harbor', 2, 'owner', at(9));
+  await member('spike-harbor', 3, 'member', at(9));
+  await member('mercury', 4, 'visitor', at(9));
+  await member('mercury', 5, 'pending', at(10));
+  await q(PURGE);
+  ok(await rows() === '2:owner 3:member 4:visitor',
+    'no ledger row at 1.20.22+: every pending row is an old one and goes; owners, members and visitors stay');
+  ok((await q(`SELECT 1 FROM schema_migrations WHERE version = 'platform_identity_028_purge_pre_notice_invites'`)).rowCount === 1,
+    'the migration records itself');
+
+  // One-shot: a notice written after the deploy survives a replay.
+  await member('mercury', 6, 'pending', at(11));
+  await q(PURGE);
+  ok(await rows() === '2:owner 3:member 4:visitor 6:pending',
+    'replaying the recorded migration deletes nothing, so a hand-run can never sweep real notices');
+
+  // ── The hub already ran ADR 0353 before this deploy: only rows older than that go. ──
+  await freshHub('since');
+  await upgraded('garbage', at(9));
+  await upgraded('1.20.99999999999', at(9, 30));        // malformed: must be skipped, not overflow the cast
+  await upgraded('1.19.1081', at(10));
+  await upgraded('1.20.21', at(11));
+  await upgraded('1.20.22', at(12));                    // the first release carrying ADR 0353
+  await upgraded('1.20.25', at(13));
+  await member('spike-harbor', 11, 'pending', at(11, 30)); // old hub invite: a locked door
+  await member('spike-harbor', 12, 'pending', at(12, 30)); // a project's own notice
+  await member('spike-harbor', 13, 'member', at(10));
+  await q(PURGE);
+  ok(await rows() === '12:pending 13:member',
+    'the earliest 1.20.22+ upgrade is the cutoff: the older pending row goes, the notice written after it stays');
+
+  // ── Versions compare as numbers, and a prefix or suffix does not hide one. ──
+  await freshHub('numeric');
+  await upgraded('1.9.0', at(9));                       // '1.9.0' > '1.20.22' as TEXT — must not count
+  await upgraded('v1.20.30-rc.1', at(12));
+  await member('demo', 21, 'pending', at(11));
+  await member('demo', 22, 'pending', at(13));
+  await q(PURGE);
+  ok(await rows() === '22:pending',
+    '1.9.0 is below 1.20.22 (numeric compare), and v1.20.30-rc.1 counts as 1.20.30');
+
+  // ── An instance with no ledger table at all (the module without core_189). ──
+  await freshHub('noledger', { ledger: false });
+  await member('demo', 31, 'pending', at(9));
+  await member('demo', 32, 'owner', at(9));
+  await q(PURGE);
+  ok(await rows() === '32:owner', 'no core_upgrades table: treated as never having run ADR 0353');
+
+  console.log(`\npending_invite_purge_db.mjs: ${pass} passed`);
+} finally {
+  for (const s of schemas) await q(`DROP SCHEMA IF EXISTS ${s} CASCADE`).catch(() => {});
+  client.release();
+  await pool.end().catch(() => {});
+}