@bongos/core 1.20.56 → 1.20.58

package/modules/ui-design/kit/fixtures/government-constitution-sample.json

@@ -0,0 +1,205 @@
+{
+  "_": "GET /government/constitution as the genesis plan reads it (task 1004423): the charter view and the recommendation for a one-builder project, from the real charter.js and recommendations.js.",
+  "charter": {
+    "forms": [
+      {
+        "key": "monarchy",
+        "name": "Monarchy / BDFL",
+        "available": true,
+        "franchise": "founder",
+        "pass_rule": "first_ratifier",
+        "explanation": "One leader decides. In a project the founder makes the calls, which is fast, clear and honest for a solo start."
+      },
+      {
+        "key": "timocratic-republic",
+        "name": "Timocratic Republic",
+        "available": true,
+        "franchise": "trusted",
+        "pass_rule": "consent",
+        "explanation": "A say is earned, not given. Builders who have reached the trusted rank decide together."
+      },
+      {
+        "key": "direct-democracy",
+        "name": "Direct Democracy",
+        "available": true,
+        "franchise": "everyone",
+        "pass_rule": "consent",
+        "explanation": "Every builder votes directly. A decision passes unless someone objects with a reason."
+      },
+      {
+        "key": "foundation",
+        "name": "Foundation",
+        "available": true,
+        "franchise": "council",
+        "pass_rule": "consent",
+        "explanation": "A written charter looked after by a small council of trustees you appoint."
+      },
+      {
+        "key": "presidential",
+        "name": "Presidential",
+        "available": false,
+        "explanation": "The team elects a leader for a fixed term. Coming later, because it needs elections."
+      },
+      {
+        "key": "cooperative",
+        "name": "Cooperative",
+        "available": false,
+        "explanation": "Every member holds a share and gets one vote. Coming later, because it needs member shares."
+      },
+      {
+        "key": "federation",
+        "name": "Federation",
+        "available": false,
+        "explanation": "Self-governing teams coordinate under one shared pact. Coming later, for projects with many teams."
+      }
+    ],
+    "variables": [
+      {
+        "key": "franchise",
+        "name": "Franchise",
+        "question": "Who gets a vote?",
+        "status": "live",
+        "explanation": "Who sits on the board and votes on the project's decisions.",
+        "options": [
+          {
+            "key": "founder",
+            "name": "The founder",
+            "predicate": "rank:archon",
+            "seats": [
+              "archon"
+            ],
+            "explanation": "Only the founder votes (the Archon rank). Right for a solo start, when there is nobody else to ask."
+          },
+          {
+            "key": "trusted",
+            "name": "Trusted builders and up",
+            "predicate": "rank:metic+",
+            "seats": [
+              "metic",
+              "archon"
+            ],
+            "explanation": "Builders who have earned the trusted rank by shipping get a vote, along with the founder."
+          },
+          {
+            "key": "everyone",
+            "name": "Every builder",
+            "predicate": "rank:xenos+",
+            "seats": [
+              "xenos",
+              "thetes",
+              "metic",
+              "archon"
+            ],
+            "explanation": "Everyone on the project gets a vote, from the newest builder to the founder."
+          },
+          {
+            "key": "council",
+            "name": "A council you name",
+            "predicate": null,
+            "seats": null,
+            "explanation": "Only the members of a council rank you create get a vote. You choose who sits on it."
+          }
+        ]
+      },
+      {
+        "key": "pass_rule",
+        "name": "Pass rule (winning coalition)",
+        "question": "How many must agree?",
+        "status": "live",
+        "explanation": "How much agreement a decision needs before it passes.",
+        "options": [
+          {
+            "key": "first_ratifier",
+            "name": "One yes is enough",
+            "explanation": "One yes from any member decides it."
+          },
+          {
+            "key": "consent",
+            "name": "Passes unless someone objects",
+            "explanation": "It passes unless a member objects, once everyone has voted or the clock runs out."
+          },
+          {
+            "key": "majority",
+            "name": "More than half",
+            "explanation": "More than half of all members must say yes."
+          },
+          {
+            "key": "unanimous",
+            "name": "Everyone who votes agrees",
+            "explanation": "Everyone who votes must agree, and at least one member must say yes."
+          }
+        ]
+      },
+      {
+        "key": "veto_points",
+        "name": "Veto points",
+        "question": "How many checkpoints must a big change pass?",
+        "status": "later",
+        "explanation": "How many separate approvals a big change must collect before it happens."
+      },
+      {
+        "key": "executive_legislative",
+        "name": "Executive–legislative relationship",
+        "question": "Does the leader serve at the team's confidence?",
+        "status": "later",
+        "explanation": "Whether the team can replace its leader by vote, or the leader holds office for a set term."
+      },
+      {
+        "key": "judicial_review",
+        "name": "Judicial review",
+        "question": "Who can void a decision that breaks the charter?",
+        "status": "later",
+        "explanation": "Who may cancel a decision that goes against the project's charter."
+      },
+      {
+        "key": "loyalty_of_enforcement",
+        "name": "Loyalty of enforcement",
+        "question": "Does power belong to the office or the person?",
+        "status": "always_on",
+        "explanation": "Whoever holds a rank holds its powers, and nobody keeps them after leaving it."
+      },
+      {
+        "key": "trajectory",
+        "name": "Trajectory",
+        "question": "How does the government change as you grow?",
+        "status": "later",
+        "explanation": "Whether the government stays put, grows with the team, or changes on a schedule.",
+        "options": [
+          {
+            "key": "locked",
+            "name": "Locked",
+            "explanation": "The government stays as founded until the project votes to change it."
+          },
+          {
+            "key": "laddered",
+            "name": "Laddered",
+            "explanation": "The government steps up automatically as the team crosses each size threshold."
+          },
+          {
+            "key": "scheduled",
+            "name": "Scheduled",
+            "explanation": "The government changes on dates the project commits to in advance."
+          }
+        ]
+      }
+    ],
+    "reads_as": {
+      "form": "monarchy",
+      "name": "Monarchy / BDFL",
+      "explanation": "One leader decides. In a project the founder makes the calls, which is fast, clear and honest for a solo start.",
+      "franchise": "founder",
+      "pass_rule": "first_ratifier"
+    }
+  },
+  "headcount": 1,
+  "recommended": {
+    "key": "monarchy",
+    "name": "Monarchy / BDFL",
+    "rung": "solo/pair",
+    "why": "informal coordination has nothing to break yet — the founding monarchy is the honest shape",
+    "type": "not-sure",
+    "size": "solo",
+    "council_rank": null,
+    "later": null
+  }
+}

