@bongos/core 1.21.88 → 1.21.89

package/modules/hall-ui/public/genesis-home.js

@@ -33,6 +33,17 @@
     not_deciding: 'The plan is already settled.',
   };
 
+  // What saving the plan did to the government, when it was not settled in the same
+  // click. The server's charter outcome (modules/onboarding/genesis-home.js
+  // applyGovernmentChoice); in_force and none need no sentence.
+  function charterNote(c) {
+    if (!c) return '';
+    if (c.state === 'sitting') return 'Your starting government is in the Board Room for a vote.';
+    if (c.state === 'needs_council') return 'A Foundation needs a council first. Add a council rank, then choose Foundation on the Charter.';
+    if (c.state === 'not_filed') return 'The plan is saved, but the government could not be changed just now. You can change it on the Charter.';
+    return '';
+  }
+
   function projectName() {
     var b = window.__BRANDING__ || {};
     return (b.identity && b.identity.productName) || 'the project';
@@ -307,7 +318,21 @@
       var t = e.target.closest('button');
       if (!t || !host.contains(t)) return;
       if (t.hasAttribute('data-genesis-plan')) {
-        act(send('POST', '/founding/plan', planBody(host)).then(function () { window.location.reload(); }));
+        // The government picked here is filed as a charter amendment with the plan
+        // (task 1004656). When the founder's one yes decides it, saving the plan is
+        // that yes too, the same one-click fast-track the stage closes take.
+        act(send('POST', '/founding/plan', planBody(host)).then(function (out) {
+          var c = out && out.charter;
+          if (c && c.state === 'sitting' && c.one_vote_decides && c.item_id) {
+            return send('POST', '/government/board/items/' + encodeURIComponent(c.item_id) + '/votes', { direction: 'yes' })
+              .catch(function () { return null; });
+          }
+          var said = charterNote(c);
+          if (!said) return null;
+          toast(said);
+          // Give the sentence time to be read before the reload takes it away.
+          return new Promise(function (done) { setTimeout(done, 3500); });
+        }).then(function () { window.location.reload(); }));
       } else if (t.hasAttribute('data-genesis-close')) {
         // The solo fast-track (spec D4): when the founder's one yes decides the sitting
         // and nobody else is asked, the close and the confirm are one click.

package/modules/hall-ui/public/street-amend.js

@@ -50,6 +50,38 @@
     var d = constitution && constitution.decision_rules;
     return d && Array.isArray(d.rules) ? d.rules.filter(function (r) { return r && r.key; }) : [];
   }
+  // The forms of government a charter draft can pick in one tap (task 1004656), from
+  // the constitution's own charter block (modules/government/charter.js), so a name
+  // is never typed twice. A form is a franchise plus a pass rule; its seat is the
+  // franchise option's predicate. Foundation seats a council the owner names (a
+  // custom rank this page cannot know), so it is listed as needing one rather than
+  // offered; the forms that cannot be adopted yet are listed as later.
+  function formsOf(constitution) {
+    var ch = constitution && constitution.charter;
+    var forms = ch && Array.isArray(ch.forms) ? ch.forms : [];
+    var seats = {};
+    (ch && Array.isArray(ch.variables) ? ch.variables : []).forEach(function (v) {
+      if (v && v.key === 'franchise' && Array.isArray(v.options)) {
+        v.options.forEach(function (o) { if (o && o.key && o.predicate) seats[o.key] = o.predicate; });
+      }
+    });
+    var out = { pick: [], council: [], later: [] };
+    forms.forEach(function (f) {
+      if (!f || !f.key) return;
+      if (!f.available) { out.later.push(str(f.name)); return; }
+      var seat = seats[f.franchise];
+      if (!seat || !FROM_PASS[f.pass_rule]) { out.council.push(str(f.name)); return; }
+      out.pick.push({ value: f.key, words: str(f.name), decided_by: seat, rule: FROM_PASS[f.pass_rule] });
+    });
+    return out;
+  }
+  // Which form the draft's settings make, or null (the name follows the settings).
+  function formOf(d) {
+    var list = (d && d.forms && d.forms.pick) || [];
+    for (var i = 0; i < list.length; i++) if (list[i].decided_by === d.decided_by && list[i].rule === d.rule) return list[i];
+    return null;
+  }
+
   function rowOf(constitution, area) {
     var as = areasOf(constitution) || [];
     for (var i = 0; i < as.length; i++) if (as[i] && as[i].area === area) return as[i];
@@ -103,6 +135,7 @@
         ? { decided_by: board.membership, rule: FROM_PASS[board.pass_rule] || null }
         : { decided_by: row.decided_by, rule: row.decided_by === 'gate' ? null : row.rule },
       decided_by: null, rule: null, reason: '',
+      forms: charter ? formsOf(constitution) : { pick: [], council: [], later: [] },
     };
     if (charter) {
       d.decided_by = board.membership;
@@ -131,11 +164,21 @@
   }
   function copy(d) { var o = {}; for (var k in d) if (Object.prototype.hasOwnProperty.call(d, k)) o[k] = d[k]; return o; }
 
-  // One pick: field 'who' | 'rule' | 'reason'. A value outside the vocabulary
-  // is refused (the draft comes back unchanged).
+  // One pick: field 'form' (the charter only) | 'who' | 'rule' | 'reason'. A value
+  // outside the vocabulary is refused (the draft comes back unchanged). A form sets
+  // who and which rule together; picking either afterwards leaves the form to be
+  // read back from the settings.
   function pick(d, field, value) {
     if (!d || !d.ok) return d;
     var n = copy(d);
+    if (field === 'form') {
+      var list = (d.forms && d.forms.pick) || [], f = null;
+      for (var i = 0; i < list.length; i++) if (list[i].value === value) f = list[i];
+      if (!f || !hasValue(d.whoOptions, f.decided_by)) return d;
+      n.decided_by = f.decided_by;
+      n.rule = f.rule;
+      return settle(n);
+    }
     if (field === 'who') { if (!hasValue(d.whoOptions, value)) return d; n.decided_by = value; }
     else if (field === 'rule') { if (!hasValue(d.ruleOptions, value)) return d; n.rule = value; }
     else if (field === 'reason') { n.reason = str(value).slice(0, REASON_MAX); return n; }
@@ -190,6 +233,10 @@
     if (check(d)) return null;
     var api = (card() && card().API) || '/api/bongos';
     var why = str(d.reason).trim();
+    // A named form goes through the charter route, so the record reads
+    // "Charter: Direct Democracy" and the server builds the same constitution.
+    var form = d.charter ? formOf(d) : null;
+    if (form) return { method: 'POST', url: api + '/government/board/charter', body: { form: form.value, rationale_md: why } };
     if (d.charter) return { method: 'POST', url: api + '/government/board/items', body: { subject_type: 'constitutional_amendment', proposal: proposal(d), rationale_md: why } };
     return { method: 'POST', url: api + '/government/board/decision-rules', body: { rules: [ruleRow(d)], rationale_md: why } };
   }
@@ -205,6 +252,9 @@
     nobody_is_vacant: 'An empty building decides nothing.',
     bad_membership: 'That is not a seat this project knows.',
     bad_pass_rule: 'That is not a way the board can decide.',
+    council_needs_a_rank: 'A Foundation needs a council rank first.',
+    unknown_council_rank: 'There is no such council rank yet, so that would seat no one.',
+    form_not_available: 'That form of government is not available yet.',
   };
   function refusal(status, body) {
     var e = body && body.error ? body.error : {};
@@ -213,7 +263,7 @@
     if (e.code === 'no_change') return 'That already is how it works. Nothing was filed.';
     if (status === 401) return 'Sign in to file an amendment.';
     if (status === 403) return 'Filing an amendment is not yours to do here. The server refused it.';
-    if ((e.code === 'invalid_decision_rules' || e.code === 'invalid_proposal') && det.reason) {
+    if ((e.code === 'invalid_decision_rules' || e.code === 'invalid_proposal' || e.code === 'invalid_charter') && det.reason) {
       return REASONS[det.reason] || 'The server refused it: ' + str(det.reason).replace(/_/g, ' ') + '.';
     }
     var C = card();
@@ -224,7 +274,9 @@
   function answer(d, body) {
     var item = body && body.item;
     return {
-      toast: 'Filed. Your amendment to ' + (d && d.name ? d.name : 'this building') + ' is on the Charter for the council to vote on.',
+      toast: d && d.charter && formOf(d)
+        ? 'Filed. Changing the government to ' + formOf(d).words + ' is on the Charter for the council to vote on.'
+        : 'Filed. Your amendment to ' + (d && d.name ? d.name : 'this building') + ' is on the Charter for the council to vote on.',
       building: 'charter',
       matter: item && item.id != null ? 'board:' + item.id : null,
       kind: 'light',
@@ -234,6 +286,7 @@
   var api = {
     RANKS: RANKS, draftFor: draftFor, pick: pick, changed: changed, change: change,
     check: check, request: request, refusal: refusal, answer: answer, whoOptions: whoOptions, ruleOptions: ruleOptions,
+    formsOf: formsOf, formOf: formOf,
   };
   root.GovAmend = api;
   if (typeof module !== 'undefined' && module.exports) module.exports = api;

package/modules/hall-ui/public/street.js

@@ -1099,6 +1099,19 @@
     } else ch.appendChild(node('p', 'inside-note', 'This is how it works today. Pick who decides, or how, to change it.'));
     box.appendChild(ch);
     var picks = node('div', 'inside-draft__picks');
+    // The Charter's draft leads with the forms of government, one tap each (task
+    // 1004656): a form sets who decides and how together, and the chip lit is the
+    // form the settings make, so a hand-picked mix lights none.
+    if (d.charter && d.forms && d.forms.pick.length) {
+      var lit = A.formOf(d);
+      picks.appendChild(draftField('government', 'insideDraftForm', draftChips('insideDraftForm', d.forms.pick, lit ? lit.value : null, function (v) {
+        dr.d = A.pick(dr.d, 'form', v); dr.error = ''; bumpDraft('insideDraftForm');
+      }), true));
+      var aside = [];
+      if (d.forms.council.length) aside.push(d.forms.council.join(', ') + ' needs a council rank first.');
+      if (d.forms.later.length) aside.push('Coming later: ' + d.forms.later.join(', ') + '.');
+      if (aside.length) picks.appendChild(node('p', 'inside-note inside-draft__later', aside.join(' ')));
+    }
     picks.appendChild(draftField('who decides', 'insideDraftWho', draftChips('insideDraftWho', d.whoOptions, d.decided_by, function (v) {
       dr.d = A.pick(dr.d, 'who', v); dr.error = ''; bumpDraft('insideDraftWho');
     }), true));

package/modules/onboarding/genesis-home.js

@@ -57,8 +57,8 @@ const MAX_DAYS = 90;
 const intIn = (v, lo, hi) => Number.isInteger(v) && v >= lo && v <= hi;
 
 // parsePlan(body) — PURE. The founder's plan, defaults filled in, or why it is refused.
-// The government is recorded, not applied: the charter stage (task 1004427) files it as
-// an amendment, so here it is only a well-formed form key.
+// Here the government is only a well-formed form key; savePlan files it as a charter
+// amendment once the plan is saved (applyGovernmentChoice, task 1004656).
 function parsePlan(body = {}) {
   const b = body && typeof body === 'object' ? body : {};
   const days = {};
@@ -281,7 +281,46 @@ async function savePlan(body, builderId, deps = {}) {
   await s.set(PLAN_KEY, JSON.stringify(parsed.plan), builderId);
   const seeded = await s.lifecycle.seedGenesis({ builderId, existing: parsed.plan.existing });
   await fm.setFoundingMode({ stage: 'scope' }, builderId, modeDeps(s));
-  return { ok: true, plan: parsed.plan, seeded: seeded && seeded.seeded };
+  const charter = await applyGovernmentChoice(parsed.plan.government, builderId, s);
+  return { ok: true, plan: parsed.plan, seeded: seeded && seeded.seeded, charter };
+}
+
+// applyGovernmentChoice — the government picked at decide becomes the one in force
+// (task 1004656). It is filed as an ordinary charter amendment under the constitution
+// in force (the government port's proposeCharter), so the board decides it like any
+// change to the rules: under the monarchy default the founder's own yes applies it,
+// and every later stage is then closed by the government they chose (spec D7).
+// Never refuses the plan — the plan is saved first, and a choice that cannot be filed
+// says why in `state`:
+//   none          no government was picked
+//   in_force      the constitution already reads as that form (Monarchy at birth)
+//   sitting       filed; `item_id`, and `one_vote_decides` when one yes carries it
+//   needs_council Foundation, which needs a council rank before it can seat anyone
+//   not_filed     anything else (`reason`), or no government module to file it with
+async function applyGovernmentChoice(form, builderId, s) {
+  if (!form) return { state: 'none' };
+  const gov = s.government;
+  if (!gov || typeof gov.proposeCharter !== 'function') return { state: 'not_filed', form, reason: 'no_government' };
+  let out;
+  try {
+    out = await gov.proposeCharter({ form, proposedBy: builderId });
+  } catch (_) {
+    return { state: 'not_filed', form, reason: 'charter_failed' };
+  }
+  if (out && out.ok) {
+    const snap = (out.item && out.item.constitution) || {};
+    return {
+      state: 'sitting',
+      form,
+      item_id: out.item ? String(out.item.id) : null,
+      one_vote_decides: snap.pass_rule === 'first_ratifier',
+      reads_as: out.reads_as ? out.reads_as.name : null,
+    };
+  }
+  const reason = (out && out.reason) || 'charter_failed';
+  if (reason === 'no_change') return { state: 'in_force', form };
+  if (reason === 'council_needs_a_rank') return { state: 'needs_council', form };
+  return { state: 'not_filed', form, reason };
 }
 
 // closeStage — put the current stage to the Board Room. The finished-tasks gate is the
@@ -335,7 +374,7 @@ async function onStagePassed(deps = {}) {
 
 module.exports = {
   PLAN_KEY, STAGE_INFO, PROPER, DEMO_PEOPLE, DEMO_HOURS, intIn, parsePlan, shapeGenesis, demoMinutes, demoPlan,
-  readGenesis, startFounding, savePlan, closeStage, comeAlive, onStagePassed,
+  readGenesis, startFounding, savePlan, applyGovernmentChoice, closeStage, comeAlive, onStagePassed,
   // the founding-mode deps this file reads the mode with, for founding-birth.js (task 1004506)
   modeDepsFor: (deps) => modeDeps(seams(deps)),
 };

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.88",
+  "version": "1.21.89",
   "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

@@ -9358,5 +9358,11 @@
       "id": "1004482",
       "text": "Upgrading a project now clears out commands Bongos used to ship but has since retired (the old dev-box commands, the old /dev /ideate /paint playbooks, the pixel-art commands), so the Commands page and Claude's menu only list"
     }
+  ],
+  "1.21.89": [
+    {
+      "id": "1004656",
+      "text": "A new project now really runs under the government its founder picks. Before, the choice made while creating a project was stored and then ignored, so every project stayed under one-person rule. Now picking a government files"
+    }
   ]
 }

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.21.88'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.89'; // 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_government.mjs

@@ -0,0 +1,220 @@
+// tests/genesis_government.mjs — THE GOVERNMENT PICKED AT GENESIS IS THE ONE IN FORCE
+// (task 1004656, goal 1000111 criterion gov-born-governed).
+//
+// WHAT IT GUARDS. A founder picks a starting government on the genesis decide screen.
+// Before this task the pick was stored in the plan and never read again, so every
+// project left genesis on the default monarchy it never chose. Now saving the plan
+// files the pick as a charter amendment under the constitution in force, and under the
+// monarchy a project is born with, the founder's own yes applies it. What can go wrong:
+//   * the pick saved but nothing filed (the old bug), or filed and never applied;
+//   * a pick that cannot be filed refusing the whole plan (the plan must always save);
+//   * Foundation filed with no council, which would seat nobody;
+//   * the hall's Charter picker filing a constitution the server would not build.
+//
+// The path RUNS end to end over the real code: genesis-home's savePlan with the REAL
+// government port's proposeCharter, castVote and close (db stubbed, the board's own
+// logic real), and the ratified text written through the stubbed apply. The hall
+// picker runs the real street-amend.js over the server's real charter view.
+//
+// Run:  node --test tests/genesis_government.mjs
+
+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 GOV = path.join(ROOT, 'modules', 'government');
+const gh = require(path.join(ROOT, 'modules', 'onboarding', 'genesis-home.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 charter = require(path.join(GOV, 'charter.js'));
+const DR = require(path.join(GOV, 'decision-rules.js'));
+const A = require(path.join(ROOT, 'modules', 'hall-ui', 'public', 'street-amend.js'));
+
+const MONARCHY = Object.freeze({ membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true });
+const FOUNDER = '42';
+const j = (v) => JSON.parse(JSON.stringify(v));
+
+// A founding project in its decide stage: an in-memory project_settings store, a fake
+// lifecycle seeder, and the REAL government port surface genesis-home calls.
+function project() {
+  const store = new Map();
+  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: { seedGenesis: async () => ({ seeded: 5 }), genesisTasks: async () => ({}) },
+    government: {
+      proposeCharter: board.proposeCharter,
+      genesisStageStatus: async () => ({ stages: [] }),
+    },
+    now: new Date('2026-10-08T00:00:00Z'),
+  };
+  return { store, deps };
+}
+
+// The board's db, stubbed to one founder under the monarchy a project is born with;
+// everything that decides (validation, the self-removal guard, the tally, the close)
+// is the real board.js. Returns what was filed and what was applied.
+async function underMonarchy(fn) {
+  const seen = { filed: null, applied: [], votes: [] };
+  const originals = {};
+  const stubs = {
+    builderHoldsRankActive: async () => true,
+    getRankByKey: async () => null,
+    createAmendment: async (args) => { seen.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: FOUNDER, constitution: MONARCHY, closed_at: null, expired: false }),
+    insertBoardVote: async (row) => { const v = { voter_id: row.voterId, direction: row.direction }; seen.votes.push(v); return v; },
+    insertVoteKarma: async () => {},
+    getVotesForItem: async () => seen.votes,
+    getActiveBuildersWithRank: async () => [{ builder_id: FOUNDER, github_login: 'founder', display_name: 'Founder' }],
+    getBoardItemAuthor: async () => FOUNDER,
+    closeBoardItem: async ({ outcome }) => ({ id: '21', subject_type: 'constitutional_amendment', subject_id: '5', opened_by: FOUNDER, closed_at: 'T', outcome }),
+    insertAuthorRatifyKarma: async () => true,
+    getAmendment: async () => ({ id: '5', proposed: seen.filed.proposed }),
+  };
+  for (const [k, v] of Object.entries(stubs)) { originals[k] = db[k]; db[k] = v; }
+  const originalApply = config.applyBoardAmendment;
+  config.applyBoardAmendment = (proposed) => { seen.applied.push(proposed); return proposed; };
+  try { await fn(seen); } finally {
+    for (const [k, v] of Object.entries(originals)) db[k] = v;
+    config.applyBoardAmendment = originalApply;
+  }
+  return seen;
+}
+
+async function decide(plan) {
+  const p = project();
+  assert.equal((await gh.startFounding(FOUNDER, p.deps)).ok, true);
+  const out = await gh.savePlan(plan, FOUNDER, p.deps);
+  return { p, out };
+}
+
+test('this checkout is born a monarchy, the state every genesis starts from', () => {
+  assert.equal(charter.readCharter(config.loadGovernmentConfig().board).form, 'monarchy');
+});
+
+for (const form of ['timocratic-republic', 'direct-democracy']) {
+  test(`picking ${form} at decide files it, the founder's one yes applies it, and the constitution reads as ${form}`, async () => {
+    const seen = await underMonarchy(async () => {
+      const { out } = await decide({ government: form });
+      assert.equal(out.ok, true, 'the plan saves');
+      assert.equal(out.charter.state, 'sitting', 'the pick is filed, not just recorded');
+      assert.equal(out.charter.one_vote_decides, true, 'under the monarchy the founder\'s yes carries it');
+      assert.equal(out.charter.item_id, '21');
+      // what the hall does next: the founder's yes, then the close
+      await board.castVote({ itemId: out.charter.item_id, voterId: FOUNDER, direction: 'yes' });
+      assert.equal((await board.maybeCloseAfterVote(out.charter.item_id)).outcome, 'passed');
+    });
+    assert.equal(seen.applied.length, 1, 'the ratified constitution is applied once');
+    assert.equal(charter.readCharter(seen.applied[0]).form, form, 'the constitution in force is the government the founder picked');
+    assert.match(seen.filed.rationaleMd, /^Charter: /, 'the record says in words what was chosen');
+  });
+}
+
+test('picking Monarchy files nothing: it is already the government in force', async () => {
+  const seen = await underMonarchy(async () => {
+    const { out } = await decide({ government: 'monarchy' });
+    assert.equal(out.ok, true);
+    assert.deepEqual(out.charter, { state: 'in_force', form: 'monarchy' });
+  });
+  assert.equal(seen.filed, null);
+});
+
+test('Foundation needs a council first: the plan saves, nothing is filed, and the reason is named', async () => {
+  const seen = await underMonarchy(async () => {
+    const { p, out } = await decide({ government: 'foundation' });
+    assert.equal(out.ok, true, 'the plan is never refused over the government');
+    assert.deepEqual(out.charter, { state: 'needs_council', form: 'foundation' });
+    assert.equal(JSON.parse(p.store.get(gh.PLAN_KEY)).government, 'foundation', 'the pick is still recorded');
+  });
+  assert.equal(seen.filed, null, 'a council nobody sits on is never filed');
+});
+
+test('no pick, no government module, a refusal, a throw: the plan still saves and says what happened', async () => {
+  let r = await decide({});
+  assert.deepEqual(r.out.charter, { state: 'none' });
+  const p = project();
+  await gh.startFounding(FOUNDER, p.deps);
+  p.deps.government = { genesisStageStatus: async () => ({ stages: [] }) };
+  r = { out: await gh.savePlan({ government: 'direct-democracy' }, FOUNDER, p.deps) };
+  assert.equal(r.out.ok, true);
+  assert.deepEqual(r.out.charter, { state: 'not_filed', form: 'direct-democracy', reason: 'no_government' });
+  for (const [proposeCharter, reason] of [
+    [async () => ({ ok: false, reason: 'unknown_form' }), 'unknown_form'],
+    [async () => { throw new Error('board down'); }, 'charter_failed'],
+  ]) {
+    const q = project();
+    await gh.startFounding(FOUNDER, q.deps);
+    q.deps.government = { proposeCharter, genesisStageStatus: async () => ({ stages: [] }) };
+    const out = await gh.savePlan({ government: 'direct-democracy' }, FOUNDER, q.deps);
+    assert.equal(out.ok, true, `${reason}: the plan saves`);
+    assert.equal(out.charter.state, 'not_filed');
+    assert.equal(out.charter.reason, reason);
+  }
+});
+
+test('a demo stays the monarchy it is born with (owner ruling 2026-10-01): nothing is filed', () => {
+  assert.equal(gh.demoPlan({ people: 3, hours_each: 4 }).government, 'monarchy');
+});
+
+// ── the hall's Charter picker ───────────────────────────────────────────────
+
+function constitutionView(boardBlock = MONARCHY) {
+  return j({
+    board: boardBlock,
+    charter: charter.charterView(boardBlock),
+    decision_rules: {
+      areas: DR.resolveAll([], { board: boardBlock }),
+      rules: DR.DECISION_RULES.map((r) => ({ key: r.key, words: r.words })),
+      changed_by: 'a passed amendment only',
+    },
+  });
+}
+
+test('the Charter offers the forms that can be adopted in one tap; Foundation and the later forms are named, not offered', () => {
+  const d = A.draftFor('charter', constitutionView());
+  assert.deepEqual(d.forms.pick.map((f) => f.words), ['Monarchy / BDFL', 'Timocratic Republic', 'Direct Democracy']);
+  assert.deepEqual(d.forms.council, ['Foundation']);
+  assert.deepEqual(d.forms.later, ['Presidential', 'Cooperative', 'Federation']);
+  assert.equal(A.draftFor('review', constitutionView()).forms.pick.length, 0, 'only the Charter carries forms');
+});
+
+test('a tapped form sets who and how together, files through the charter route, and the server builds the same constitution', () => {
+  for (const key of ['timocratic-republic', 'direct-democracy']) {
+    let d = A.draftFor('charter', constitutionView());
+    d = A.pick(d, 'form', key);
+    assert.equal(A.formOf(d).value, key, 'the lit chip is the form the settings make');
+    d = A.pick(d, 'reason', 'More of us should decide.');
+    const req = A.request(d);
+    assert.equal(req.url, '/api/bongos/government/board/charter');
+    assert.deepEqual(req.body, { form: key, rationale_md: 'More of us should decide.' });
+    // what the server files for that body
+    const built = charter.buildCharterProposal(MONARCHY, { form: key });
+    assert.equal(built.ok, true);
+    assert.equal(built.proposal.membership, d.decided_by, `${key}: the seat the hall showed is the seat the server files`);
+    assert.equal(charter.readCharter(built.proposal).form, key);
+    assert.match(A.answer(d, { item: { id: 7 } }).toast, new RegExp(A.formOf(d).words.replace(/[/]/g, '\\/')));
+  }
+});
+
+test('picking who or how by hand after a form lights no form, and files as a plain amendment', () => {
+  let d = A.pick(A.draftFor('charter', constitutionView()), 'form', 'direct-democracy');
+  d = A.pick(d, 'rule', 'majority');
+  assert.equal(A.formOf(d), null, 'the name follows the settings: a mix is no named form');
+  d = A.pick(d, 'reason', 'A majority, not consent.');
+  assert.equal(A.request(d).url, '/api/bongos/government/board/items');
+  assert.equal(A.pick(d, 'form', 'presidential'), d, 'a form outside the offered set changes nothing');
+});
+
+test('the charter route\'s refusals are said in words', () => {
+  const d = A.draftFor('charter', constitutionView());
+  const say = (reason) => A.refusal(400, { error: { code: 'invalid_charter', details: { reason } } });
+  assert.match(say('council_needs_a_rank'), /council rank/);
+  assert.match(say('form_not_available'), /not available yet/);
+  assert.ok(d.ok);
+});