@bongos/core 1.25.17 → 1.25.19

package/tests/genesis_home.mjs

@@ -226,7 +226,7 @@ function world({ withGovernment = true } = {}) {
   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,
+    lifecycle, government, now, documents: null,
   });
   return {
     store, tasks, board, opened, deps,
@@ -385,6 +385,67 @@ test('with no Board Room module the founder\'s confirm closes a finished stage',
   assert.equal((await gh.readGenesis(w.deps())).stage, 'strategize');
 });
 
+test('task 1005115: with no Board Room a finished stage moves on by itself, and the view says so', async () => {
+  const w = world({ withGovernment: false });
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({}, 1, w.deps());
+  let g = await gh.readGenesis(w.deps());
+  assert.equal(g.board_room, false);
+  assert.equal(g.moved, null, 'nothing has moved past a stage yet');
+  w.finish('scope');
+  // A ship moves it on; no read and no button needed.
+  assert.deepEqual(await gh.onTaskShipped(w.deps()), []);
+  assert.equal(w.store.get(fm.KEYS.STAGE), 'strategize', 'the ship that finished scope advanced it');
+  g = await gh.readGenesis(w.deps());
+  assert.equal(g.stage, 'strategize');
+  assert.equal(g.can_close, false, 'there is no close button on this path');
+  assert.equal(g.moved.from, 'scope');
+  assert.equal(g.moved.to, 'strategize');
+  assert.equal(g.moved.how, 'tasks_finished');
+  assert.deepEqual(g.moved.opened, fm.WAKES.scope, 'and it names what opened');
+  assert.equal(g.stages[0].state, 'done');
+  // Every read reconciles too, through several finished stages in order.
+  w.finish('strategize'); w.finish('charter');
+  g = await gh.readGenesis(w.deps());
+  assert.equal(g.stage, 'legalize');
+  // Legislation does not pass itself: its finished tasks open the alive door.
+  w.finish('legalize'); w.finish('legislation');
+  g = await gh.readGenesis(w.deps());
+  assert.equal(g.stage, 'legislation');
+  assert.equal(g.can_close, false);
+  assert.equal(g.can_come_alive, true);
+  // The old close call on a stage that already moved answers what happened.
+  const again = await gh.closeStage('scope', 1, w.deps());
+  assert.equal(again.ok, true);
+  assert.equal(again.already, true);
+  assert.equal(again.next_stage, 'legislation', 'it names where the project is now, not the stage after scope');
+  assert.equal((await gh.comeAlive(1, w.deps())).ok, true);
+});
+
+test('task 1005115: with a Board Room nothing moves by itself; the sitting still decides', async () => {
+  const w = world();
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({}, 1, w.deps());
+  w.finish('scope');
+  const g = await gh.readGenesis(w.deps());
+  assert.equal(g.stage, 'scope');
+  assert.equal(g.board_room, true);
+  assert.equal(g.can_close, true);
+});
+
+test('task 1005115: each stage on the genesis home carries its document', async () => {
+  const w = world({ withGovernment: false });
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({}, 1, w.deps());
+  const documents = async () => ({ scope: { title: 'The scope', filled: true, updated_at: null, editable: true } });
+  let g = await gh.readGenesis({ ...w.deps(), documents });
+  assert.equal(g.stages[0].document.title, 'The scope');
+  assert.equal(g.stages[1].document, null);
+  g = await gh.readGenesis({ ...w.deps(), documents: async () => { throw new Error('db down'); } });
+  assert.equal(g.stage, 'scope', 'the home still renders when the documents cannot be read');
+  assert.equal(g.stages[0].document, null);
+});
+
 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({
@@ -605,6 +666,25 @@ test('the stage reads as a checklist: done, open and locked, and a locked row of
   assert.doesNotMatch(r304, /data-genesis-copy/);
 });
 
+test('task 1005115: with no Board Room the card says the stage moved by itself, and lists what each stage left', async () => {
+  const genesis = gh.shapeGenesis({
+    mode: { stage: 'strategize', stage_number: 2, stage_count: 5, day: 3 },
+    plan: { days: {} },
+    tasks: { scope: [{ id: '1', title: 'Write the scope', status: 'shipped' }], strategize: [{ id: '2', title: 'Write the strategy', status: 'ready' }] },
+    stageAt: { strategize: '2026-10-08T00:00:00Z' },
+    boardRoom: false,
+    documents: { scope: { title: 'The scope', filled: true, updated_at: null, editable: true }, strategize: { title: 'The strategy', filled: false } },
+  });
+  const { host } = bootCard({ founding: true, data: { genesis, viewer_id: '1' } });
+  await new Promise((r) => setImmediate(r));
+  await new Promise((r) => setImmediate(r));
+  assert.match(host.innerHTML, /data-genesis-moved>Scope is done, so this stage opened by itself\. Now open: /);
+  assert.match(host.innerHTML, /moves on by itself/);
+  assert.doesNotMatch(host.innerHTML, /put this stage to the board/, 'no board to put it to');
+  assert.match(host.innerHTML, /<b>The scope<\/b>/);
+  assert.doesNotMatch(host.innerHTML, /The strategy<\/b>/, 'an empty document is not listed');
+});
+
 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');

package/tests/genesis_work.mjs

@@ -222,10 +222,81 @@ if (import.meta.url === url.pathToFileURL(process.argv[1]).href) {
 
   await test('a stage that has not adopted questions still takes a page and a link', async () => {
     const deps = { store: memStore() };
-    const r = await gw.setPage('charter', 'Monarchy to start.', 1, deps);
+    const r = await gw.setPage('legalize', 'Credits only to start.', 1, deps);
     assert.equal(r.work.adopted, false);
-    assert.equal(r.work.page, 'Monarchy to start.');
-    assert.equal((await gw.setAnswer('charter', 'anything', { text: 'x' }, 1, deps)).reason, 'unknown_question');
+    assert.equal(r.work.page, 'Credits only to start.');
+    assert.equal((await gw.setAnswer('legalize', 'anything', { text: 'x' }, 1, deps)).reason, 'unknown_question');
+  });
+
+  // ── the charter stage (task 1005119) ──────────────────────────────────────
+  // A stand-in government port that records what it was handed, so the test sees
+  // exactly which answers reach the recommender.
+  const fakeGov = () => {
+    const calls = [];
+    return { calls, async charterAdvice(input) { calls.push(input); return { charter: { key: 'monarchy' }, input }; } };
+  };
+  const charterDeps = (extra = {}) => ({ store: memStore(), government: fakeGov(), getSetting: async () => null, ...extra });
+
+  await test('charter: a closed answer must be one of its choices, and a label reads back as its key', async () => {
+    const deps = charterDeps();
+    const bad = await gw.setAnswer('charter', 'final_say', { text: 'my cat' }, 1, deps);
+    assert.equal(bad.reason, 'not_a_choice');
+    assert.deepEqual(bad.expected, ['founder', 'trusted', 'everyone', 'council']);
+    const r = await gw.setAnswer('charter', 'final_say', { text: 'Everyone on the project' }, 1, deps);
+    const q = qOf(r, 'final_say');
+    assert.equal(q.answer.text, 'everyone', 'stored as the key');
+    assert.equal(q.answer.choice_label, 'Everyone on the project');
+    assert.ok(q.choices.some((c) => c.key === 'council'), 'the choices ride the view');
+    // prose questions take any words
+    const p = await gw.setAnswer('charter', 'feel', { text: 'Calm and careful.' }, 1, deps);
+    assert.equal(qOf(p, 'feel').answer.text, 'Calm and careful.');
+  });
+
+  await test('charter: every question is skippable and answerable "not sure yet"', async () => {
+    const deps = charterDeps();
+    for (const q of gw.QUESTIONS.charter) {
+      assert.equal((await gw.setAnswer('charter', q.id, { state: 'not_sure' }, 1, deps)).ok, true, q.id);
+      assert.equal((await gw.setAnswer('charter', q.id, { state: 'skipped' }, 1, deps)).ok, true, q.id);
+    }
+  });
+
+  await test('charter: only given answers reach the recommender, closed as keys and prose as words', async () => {
+    const gov = fakeGov();
+    const deps = charterDeps({ government: gov, getSetting: async () => ({ value: JSON.stringify({ expected_builders: 6 }) }) });
+    await gw.setAnswer('charter', 'final_say', { text: 'trusted' }, 1, deps);
+    await gw.setAnswer('charter', 'agreement', { state: 'not_sure' }, 1, deps);
+    await gw.setAnswer('charter', 'speed', { state: 'skipped' }, 1, deps);
+    await gw.setAnswer('charter', 'leave_behaviour', { text: 'Lying about shipped work.' }, 1, deps);
+    const r = await gw.readStage('charter', deps);
+    const last = gov.calls[gov.calls.length - 1];
+    assert.deepEqual(last.answers, { final_say: 'trusted' }, 'not sure yet and skipped are not sent');
+    assert.deepEqual(last.prose, { leave_behaviour: 'Lying about shipped work.' });
+    assert.equal(last.headcount, 6, "the founder's expected headcount from the plan");
+    assert.equal(r.work.advice.charter.key, 'monarchy', 'the advice rides the stage');
+  });
+
+  await test('charter: no government module, or a failing one, still reads the stage (advice null)', async () => {
+    const none = await gw.readStage('charter', charterDeps({ government: null }));
+    assert.equal(none.ok, true);
+    assert.equal(none.work.advice, null);
+    const broken = await gw.readStage('charter', charterDeps({ government: { charterAdvice: async () => { throw new Error('db down'); } } }));
+    assert.equal(broken.work.advice, null);
+    const other = await gw.readStage('strategize', charterDeps());
+    assert.equal(other.work.advice, undefined, 'only the charter stage carries advice');
+  });
+
+  await test('charter: the assisted brief lists the keys to record for each closed question', async () => {
+    const p = gw.assistPrompt('charter');
+    assert.match(p, /\[final_say\]/);
+    assert.match(p, /Record one of: founder \(Me, the founder\) · trusted/);
+    assert.match(p, /\[leave_behaviour\]/);
+  });
+
+  await test('charter: the planning read path shows a closed answer in words, not its key', async () => {
+    const deps = charterDeps();
+    await gw.setAnswer('charter', 'agreement', { text: 'consent' }, 1, deps);
+    const { markdown } = await gw.readContext(deps);
+    assert.match(markdown, /How much agreement should a decision need\?\*\*\n  It passes unless someone objects/);
   });
 
   await test('an empty project gives the planning read path nothing to print', async () => {
@@ -299,6 +370,35 @@ if (import.meta.url === url.pathToFileURL(process.argv[1]).href) {
     assert.match(out, /\(empty\)/);
   });
 
+  await test('task 1005115: a stage\'s document is its record read as one named, editable page', async () => {
+    const deps = { store: memStore() };
+    let d = (await gw.readDocument('strategize', deps)).document;
+    assert.equal(d.title, 'The strategy');
+    assert.equal(d.filled, false, 'nothing written yet: an empty document, not a heading');
+    assert.equal(d.markdown, '');
+    await gw.setAnswer('strategize', 'big_pieces', { text: 'Ledger, then sync' }, 1, deps);
+    await gw.setAnswer('strategize', 'risks', { state: 'not_sure', text: 'bank API' }, 1, deps);
+    await gw.setPage('strategize', 'We start small.', 1, deps);
+    d = (await gw.readDocument('strategize', deps)).document;
+    assert.equal(d.filled, true);
+    assert.match(d.markdown, /^# The strategy\n/);
+    assert.match(d.markdown, /Ledger, then sync/);
+    assert.match(d.markdown, /Not sure yet — bank API/);
+    assert.match(d.markdown, /We start small\./);
+    assert.equal(d.editable, true);
+    assert.equal(d.edit.page, 'PUT /api/bongos/founding/work/strategize/page');
+    assert.ok(d.updated_at, 'the document says when it last changed');
+    // Editing it is editing the record: the same write, seen at once in the document.
+    await gw.setAnswer('strategize', 'big_pieces', { text: 'Sync first' }, 1, deps);
+    assert.match((await gw.readDocument('strategize', deps)).document.markdown, /Sync first/);
+    assert.equal((await gw.readDocument('nope', deps)).reason, 'unknown_stage');
+    const all = await gw.readDocuments(deps);
+    assert.deepEqual(Object.keys(all), ['scope', 'strategize', 'charter', 'legalize', 'legislation']);
+    assert.equal(all.strategize.filled, true);
+    assert.equal(all.scope.filled, false);
+    assert.equal(all.charter.title, 'The charter');
+  });
+
   console.log(`\ngenesis_work: ${passed} passed, ${failed} failed`);
   if (failed) process.exit(1);
 }

package/tests/genesis_work_routes.mjs

@@ -67,6 +67,15 @@ try {
     assert.equal(r.data.work.questions.find((q) => q.id === 'big_pieces').answer.text, 'Ledger first.');
   });
 
+  await test('task 1005115: any builder reads a stage\'s document; an unknown stage is 404', async () => {
+    assert.equal((await call('GET', '/founding/work/strategize/document', { as: null })).status, 401);
+    const r = await call('GET', '/founding/work/strategize/document', { as: OTHER });
+    assert.equal(r.status, 200);
+    assert.equal(r.data.document.title, 'The strategy');
+    assert.match(r.data.document.markdown, /Ledger first\./, 'the answer written above is in the document');
+    assert.equal((await call('GET', '/founding/work/nope/document')).status, 404);
+  });
+
   await test('a builder who is not the owner cannot write', async () => {
     for (const [m, p, body] of [
       ['PUT', '/founding/work/strategize/answers/risks', { text: 'x' }],

package/tests/government_charter_advice.mjs

@@ -0,0 +1,150 @@
+// tests/government_charter_advice.mjs — the genesis charter stage's recommendation
+// from the founder's own answers (task 1005119).
+//
+// The rules held here:
+//   • ONE recommender: the answers widen recommendedCharter; with none it answers
+//     exactly as the size ladder always has, for every type and size;
+//   • every recommendation is an adoptable form, says why in the founder's answers,
+//     and a Foundation still brings its council rank;
+//   • the principles point at a strictness preset (or none), and saying what a preset
+//     does is part of the answer;
+//   • the drafted bylaws list the recommended preset's own laws word for word, so the
+//     prose and the law book agree, and say plainly when no laws are switched on;
+//   • the closed answers' keys are the genesis questions' choices (two modules, one
+//     vocabulary, held equal here because neither may import the other).
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+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 reco = require(path.join(ROOT, 'modules', 'government', 'recommendations.js'));
+const presets = require(path.join(ROOT, 'modules', 'government', 'presets.js'));
+const charter = require(path.join(ROOT, 'modules', 'government', 'charter.js'));
+const advice = require(path.join(ROOT, 'modules', 'government', 'charter-advice.js'));
+const gw = require(path.join(ROOT, 'modules', 'onboarding', 'genesis-work.js'));
+
+const TYPES = [...reco.PROJECT_TYPES.map((t) => t.key), undefined];
+const SIZES = [0, 1, 2, 3, 8, 9, 49, 50, 149, 150, 1000];
+
+test('the answer keys are exactly the charter questions\' choices', () => {
+  const closed = Object.fromEntries(gw.QUESTIONS.charter.filter((q) => q.choices).map((q) => [q.id, q.choices.map((c) => c.key)]));
+  const expected = { ...reco.CHARTER_ANSWERS, ...presets.PRINCIPLE_ANSWERS };
+  assert.deepEqual(Object.keys(closed).sort(), Object.keys(expected).sort());
+  for (const [id, keys] of Object.entries(expected)) assert.deepEqual(closed[id], [...keys], id);
+});
+
+test('with no answers (or only "not sure"), the ladder answers exactly as before', () => {
+  for (const type of TYPES) {
+    for (const n of SIZES) {
+      const plain = reco.recommendedCharter(n, type);
+      for (const a of [undefined, {}, { final_say: 'maybe', agreement: null }]) {
+        const r = reco.recommendedCharter(n, type, a);
+        assert.equal(r.key, plain.key);
+        assert.equal(r.why, plain.why);
+        assert.equal(r.from_answers, false);
+      }
+    }
+  }
+});
+
+test('the founder\'s final say picks the form, and why quotes them', () => {
+  const r = reco.recommendedCharter(1, 'game', { final_say: 'everyone' });
+  assert.equal(r.key, 'direct-democracy', 'a solo founder who wants everyone deciding is not told monarchy');
+  assert.match(r.why, /You said everyone on the project should have the final say/);
+  assert.equal(r.from_answers, true);
+  const council = reco.recommendedCharter(5, 'research', { final_say: 'council' });
+  assert.equal(council.key, 'foundation');
+  assert.equal(council.council_rank, 'steering-committee', 'a Foundation still brings its council');
+});
+
+test('the other answers move the franchise when the final say is not given', () => {
+  assert.equal(reco.recommendedCharter(5, null, { answers_to: 'yes' }).key, 'foundation');
+  const back = reco.recommendedCharter(1, null, { step_back: 'yes' });
+  assert.equal(back.key, 'timocratic-republic');
+  assert.match(back.why, /step back/);
+  assert.equal(reco.recommendedCharter(5, null, { strangers: 'yes' }).key, 'timocratic-republic');
+  const fast = reco.recommendedCharter(5, null, { speed: 'fast' });
+  assert.equal(fast.key, 'direct-democracy', 'speed alone keeps the ladder\'s form');
+  assert.match(fast.why, /Who votes follows your size/, 'the part the answers did not decide says the ladder decided it');
+});
+
+test('how much agreement tunes the pass rule and says where it is set', () => {
+  const r = reco.recommendedCharter(20, null, { agreement: 'majority' });
+  assert.equal(r.key, 'timocratic-republic');
+  assert.equal(r.pass_rule, 'majority');
+  assert.equal(r.pass_rule_tuned, true);
+  assert.match(r.why, /legislation stage/);
+  const solo = reco.recommendedCharter(1, null, { final_say: 'founder', agreement: 'unanimous' });
+  assert.equal(solo.pass_rule, 'first_ratifier', 'a board of one is decided by its one yes');
+  assert.match(solo.why, /only voter/);
+});
+
+test('every answer combination recommends an adoptable form whose settings build a proposal', () => {
+  const A = reco.CHARTER_ANSWERS;
+  const available = charter.FORMS.filter((f) => f.available).map((f) => f.key);
+  const live = { membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true };
+  for (const fs of [undefined, ...A.final_say]) for (const ag of [undefined, ...A.agreement]) for (const yn of [undefined, 'yes', 'no']) {
+    const r = reco.recommendedCharter(5, 'business', { final_say: fs, agreement: ag, strangers: yn, answers_to: yn, step_back: yn });
+    assert.ok(available.includes(r.key), r.key);
+    assert.ok(typeof r.why === 'string' && r.why.length > 10);
+    const built = charter.buildCharterProposal(live, { franchise: r.franchise, passRule: r.pass_rule, councilRank: r.council_rank });
+    assert.equal(built.ok, true, JSON.stringify(r));
+    assert.equal(charter.readCharter(built.proposal).franchise, r.franchise);
+  }
+});
+
+test('principles point at a preset, or at none', () => {
+  assert.equal(presets.recommendedPreset({}), null, 'no preset is a fine answer');
+  assert.equal(presets.recommendedPreset({ trust_level: 'a_lot' }).key, 'open');
+  assert.equal(presets.recommendedPreset({ trust_level: 'some' }).key, 'guild');
+  assert.equal(presets.recommendedPreset({ trust_level: 'little' }).key, 'factory');
+  assert.equal(presets.recommendedPreset({ trust_level: 'a_lot', catch_or_fix: 'catch_early' }).key, 'guild');
+  assert.equal(presets.recommendedPreset({ trust_level: 'little', catch_or_fix: 'move_fast' }).key, 'guild');
+  const p = presets.recommendedPreset({ trust_level: 'some' });
+  assert.match(p.why, /You said/);
+  assert.match(p.is, /not a style guide/);
+  assert.ok(p.laws.length > 0);
+});
+
+test('the draft names the recommended preset\'s own laws word for word', () => {
+  const a = advice.buildAdvice({
+    answers: { final_say: 'trusted', trust_level: 'little' },
+    prose: { feel: 'Calm and careful.', leave_behaviour: 'Lying about shipped work.', write_down: 'We never ship on Fridays.' },
+    headcount: 12,
+  });
+  assert.equal(a.charter.key, 'timocratic-republic');
+  assert.equal(a.preset.key, 'factory');
+  const factory = presets.PRESETS.find((p) => p.key === 'factory');
+  for (const law of factory.laws) assert.ok(a.draft_md.includes(`**${law.text}.** ${law.effect_on_ai}`), law.text);
+  assert.ok(a.preset.locks.some((l) => l.setting === 'wandering'), 'what it would lock is said');
+  assert.match(a.draft_md, /Timocratic Republic/);
+  assert.match(a.draft_md, /Calm and careful\./);
+  assert.match(a.draft_md, /Lying about shipped work\./);
+  assert.match(a.draft_md, /We never ship on Fridays\./);
+});
+
+test('with no preset the draft says no laws are switched on', () => {
+  const a = advice.buildAdvice({ answers: {}, headcount: 1 });
+  assert.equal(a.preset, null);
+  assert.match(a.draft_md, /No laws are switched on/);
+  assert.equal(a.charter.key, 'monarchy');
+  assert.doesNotMatch(a.draft_md, /Code of conduct/, 'no section for words the founder has not written');
+});
+
+test('the port entry reads the head count and the law book', async () => {
+  const calls = [];
+  const db = {
+    countActiveBuilders: async () => { calls.push('count'); return 40; },
+    listLaws: async () => { calls.push('laws'); return []; },
+  };
+  const live = await advice.charterAdvice({ answers: {}, prose: { feel: '  ' } }, { db });
+  assert.equal(live.headcount, 40);
+  assert.equal(live.charter.key, 'timocratic-republic');
+  assert.ok(calls.includes('laws'));
+  const expected = await advice.charterAdvice({ answers: {}, headcount: 2 }, { db });
+  assert.equal(expected.headcount, 2, 'the founder\'s expected number wins over the live count');
+  assert.equal(expected.charter.key, 'monarchy');
+});