package/modules/ui-design/kit/serve.js

@@ -108,7 +108,13 @@ const FEEDS = {
 // /founding/builders (task 1004424) answers a never-founded project's empty list by default,
 // so every existing render stays today's page; a founding variant states file points it at
 // founding-builders-sample via stub.fixtures.
-const AUTHED = { '/my-projects': 'my-projects', '/my-projects/invites': 'my-projects__invites', '/founding/builders': 'founding-builders' };
+// /founding/genesis and /government/constitution (task 1004423) ship no default file: the
+// genesis home asks for them only in founding mode, so every existing render is unchanged,
+// and the genesis variants point them at their samples.
+const AUTHED = {
+  '/my-projects': 'my-projects', '/my-projects/invites': 'my-projects__invites', '/founding/builders': 'founding-builders',
+  '/founding/genesis': 'founding-genesis', '/government/constitution': 'government-constitution',
+};
 const UNAUTH = { error: { code: 'unauthenticated', message: 'unauthenticated' } };
 
 // GET /provisioning/starter-bundles as the create wizard's module picker reads it

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.20.56",
+  "version": "1.20.58",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.20.56",
+      "version": "1.20.58",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.20.56",
+  "version": "1.20.58",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -8453,5 +8453,17 @@
       "id": "1004424",
       "text": "Everyone who joins a project while it is being founded now becomes a founding builder, numbered in the order they arrived, and the owner is marked founder. The mark shows as a small seed badge on the builders list and on their"
     }
