@bongos/core 1.20.57 → 1.20.59

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/main_discipline.mjs

@@ -0,0 +1,81 @@
+// tests/main_discipline.mjs — the builder's own MAIN role (task 1004433 /
+// WA6.RP03, core_268): what updateBuilderDisciplines sends for each of the
+// three answers, and what it refuses before anything is written.
+//
+// The statement's own behaviour (keep, clear, set) runs against a real Postgres
+// in tests/role_stats_db.mjs; this pins the half before it, DB-free: the
+// "named or not" flag, the value, and the refusal of a main role that is not
+// one of the builder's chosen crafts.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+let passed = 0;
+let failed = 0;
+async function t(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (e) { failed++; console.error(`  FAIL ${name}\n       ${e.message}`); }
+}
+
+const calls = [];
+const poolPath = require.resolve('../src/bongos/pool.js');
+require.cache[poolPath] = {
+  id: poolPath, filename: poolPath, loaded: true,
+  exports: {
+    pool: {
+      async query(sql, params) {
+        calls.push({ sql, params });
+        return { rows: [{ id: params[0], preferred_disciplines: params[1], main_discipline: params[2] ? params[3] : null }] };
+      },
+    },
+  },
+};
+const db = require('../src/bongos/db.js');
+const { enabledDisciplines } = require('../src/modules.js');
+const offered = enabledDisciplines();
+const last = () => calls[calls.length - 1];
+
+await t('the write goes through the one exported statement', async () => {
+  await db.updateBuilderDisciplines(7, ['engineer']);
+  assert.equal(last().sql, db.UPDATE_BUILDER_DISCIPLINES_SQL);
+  assert.match(db.UPDATE_BUILDER_DISCIPLINES_SQL, /main_discipline = CASE WHEN \$3::boolean THEN \$4::text/);
+  assert.match(db.UPDATE_BUILDER_DISCIPLINES_SQL, /WHEN main_discipline = ANY\(\$2::text\[\]\) THEN main_discipline\s+ELSE NULL END/);
+});
+
+await t('not mentioned: the flag is false, so the stored main role is left to the statement to keep or clear', async () => {
+  await db.updateBuilderDisciplines(7, ['engineer', 'ideator']);
+  assert.deepEqual(last().params.slice(2), [false, null]);
+});
+
+await t('named: the flag is true and the role travels', async () => {
+  await db.updateBuilderDisciplines(7, ['ideator', 'engineer'], { mainDiscipline: 'ideator' });
+  assert.deepEqual(last().params.slice(2), [true, 'ideator']);
+  assert.deepEqual(last().params[1], offered.filter((d) => ['ideator', 'engineer'].includes(d)),
+    'the set is still stored in canonical order: the main role is what carries the choice');
+});
+
+await t('null clears it on purpose', async () => {
+  await db.updateBuilderDisciplines(7, ['engineer'], { mainDiscipline: null });
+  assert.deepEqual(last().params.slice(2), [true, null]);
+});
+
+await t('a main role that is not one of the chosen crafts is refused, and nothing is written', async () => {
+  const before = calls.length;
+  await assert.rejects(() => db.updateBuilderDisciplines(7, ['engineer'], { mainDiscipline: 'ideator' }),
+    (err) => err.code === 'invalid_main_discipline' && err.bad[0] === 'ideator');
+  assert.equal(calls.length, before);
+});
+
+await t('the PATCH route hands main_discipline through only when the body names it', async () => {
+  const fs = require('node:fs');
+  const src = fs.readFileSync(require.resolve('../src/bongos/routes/me.js'), 'utf8');
+  const route = src.slice(src.indexOf("router.patch('/me/disciplines'"), src.indexOf("router.patch('/me/disciplines'") + 2500);
+  assert.match(route, /hasOwnProperty\.call\(body, 'main_discipline'\)/);
+  assert.match(route, /db\.updateBuilderDisciplines\(req\.builder\.id, input, mainOpt\)/);
+  assert.match(route, /invalid_main_discipline/);
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);