+  ],
+  "1.20.57": [
+    {
+      "id": "1004479",
+      "text": "Each recommended rank on the Government page now shows just its name and one plain line of what it can do. The extra description that said the same thing twice is gone."
+    }
+  ],
+  "1.20.58": [
+    {
+      "id": "1004423",
+      "text": "A project that is being founded now has a genesis home at the top of its hall. The founder settles a plan in one click (each stage's length, the starting government by its real name with a plain explanation, and how many passe"
+    }
   ]
 }

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.20.56'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.20.58'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');

package/tests/genesis_home.mjs

@@ -0,0 +1,288 @@
+// tests/genesis_home.mjs — THE GENESIS HOME (task 1004423 / BV2.PS08, goal 1000121).
+//
+// Done-when: a founded project walks decide → five stages → alive, and the full hall
+// opens. Spec D7: a stage closes when its tasks are finished AND the constitution in
+// force decides it (the Board Room's genesis-stage sitting). D4: a solo founder gets a
+// fast-track, defaults pre-picked and one confirm per stage, and genesis is never
+// skipped. The blend rule: a hall that is not founding renders, and requests, exactly
+// what it did before.
+//
+// Everything here RUNS: the real checklist and seeder over a fake pool, the real
+// genesis-home flow over an in-memory project_settings store with fake lifecycle and
+// government ports, and the real hall card in a vm.
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+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 { genesisChecklist } = require('../modules/lifecycle/kickoff-checklist.js');
+const seed = require('../modules/lifecycle/kickoff-seed.js');
+const gh = require('../modules/onboarding/genesis-home.js');
+const fm = require('../modules/onboarding/founding-mode.js');
+
+const STAGES5 = ['scope', 'strategize', 'charter', 'legalize', 'legislation'];
+
+// ── the checklist + the seeder ───────────────────────────────────────────────
+
+test('genesis files a task per stage, keyed by a ref that names the step, not its place', () => {
+  const plain = genesisChecklist();
+  assert.deepEqual(Object.keys(plain), STAGES5);
+  for (const s of STAGES5) {
+    assert.equal(plain[s].length, 1);
+    assert.equal(plain[s][0].ref, `genesis:${s}`);
+    assert.equal(plain[s][0].kind, 'decision');
+    assert.equal(plain[s][0].discipline, 'ideator');
+  }
+  const existing = genesisChecklist({ existing: true });
+  assert.deepEqual(existing.scope.map((t) => t.ref), ['genesis:scope:existing', 'genesis:scope'],
+    'the brownfield step comes first and does not re-key scope\'s own step');
+});
+
+test('the seeder files every genesis step once, under the catch-all, and never twice', async () => {
+  const filed = [];
+  const deps = {
+    pool: { query: async () => ({ rows: [{ id: 'V1' }] }) },
+    createTask: async (row) => { filed.push(row); },
+    findTaskBySourceRef: async ({ source, sourceRef }) => filed.find((r) => r.source === source && r.sourceRef === sourceRef) || null,
+  };
+  const first = await seed.seedGenesisStages({ builderId: 1 }, deps);
+  assert.equal(first.seeded, 5);
+  assert.ok(filed.every((r) => r.status === 'ready' && r.source === 'genesis' && r.allowCatchAll === true && r.versionId === 'V1'));
+  const again = await seed.seedGenesisStages({ builderId: 1, existing: true }, deps);
+  assert.equal(again.seeded, 1, 'a second run files only the step that was not there (the brownfield one)');
+  assert.equal(filed.length, 6);
+});
+
+test('the board read groups genesis tasks by the stage their ref names', async () => {
+  const pool = { query: async (sql, params) => {
+    assert.deepEqual(params, ['genesis']);
+    return { rows: [
+      { id: 1, title: 'a', status: 'shipped', source_ref: 'genesis:scope' },
+      { id: 2, title: 'b', status: 'ready', source_ref: 'genesis:scope:existing' },
+      { id: 3, title: 'c', status: 'ready', source_ref: 'genesis:charter' },
+    ] };
+  } };
+  const out = await seed.genesisStageTasks({ pool });
+  assert.deepEqual(Object.keys(out), ['scope', 'charter']);
+  assert.deepEqual(out.scope.map((t) => t.id), ['1', '2']);
+});
+
+// ── the plan ─────────────────────────────────────────────────────────────────
+
+test('an empty plan is the recommended defaults: the solo fast-track is one click', () => {
+  const r = gh.parsePlan({});
+  assert.equal(r.ok, true);
+  assert.deepEqual(r.plan.days, { scope: 7, strategize: 7, charter: 4, legalize: 7, legislation: 3 });
+  assert.equal(r.plan.passes, 1);
+  assert.equal(r.plan.advisors, 'none');
+});
+
+test('a plan out of range is refused with the reason', () => {
+  assert.equal(gh.parsePlan({ days: { scope: 0 } }).reason, 'bad_days');
+  assert.equal(gh.parsePlan({ passes: 3 }).reason, 'bad_passes');
+  assert.equal(gh.parsePlan({ advisors: 'robots' }).reason, 'bad_advisors');
+  assert.equal(gh.parsePlan({ government: 'Not A Key' }).reason, 'bad_government');
+  assert.equal(gh.parsePlan({ expected_builders: 0 }).reason, 'bad_expected_builders');
+});
+
+// ── the flow, end to end over fakes ──────────────────────────────────────────
+
+function world({ withGovernment = true } = {}) {
+  const store = new Map();
+  const tasks = {};
+  const board = {};
+  let now = new Date('2026-10-01T00:00:00Z');
+  const opened = [];
+  const lifecycle = {
+    seedGenesis: async () => {
+      for (const s of STAGES5) tasks[s] = [{ id: String(100 + STAGES5.indexOf(s)), title: s, status: 'ready' }];
+      return { seeded: 5 };
+    },
+    genesisTasks: async () => JSON.parse(JSON.stringify(tasks)),
+  };
+  const government = withGovernment ? {
+    genesisStageStatus: async () => ({ stages: STAGES5.map((key) => ({ key, ...(board[key] || { state: 'not_put', waiting_on: [] }) })) }),
+    openGenesisStageClose: async ({ stageKey, taskIds }) => {
+      opened.push({ stageKey, taskIds });
+      if (!(tasks[stageKey] || []).every((t) => ['shipped', 'abandoned'].includes(t.status))) {
+        return { opened: false, reason: 'stage_tasks_unfinished', unfinished: [{ task_id: taskIds[0] }] };
+      }
+      board[stageKey] = { state: 'sitting', item_id: '9', one_vote_decides: true, waiting_on: [{ builder_id: '1' }] };
+      return { opened: true, item: { id: 9 } };
+    },
+  } : null;
+  const deps = () => ({
+    getSetting: async (k) => (store.has(k) ? { key: k, value: store.get(k) } : null),
+    setSetting: async (k, v) => { store.set(k, String(v)); return { key: k, value: String(v) }; },
+    lifecycle, government, now,
+  });
+  return {
+    store, tasks, board, opened, deps,
+    finish: (s) => tasks[s].forEach((t) => { t.status = 'shipped'; }),
+    pass: (s) => { board[s] = { state: 'passed', item_id: '9', waiting_on: [] }; },
+    tick: (days) => { now = new Date(now.getTime() + days * 86400000); },
+  };
+}
+
+test('decide → five stages through the Board Room → alive, and the hall opens', async () => {
+  const w = world();
+  assert.equal(await gh.readGenesis(w.deps()), null, 'not founding: there is no genesis home');
+  assert.equal((await gh.startFounding(1, w.deps())).ok, true);
+  let g = await gh.readGenesis(w.deps());
+  assert.equal(g.deciding, true);
+  assert.equal(g.stage, 'decide');
+
+  const saved = await gh.savePlan({}, 1, w.deps());
+  assert.equal(saved.ok, true);
+  assert.equal(saved.seeded, 5);
+  assert.ok(JSON.parse(w.store.get(gh.PLAN_KEY)).days, 'the plan is recorded');
+  g = await gh.readGenesis(w.deps());
+  assert.equal(g.stage, 'scope');
+  assert.equal(g.can_close, false, 'a stage with unfinished tasks cannot be put to the board');
+  assert.equal((await gh.savePlan({}, 1, w.deps())).reason, 'not_deciding', 'the plan is settled once');
+
+  for (const s of STAGES5) {
+    assert.equal((await gh.readGenesis(w.deps())).stage, s);
+    assert.equal((await gh.closeStage(s, 1, w.deps())).reason, 'stage_tasks_unfinished', `${s}: the Board Room's gate refuses unfinished work`);
+    w.finish(s);
+    assert.equal((await gh.readGenesis(w.deps())).can_close, true);
+    const closed = await gh.closeStage(s, 1, w.deps());
+    assert.equal(closed.ok, true);
+    assert.equal(closed.item_id, '9');
+    assert.deepEqual(w.opened.at(-1), { stageKey: s, taskIds: [String(100 + STAGES5.indexOf(s))] }, 'the stage\'s own task ids go to the gate');
+    g = await gh.readGenesis(w.deps());
+    assert.equal(g.stage, s, 'sitting is not passing: the stage holds until the vote');
+    assert.equal(g.can_close, false);
+    if (s !== 'legislation') assert.equal((await gh.comeAlive(1, w.deps())).ok, false);
+    w.pass(s);
+    await gh.onStagePassed(w.deps());
+  }
+  g = await gh.readGenesis(w.deps());
+  assert.equal(g.stage, 'legislation', 'legislation does not advance past itself');
+  assert.equal(g.can_come_alive, true);
+  assert.equal((await gh.comeAlive(1, w.deps())).ok, true);
+  assert.equal(await gh.readGenesis(w.deps()), null, 'founding mode is off: the full hall opens');
+  assert.ok(w.store.get(fm.KEYS.ENDED_AT), 'the founding window closed, for the founding mark');
+  assert.equal((await gh.startFounding(1, w.deps())).reason, 'already_alive', 'genesis happens once');
+});
+
+test('only the stage in progress can be put to the board', async () => {
+  const w = world();
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({}, 1, w.deps());
+  const r = await gh.closeStage('charter', 1, w.deps());
+  assert.equal(r.reason, 'not_current_stage');
+  assert.equal(w.opened.length, 0);
+});
+
+test('a returned stage stays put and can be put up again', async () => {
+  const w = world();
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({}, 1, w.deps());
+  w.finish('scope');
+  w.board.scope = { state: 'returned', item_id: '9', waiting_on: [] };
+  const g = await gh.readGenesis(w.deps());
+  assert.equal(g.stage, 'scope');
+  assert.equal(g.can_close, true);
+});
+
+test('with no Board Room module the founder\'s confirm closes a finished stage', async () => {
+  const w = world({ withGovernment: false });
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({}, 1, w.deps());
+  assert.equal((await gh.closeStage('scope', 1, w.deps())).reason, 'stage_tasks_unfinished');
+  w.finish('scope');
+  assert.equal((await gh.closeStage('scope', 1, w.deps())).ok, true);
+  assert.equal((await gh.readGenesis(w.deps())).stage, 'strategize');
+});
+
+test('the view: states, wakes, the life plates and a due date from the plan', () => {
+  const mode = { stage: 'strategize', stage_number: 2, stage_count: 5, day: 9 };
+  const g = gh.shapeGenesis({
+    mode, plan: { days: { scope: 7, strategize: 10, charter: 4, legalize: 7, legislation: 3 } },
+    tasks: { strategize: [{ id: '1', title: 't', status: 'active' }] },
+    stageAt: { strategize: '2026-10-08T00:00:00Z' },
+  });
+  assert.deepEqual(g.stages.map((s) => s.state), ['done', 'now', 'later', 'later', 'later']);
+  assert.deepEqual(g.stages[1].wakes, ['work']);
+  assert.equal(g.stages[1].plate, 'r5-life-2-first-cells');
+  assert.equal(g.stages[1].due, '2026-10-18T00:00:00.000Z');
+  assert.equal(g.stages[1].finished, 0);
+});
+
+// ── the routes ───────────────────────────────────────────────────────────────
+
+test('every genesis write is the project owner\'s; the read is any signed-in builder\'s', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules', 'onboarding', 'routes', 'onboarding.js'), 'utf8');
+  assert.match(src, /const owns = api\.requirePermission\('project\.settings\.manage'\);/);
+  for (const p of ['/founding/start', '/founding/plan', '/founding/stages/:stage/close', '/founding/alive']) {
+    assert.ok(src.includes(`router.post('${p}', api.requireBuilder, owns,`), `${p} is owner-gated`);
+  }
+  assert.match(src, /router\.get\('\/founding\/genesis', api\.requireBuilder,/);
+  assert.match(src, /api\.on\('board\.genesis_stage\.passed'/, 'a pass moves the stage on without waiting for a read');
+});
+
+// ── the hall card, RUN ───────────────────────────────────────────────────────
+
+const CARD = fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'genesis-home.js'), 'utf8');
+
+function bootCard({ founding }) {
+  const calls = [];
+  let widget = null;
+  let observer = null;
+  const attrs = founding ? { 'data-founding': 'on' } : {};
+  const sandbox = {
+    window: {
+      OTB: { escapeHtml: (s) => String(s), contributeHallWidget: (w) => { widget = w; } },
+      BongosClient: { createClient: () => ({ request: async (m, p) => { calls.push(`${m} ${p}`); return { ok: true, status: 200, data: { genesis: null } }; } }) },
+    },
+    document: { documentElement: { getAttribute: (k) => attrs[k] || null } },
+    MutationObserver: class { constructor(fn) { observer = fn; } observe() {} disconnect() {} },
+    Promise,
+  };
+  vm.createContext(sandbox);
+  vm.runInContext(CARD, sandbox, { filename: 'genesis-home.js' });
+  const host = { hidden: true, innerHTML: '', addEventListener() {}, querySelector: () => null, querySelectorAll: () => [] };
+  widget.mount(host);
+  return { widget, host, calls, attrs, fire: () => observer && observer() };
+}
+
+test('the card registers in the Home banner, ahead of the welcome, hidden by default', () => {
+  const { widget } = bootCard({ founding: false });
+  assert.equal(widget.zone, 'home-banner');
+  assert.equal(widget.view, 'home');
+  assert.equal(widget.hiddenByDefault, true);
+  assert.ok(widget.order < 0);
+});
+
+test('a hall that is not founding: no markup and no request', async () => {
+  const { host, calls } = bootCard({ founding: false });
+  await new Promise((r) => setImmediate(r));
+  assert.equal(host.innerHTML, '');
+  assert.deepEqual(calls, []);
+});
+
+test('founding mode stamped after mount still starts the card, once', async () => {
+  const b = bootCard({ founding: false });
+  b.attrs['data-founding'] = 'on';
+  b.fire();
+  b.fire();
+  await new Promise((r) => setImmediate(r));
+  assert.deepEqual(b.calls, ['GET /api/bongos/founding/genesis']);
+});
+
+test('the hall carries the five life plates byte-identical to the world\'s', () => {
+  const world = path.join(ROOT, 'modules', 'public-landing', 'public', 'assets', 'world');
+  const hall = path.join(ROOT, 'modules', 'hall-ui', 'public', 'genesis');
+  for (const s of Object.values(gh.STAGE_INFO)) {
+    for (const f of [`${s.plate}.jpg`, `${s.plate}-cut.webp`]) {
+      assert.ok(fs.readFileSync(path.join(world, f)).equals(fs.readFileSync(path.join(hall, f))), `${f} matches the world plate`);
+    }
+  }
+});

package/tests/government_recommendations.mjs

@@ -129,4 +129,5 @@ test('the panel says what a recommended rank can do in words, never in permissio
   const row = client.slice(client.indexOf('function recoRankRow'), client.indexOf('function recommendationHtml'));
   assert.match(row, /r\.can/, 'the rank row renders the sentence');
   assert.doesNotMatch(row, /permissions/, 'the rank row does not render the raw keys');
+  assert.doesNotMatch(row, /r\.description/, 'one line per rank: the description is not repeated above the Can line (task 1004479)');
 });