@bongos/core 1.25.19 → 1.25.21

package/tests/founding_mode.mjs

@@ -143,7 +143,8 @@ function makeHall() {
     documentElement: root,
     createElement: (t) => new El(t),
     querySelector: (sel) => (sel === '.app-body' ? appBody : null),
-    querySelectorAll: (sel) => (sel === '#app-sidebar .nav-item--asleep' ? nav.filter((a) => a.classList.contains('nav-item--asleep')) : []),
+    querySelectorAll: (sel) => (sel === '#app-sidebar .nav-item--asleep, #app-sidebar .nav-item--arrived'
+      ? nav.filter((a) => a.classList.contains('nav-item--asleep') || a.classList.contains('nav-item--arrived')) : []),
     getElementById: (id) => nav.find((a) => a.id === id) || appBody.children.find((c) => c.id === id) || null,
   };
   return { document, nav, appBody, root };
@@ -164,12 +165,12 @@ function sliceFn(name) {
   assert.ok(start > -1 && end > start, name + ' was located in shell.js');
   return SHELL.slice(start, end + 4);
 }
-function loadApplyFounding(document, access, brand = { identity: { productName: 'Kestrel' } }) {
+function loadApplyFounding(document, access, brand = { identity: { productName: 'Kestrel' } }, storage = null) {
   const wakeStart = SHELL.indexOf('  var WAKE_TEXT = {');
   const wakeEnd = SHELL.indexOf('};', wakeStart) + 2;
   assert.ok(wakeStart > -1, 'WAKE_TEXT was located in shell.js');
   const src = [SHELL.slice(wakeStart, wakeEnd), sliceEsc(), sliceFn('applyFounding')].join('\n');
-  return new Function('document', 'brand', 'access', 'window', `${src}\nreturn applyFounding;`)(document, brand, access, { OTB: realOTB() });
+  return new Function('document', 'brand', 'access', 'window', `${src}\nreturn applyFounding;`)(document, brand, access, { OTB: realOTB(), localStorage: storage || undefined });
 }
 
 const snapshot = (h) => JSON.stringify({
@@ -213,8 +214,8 @@ test('founding ON: the band above the topbar, and the rooms the server named asl
   const byId = (id) => h.nav.find((a) => a.id === 'nav-' + id);
   assert.ok(!byId('goals').classList.contains('nav-item--asleep'), 'scope is behind: goals is awake');
   assert.ok(byId('work').classList.contains('nav-item--asleep'), 'strategize is current: tasks still sleeps');
-  assert.equal(byId('work').children[0].textContent, 'opens after strategy', 'a sentence, never a raw slug');
-  assert.equal(byId('collab').children[0].textContent, 'opens when alive');
+  assert.equal(byId('work').children.length, 0, 'a hidden room carries no label nobody can see (task 1005112)');
+  assert.ok(byId('collab').classList.contains('nav-item--asleep'), 'community sleeps until alive');
   assert.ok(!byId('home').classList.contains('nav-item--asleep'), 'home is never put to sleep');
 });
 
@@ -227,7 +228,7 @@ test('founding OFF after ON restores the hall exactly — OFF removes, it does n
   assert.notEqual(snapshot(h), before);
   access.founding = null;
   apply();
-  assert.equal(snapshot(h), before, 'band, asleep classes, wake tags and the root attribute are all gone');
+  assert.equal(snapshot(h), before, 'band, asleep classes and the root attribute are all gone');
 });
 
 test('the band escapes what it prints — a project name cannot inject markup', () => {
@@ -280,13 +281,13 @@ test('a failing waiting-on source never turns the mode off', async () => {
   assert.equal(f.waiting_on, null);
 });
 
-test('re-applying ON does not stack a second band or duplicate wake tags', () => {
+test('re-applying ON does not stack a second band or add anything to a room', () => {
   const h = makeHall();
   const access = { founding: fm.shapeFoundingMode({ active: 'true', stage: 'decide' }) };
   const apply = loadApplyFounding(h.document, access);
   apply(); apply();
   assert.equal(h.appBody.children.filter((c) => c.id === 'founding-band').length, 1);
-  assert.equal(h.nav.find((a) => a.id === 'nav-work').children.length, 1);
+  assert.equal(h.nav.find((a) => a.id === 'nav-work').children.length, 0);
 });
 
 // ── the wiring ──────────────────────────────────────────────────────────────
@@ -317,3 +318,78 @@ test('founding mode adds no page, no route and no nav item — it is a mode', ()
   const hall = fs.readdirSync(path.join(ROOT, 'modules', 'hall-ui', 'public'));
   assert.ok(!hall.some((f) => /^founding\./.test(f)), 'no founding page file');
 });
+
+// ── task 1005112: hidden, not dimmed; the arrival; the honest refusal ─────────
+
+test('a sleeping room is hidden by the sheet, and a group of sleeping rooms hides its head', () => {
+  const css = fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'style.css'), 'utf8');
+  assert.match(css, /\.nav-item--asleep \{ display: none; \}/, 'asleep is not drawn at all, never dimmed');
+  assert.doesNotMatch(css, /\.nav-item--asleep \{ opacity/);
+  assert.match(css, /html\[data-founding="on"\] \.nav-group:not\(:has\(\.nav-item:not\(\.nav-item--asleep\)/);
+});
+
+test('a room that woke since this browser last looked arrives marked, once (task 1005112)', () => {
+  const store = new Map();
+  const storage = { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, String(v)) };
+  const at = (stage) => ({ founding: fm.shapeFoundingMode({ active: 'true', stage }) });
+  const h1 = makeHall();
+  loadApplyFounding(h1.document, at('scope'), undefined, storage)();
+  assert.ok(!h1.nav.some((a) => a.classList.contains('nav-item--arrived')), 'the first look marks nothing');
+  const h2 = makeHall();
+  loadApplyFounding(h2.document, at('strategize'), undefined, storage)();
+  const arrived = h2.nav.filter((a) => a.classList.contains('nav-item--arrived')).map((a) => a.id);
+  assert.deepEqual(arrived.sort(), ['nav-goal-map', 'nav-goals'], 'scope finished: Goals and Sky arrive');
+  const h3 = makeHall();
+  loadApplyFounding(h3.document, at('strategize'), undefined, storage)();
+  assert.ok(!h3.nav.some((a) => a.classList.contains('nav-item--arrived')), 'the next page load: no mark again');
+  // Switching off removes the mark with everything else.
+  const access = at('charter');
+  const h4 = makeHall();
+  const before = snapshot(h4);
+  const apply = loadApplyFounding(h4.document, access, undefined, storage);
+  apply();
+  access.founding = null;
+  apply();
+  assert.equal(snapshot(h4), before);
+});
+
+test('the shell says, on Home, what a refused room is and which stage opens it (task 1005112)', () => {
+  const navStart = SHELL.indexOf('  var NAV = [');
+  const navEnd = SHELL.indexOf('  var NAV_COLLAPSE_KEY');
+  const wakeStart = SHELL.indexOf('  var WAKE_TEXT = {');
+  const wakeEnd = SHELL.indexOf('};', wakeStart) + 2;
+  const src = [SHELL.slice(navStart, navEnd), SHELL.slice(wakeStart, wakeEnd), sliceEsc(),
+    sliceFn('navItemById'), sliceFn('renderDeniedNotice')].join('\n');
+  let inserted = null;
+  let replaced = null;
+  const el = { querySelector: () => ({ addEventListener() {} }), setAttribute() {} };
+  const document = {
+    getElementById: (id) => (id === 'app-topbar' ? { insertAdjacentElement: (_, n) => { inserted = n; } } : null),
+    createElement: () => el,
+  };
+  const run = (search) => {
+    inserted = null;
+    new Function('document', 'window', 'history', 'brand', 'access', 'icon', 'chevronIcon',
+      `${src}\nreturn renderDeniedNotice;`)(document,
+      { location: { search, pathname: '/', hash: '' }, OTB: realOTB() },
+      { replaceState: (a, b, url) => { replaced = url; } }, {}, {}, () => '', () => '')();
+    return inserted;
+  };
+  const n = run('?asleep=goals&opens=scope');
+  assert.ok(n, 'a notice is drawn');
+  assert.match(n.innerHTML, /Goals isn’t open yet\. It opens after scope\. Finish that stage of founding here on Home\./);
+  assert.equal(replaced, '/', 'the query is stripped so a refresh does not re-show it');
+  assert.equal(run('?asleep=goals%3Cx&opens=scope'), null, 'a malformed room id draws nothing');
+  assert.match(run('?denied=page.view.government').innerHTML, /permission/, 'the old denial still reads the same');
+});
+
+test('the arrival mark survives the shell applying the mode a second time on one page', () => {
+  const store = new Map([['hall-founding-asleep', JSON.stringify({ goals: 'scope', 'goal-map': 'scope', 'board-room': 'charter' })]]);
+  const storage = { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, String(v)) };
+  const h = makeHall();
+  const apply = loadApplyFounding(h.document, { founding: fm.shapeFoundingMode({ active: 'true', stage: 'strategize' }) }, undefined, storage);
+  apply();
+  apply(); // /me settles, then the page reports: applyAccess runs again
+  const arrived = h.nav.filter((a) => a.classList.contains('nav-item--arrived')).map((a) => a.id).sort();
+  assert.deepEqual(arrived, ['nav-board-room', 'nav-goal-map', 'nav-goals']);
+});

package/tests/founding_page_gate.mjs

@@ -0,0 +1,105 @@
+// tests/founding_page_gate.mjs — A SLEEPING ROOM IS NOT REACHABLE BY URL (task 1005112).
+//
+// The sidebar hides a room a founding project has not opened; this is the other half,
+// the page. Everything here RUNS the real middleware (src/bongos/founding-page-gate.js)
+// over fake requests, fed by the real founding-mode shape (modules/onboarding/
+// founding-mode.js) — and, in the last cases, through the real port lookup — so the
+// server's /me answer and the page refusal are one rule.
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+
+const require = createRequire(import.meta.url);
+const { foundingPageGate } = require('../src/bongos/founding-page-gate.js');
+const seams = require('../src/module-seams.js');
+const fm = require('../modules/onboarding/founding-mode.js');
+
+const founding = (stage) => fm.shapeFoundingMode({ active: 'true', stage });
+const ROOMS = [...new Set([...Object.values(fm.WAKES).flat(), ...fm.WAKES_WHEN_ALIVE])];
+
+// Drive the middleware once; resolve with what it did.
+function run(pathname, { read, buildersHost = false, skip = false } = {}) {
+  return new Promise((resolve) => {
+    const res = {
+      headers: {},
+      set(k, v) { this.headers[k] = v; return this; },
+      redirect(code, url) { resolve({ redirect: url, code, headers: this.headers }); },
+    };
+    const opts = { isBuildersHost: () => buildersHost, skip: () => skip };
+    if (read) opts.read = read;
+    foundingPageGate(opts)({ path: pathname }, res, () => resolve({ next: true }));
+  });
+}
+
+test('every room a genesis stage can put to sleep is refused while it sleeps, and nothing else is', async () => {
+  // At 'decide' every room sleeps, so this is the whole list the gate must cover.
+  const read = async () => founding('decide');
+  for (const id of ROOMS) {
+    const out = await run(`/builders/${id}`, { read });
+    assert.ok(out.redirect, `${id} is refused while asleep`);
+  }
+  for (const never of ['primer', 'board-room', 'profile', 'task/12', 'settings', 'blockers', 'studio']) {
+    assert.deepEqual(await run(`/builders/${never}`, { read }), { next: true }, `${never} is never gated`);
+  }
+  // And the gate names no room the server never puts to sleep: a fake answer naming
+  // an unknown room changes nothing.
+  assert.deepEqual(await run('/builders/blockers', { read: async () => ({ active: true, asleep: { blockers: 'scope' } }) }), { next: true });
+});
+
+test('a sleeping room\'s page goes home, naming the room and the stage that opens it', async () => {
+  const out = await run('/builders/goals', { read: async () => founding('scope') });
+  assert.equal(out.code, 302);
+  assert.equal(out.redirect, '/builders/?asleep=goals&opens=scope');
+  assert.equal(out.headers['Cache-Control'], 'no-store', 'a refusal is never cached past the wake');
+  const sub = await run('/builders/work.html', { read: async () => founding('scope'), buildersHost: true });
+  assert.equal(sub.redirect, '/?asleep=work&opens=strategize', 'the builders. host form');
+  const alive = await run('/builders/roster/', { read: async () => founding('legislation') });
+  assert.equal(alive.redirect, '/builders/?asleep=roster&opens=alive');
+  const sneaky = await run('/builders//goal-map', { read: async () => founding('decide') });
+  assert.equal(sneaky.redirect, '/builders/?asleep=goal-map&opens=scope', 'a doubled slash is normalised, not a way past');
+});
+
+test('an awake room opens, and a later stage never takes one away', async () => {
+  assert.deepEqual(await run('/builders/goals', { read: async () => founding('strategize') }), { next: true });
+  assert.deepEqual(await run('/builders/work', { read: async () => founding('charter') }), { next: true });
+});
+
+test('a project that is not founding is untouched, and a failed read opens rather than shuts', async () => {
+  assert.deepEqual(await run('/builders/goals', { read: async () => null }), { next: true });
+  assert.deepEqual(await run('/builders/collab', { read: async () => ({ active: false }) }), { next: true });
+  assert.deepEqual(await run('/builders/goals', { read: async () => { throw new Error('db down'); } }), { next: true },
+    'a read that throws opens the page');
+});
+
+test('only the five room pages ever cost a founding read', async () => {
+  let reads = 0;
+  const read = async () => { reads += 1; return founding('decide'); };
+  for (const p of ['/builders/', '/builders/primer', '/builders/board-room', '/builders/task/5', '/api/bongos/me', '/goals']) {
+    assert.deepEqual(await run(p, { read }), { next: true }, p);
+  }
+  assert.deepEqual(await run('/builders/goals', { read, skip: true }), { next: true }, 'a module surface host is skipped');
+  assert.equal(reads, 0);
+});
+
+test('the default read is the onboarding port\'s foundingModeFor, the answer /me carries', async () => {
+  seams._reset();
+  try {
+    assert.deepEqual(await run('/builders/goals'), { next: true }, 'onboarding module off: not founding, page opens');
+    seams.registerProvider('onboarding', { foundingModeFor: async () => founding('scope') });
+    assert.equal((await run('/builders/goals')).redirect, '/builders/?asleep=goals&opens=scope');
+    seams._reset();
+    seams.registerProvider('onboarding', { foundingModeFor: async () => { throw new Error('settings table gone'); } });
+    assert.deepEqual(await run('/builders/goals'), { next: true }, 'a port that throws opens the page');
+  } finally {
+    seams._reset();
+  }
+});
+
+test('the server mounts it after the sign-in gate, so a stranger still meets sign-in first', () => {
+  const src = fs.readFileSync(new URL('../src/bongos/serve-internal.js', import.meta.url), 'utf8');
+  const signIn = src.indexOf('return gdsAuth.requireBuilderPage(req, res, next);');
+  const mount = src.indexOf('app.use(foundingPageGate(');
+  assert.ok(signIn > 0 && mount > signIn, 'mounted, and after the sign-in gate');
+});

package/tests/front_door_guide_existing.mjs

@@ -222,6 +222,7 @@ test('the guide has no upload, fetch or link-reading path: these are all its rou
   assert.deepEqual([...routes(chatRouter), ...routes(planRouter)].sort(), [
     'GET /front-door-guide/conversations/:id',
     'GET /front-door-guide/mine',
+    'GET /front-door-guide/mine/handoff.md',   // the plan as the hand-off file, a download (task 1005274): reads nothing of theirs
     'GET /front-door-guide/status',
     'POST /front-door-guide/conversations',
     'POST /front-door-guide/conversations/:id/attach',

package/tests/genesis_government.mjs

@@ -131,7 +131,11 @@ test('picking Monarchy files nothing: it is already the government in force', as
   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(out.charter.state, 'in_force');
+    assert.equal(out.charter.form, 'monarchy');
+    // task 1005130: said plainly, and counted as done — never a silent no-op
+    assert.equal(out.charter.complete, true);
+    assert.match(out.charter.message, /already a Monarchy \/ BDFL\. Nothing to change/);
   });
   assert.equal(seen.filed, null);
 });

package/tests/genesis_home.mjs

@@ -573,6 +573,23 @@ test('a demo\'s genesis card: no decide form, the settled plan in one line, each
   assert.doesNotMatch(host.innerHTML, /data-genesis-plan/, 'a demo never shows the decide form');
 });
 
+test('the plan picker says what is in force, marks it, and says what each form asks day to day (task 1005130)', async () => {
+  const charter = require('../modules/government/charter.js');
+  const reco = require('../modules/government/recommendations.js');
+  const MONARCHY = { membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true };
+  const genesis = gh.shapeGenesis({ mode: { stage: 'decide', stage_number: 0, stage_count: 5, day: 1 }, plan: null });
+  // One stub answers every read: the genesis read and the constitution read.
+  const { host } = bootCard({ founding: true, data: {
+    genesis, viewer_id: '1', headcount: 1, charter: charter.charterView(MONARCHY), recommended: reco.recommendedCharter(1),
+  } });
+  for (let i = 0; i < 6; i++) await new Promise((r) => setImmediate(r));
+  assert.match(host.innerHTML, /This project runs as Monarchy \/ BDFL now\. Every project opens as one/, 'what is in force is said first');
+  assert.match(host.innerHTML, /Monarchy \/ BDFL · in force now · recommended/, 'the form in force is marked');
+  assert.match(host.innerHTML, /You decide\. Each decision takes one yes from you\./, 'monarchy says one yes is still needed');
+  assert.match(host.innerHTML, /Every builder on the project decides\./, 'every form says who decides');
+  assert.equal((host.innerHTML.match(/in force now/g) || []).length, 1, 'only the form in force is marked');
+});
+
 test('the card lists every stage vote waiting on the viewer, and votes yes on all in order (task 1005199)', async () => {
   const me = [{ builder_id: '1', display_name: 'Founder' }];
   const genesis = gh.shapeGenesis({
@@ -653,6 +670,8 @@ test('the stage reads as a checklist: done, open and locked, and a locked row of
   assert.match(row('302'), /class="genesis__task is-locked"/);
   assert.match(row('302'), /after Gather what already exists/, 'a locked row says what it waits on');
   assert.doesNotMatch(row('302'), /data-genesis-copy/, 'a locked row offers no prompt for work it cannot claim');
+  assert.doesNotMatch(row('301'), /sr-only/, 'an open row adds no hidden word its status pill could contradict');
+  assert.match(row('302'), /class="sr-only">Locked: /);
   assert.doesNotMatch(html, /is-finished|line-through/, 'nothing is drawn struck through');
   // The "done" row: the earlier stage is not the one on screen, so check the shape directly.
   const done = gh.shapeGenesis({ mode: { stage: 'scope', stage_number: 1, stage_count: 5, day: 1 }, plan: gh.parsePlan({}).plan,
@@ -774,3 +793,25 @@ test('task 1005121: the close route answers 202 with the whole body for an open
   const click = hall.slice(hall.indexOf("t.hasAttribute('data-genesis-close')"), hall.indexOf("t.hasAttribute('data-genesis-confirm')"));
   assert.ok(click.length > 0 && !click.includes('/votes'),'the hall no longer casts a second vote after closing — the server did it');
 });
+
+test('a stage that opens no room says what finishing it earns, never nothing (task 1005112)', async () => {
+  const genesis = gh.shapeGenesis({ mode: { stage: 'scope', stage_number: 1, stage_count: 5, day: 1 }, plan: gh.parsePlan({}).plan });
+  const by = Object.fromEntries(genesis.stages.map((s) => [s.key, s]));
+  assert.equal(by.scope.earns, null, 'a stage that wakes rooms names the rooms instead');
+  assert.equal(by.strategize.earns, null);
+  for (const k of ['charter', 'legalize', 'legislation']) {
+    assert.deepEqual(by[k].wakes, [], `${k} wakes no room`);
+    assert.ok(by[k].earns && by[k].earns.length > 10, `${k} says what it earns`);
+  }
+  assert.match(by.legislation.earns, /every room opens/, 'the last stage is the one that opens everything');
+  const b = bootCard({ founding: true, data: { genesis, viewer_id: '1' } });
+  await mountClickable(b);
+  assert.match(b.host.innerHTML, /Wakes Goals, Goal map/);
+  assert.match(b.host.innerHTML, /puts your government in force/);
+  assert.match(b.host.innerHTML, /settles how contributors are rewarded/);
+  // The district rises with the stages (task 1005112): each row also names what it raises.
+  assert.match(b.host.innerHTML, /Wakes Goals, Goal map · raises Planning/);
+  assert.match(b.host.innerHTML, /Raises Treasury · settles how contributors are rewarded/);
+  assert.match(b.host.innerHTML, /Raises Rules, Review, Disputes · brings the project to life/);
+  assert.deepEqual(by.legalize.raises, ['treasury']);
+});

package/tests/government_charter_advice.mjs

@@ -148,3 +148,52 @@ test('the port entry reads the head count and the law book', async () => {
   assert.equal(expected.headcount, 2, 'the founder\'s expected number wins over the live count');
   assert.equal(expected.charter.key, 'monarchy');
 });
+
+// ── task 1005130: every project is already a monarchy, and is told so ────────
+const MONARCHY = { membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true };
+const config = require(path.join(ROOT, 'modules', 'government', 'config.js'));
+
+test('the default constitution reads as Monarchy, and the stage says so on arrival', () => {
+  const live = config.loadGovernmentConfig().board;
+  const v = charter.charterView(live);
+  assert.equal(v.in_force.form, 'monarchy', 'every project boots as a monarchy');
+  assert.match(v.in_force.line, /runs as Monarchy \/ BDFL now\. Every project opens as one/);
+  assert.match(v.in_force.line, /You decide\. Each decision takes one yes from you\./);
+  assert.deepEqual(v.forms.filter((f) => f.current).map((f) => f.key), ['monarchy'], 'exactly the form in force is marked');
+});
+
+test('every form says who decides and what closing takes, derived from its own settings', () => {
+  const v = charter.charterView(MONARCHY);
+  for (const f of v.forms.filter((x) => x.available)) {
+    const d = charter.dutyOf(f.franchise, f.pass_rule);
+    assert.equal(f.who_decides, d.who_decides, f.key);
+    assert.equal(f.to_close, d.to_close, f.key);
+    assert.ok(f.who_decides && f.to_close, `${f.key} says both`);
+  }
+  assert.equal(charter.dutyOf('founder', 'first_ratifier').to_close, 'Each decision takes one yes from you.');
+  assert.match(charter.dutyOf('everyone', 'majority').to_close, /more than half/);
+  assert.notEqual(charter.dutyOf('trusted', 'consent').to_close, charter.dutyOf('trusted', 'majority').to_close,
+    'the sentence follows the pass rule, so a tuned rule is described as it runs');
+});
+
+test('choosing what is in force changes nothing and is done; choosing another says what happens next', () => {
+  const same = charter.choiceOutcome(MONARCHY, 'monarchy');
+  assert.equal(same.changes, false);
+  assert.equal(same.complete, true);
+  assert.match(same.line, /already a Monarchy \/ BDFL\. Nothing to change/);
+  const other = charter.choiceOutcome(MONARCHY, 'direct-democracy');
+  assert.equal(other.changes, true);
+  assert.match(other.line, /filed as a change to the rules and decided under the government in force \(Monarchy \/ BDFL\)\. Under it, your own one yes applies it\./);
+  const underCircle = charter.choiceOutcome({ ...MONARCHY, membership: 'rank:xenos+', pass_rule: 'consent' }, 'monarchy');
+  assert.match(underCircle.line, /passes unless one of them objects/, 'under another government the rule in force is named');
+});
+
+test('the charter stage advice carries what is in force and what choosing the recommendation does', () => {
+  const a = advice.buildAdvice({ answers: {}, headcount: 1, board: MONARCHY });
+  assert.equal(a.in_force.form, 'monarchy');
+  assert.equal(a.charter.key, 'monarchy');
+  assert.equal(a.charter.on_choose.changes, false, 'a solo founder is told the recommendation is what they already have');
+  const b = advice.buildAdvice({ answers: { final_say: 'everyone' }, headcount: 1, board: MONARCHY });
+  assert.equal(b.charter.on_choose.changes, true);
+  assert.ok(b.forms.find((f) => f.key === 'monarchy').current);
+});

package/tests/government_charter_forms.mjs

@@ -254,8 +254,12 @@ test('a charter that changes nothing files nothing, and a council must be a rank
     getRankByKey: async (key) => (key === 'trustees' ? { rank_key: 'trustees' } : null),
     builderHoldsRankActive: async () => true,
   }, async () => {
-    assert.equal((await board.proposeCharter({ form: 'monarchy', proposedBy: '42' })).reason, 'no_change',
-      'a sitting on the constitution already in force would decide nothing');
+    const same = await board.proposeCharter({ form: 'monarchy', proposedBy: '42' });
+    assert.equal(same.reason, 'no_change', 'a sitting on the constitution already in force would decide nothing');
+    // task 1005130: the refusal says what is true in words and counts the choice done
+    assert.equal(same.in_force, 'Monarchy / BDFL');
+    assert.equal(same.complete, true);
+    assert.match(same.message, /You are already a Monarchy \/ BDFL\. Nothing to change/);
     assert.equal((await board.proposeCharter({ form: 'foundation', councilRank: 'ghosts', proposedBy: '42' })).reason, 'unknown_council_rank');
     assert.equal((await board.proposeCharter({ form: 'direct-democracy', proposedBy: null })).reason, 'missing_proposer');
   });
@@ -272,7 +276,14 @@ test('the constitution view carries the charter: forms, variables, and what the
   });
   const routes = fs.readFileSync(path.join(GOV, 'routes', 'government.js'), 'utf8');
   assert.match(routes, /router\.post\('\/government\/board\/charter', api\.requireBuilder, api\.requirePermission\('board\.item\.open'\)/);
-  assert.match(routes, /proposeCharter: board\.proposeCharter/);
+  // The port's charter filing IS board.proposeCharter, followed by the board-of-one
+  // confirm (task 1005130) — called, not read: a refusal from board comes back as is.
+  const { governmentPort } = require(path.join(GOV, 'routes', 'government.js'));
+  const real = board.proposeCharter;
+  board.proposeCharter = async (a) => ({ ok: false, reason: 'from_board', seen: a.form });
+  try {
+    assert.deepEqual(await governmentPort.proposeCharter({ form: 'monarchy', proposedBy: '42' }), { ok: false, reason: 'from_board', seen: 'monarchy' });
+  } finally { board.proposeCharter = real; }
   const pins = fs.readFileSync(path.join(ROOT, 'src', 'bongos', 'route-rank-check.js'), 'utf8');
   assert.match(pins, /'POST \/government\/board\/charter': 'perm:board\.item\.open'/);
 });

package/tests/government_seed.mjs

@@ -55,6 +55,7 @@ const NON_GRANT_MIGRATIONS = new Set([
   'government_036_access_holders.sql',             // who holds the keys outside Bongos + the access:<key> ask seat (task 1005000)
   'government_037_constitution.sql',               // the constitution in force as a durable row (task 1005140)
   'government_038_vote_cast_via.sql',               // HOW a vote was cast: a ballot, or a stage-close confirm (task 1005121)
+  'government_039_vote_cast_via_filed.sql',         // a board of one's confirm given by filing (task 1005130)
 ]);
 
 // Permission keys RENAMED after the grant migrations that first granted them.

package/tests/government_sole_member.mjs

@@ -0,0 +1,153 @@
+// tests/government_sole_member.mjs — a board of ONE decides by filing (task 1005130,
+// part C; the ruling task 1005121 shipped for closing a genesis stage, applied
+// wherever it holds).
+//
+// The rule held here, for a charter change, a laws change and a decision-rules change:
+//   • the sole member of a first_ratifier board files → their yes is cast in the same
+//     call, recorded as THEIR vote (attributed, cast_via 'filed'), and the sitting
+//     closes through the ordinary close path;
+//   • a second member on the board, a consent or majority rule, or a caller who is not
+//     the sole member → the filing comes back exactly as it was, and nothing is cast;
+//   • the yes goes through the real castVote — its membership re-check, and a
+//     'filed' cast is refused on anything but an amendment, or as a 'no';
+//   • a filing the filer was refused comes back untouched, and a failing confirm
+//     leaves the sitting open rather than failing the filing.
+// The real routes (permission gate first, a non-member's filing left open, a lower
+// rank refused before anything is filed) are walked end to end in
+// scripts/bongos/government-walk.js (rows G3, G5, B*, L2–L4, L11–L15).
+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 db = require(path.join(GOV, 'db.js'));
+const board = require(path.join(GOV, 'board.js'));
+const sole = require(path.join(GOV, 'sole-member.js'));
+
+const MONARCHY = { membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true };
+const FILERS = ['proposeCharter', 'proposeLaws', 'proposeDecisionRules'];
+
+// A world: who holds which rank, the one open item a filing opened, and every vote
+// written. db is stubbed underneath the REAL castVote; the filers and the close are
+// stubbed on board (looked up at call time), so this exercises the decision alone.
+async function world({ members = ['42'], constitution = MONARCHY, subjectType = 'constitutional_amendment', filedOk = true } = {}, fn) {
+  const votes = [];
+  const closes = [];
+  const item = { id: 7, subject_type: subjectType, constitution, closed_at: null, expired: false };
+  const stubs = {
+    getActiveBuildersWithRank: async () => members.map((id) => ({ builder_id: id, github_login: `b${id}`, display_name: `B${id}` })),
+    builderHoldsRankActive: async (id) => members.includes(String(id)),
+    getBoardItemForVote: async () => ({ ...item }),
+    getBoardItemAuthor: async () => '42',
+    insertBoardVote: async (v) => { const row = { item_id: String(v.itemId), voter_id: String(v.voterId), direction: v.direction, cast_via: v.castVia || 'ballot', cast_at: '2026-11-13T12:00:00.000Z' }; votes.push(row); return row; },
+    getBoardVote: async () => null,
+    insertVoteKarma: async () => { throw new Error('a confirm given by filing earns no vote karma'); },
+  };
+  const boardStubs = {
+    maybeCloseAfterVote: async (id) => { closes.push(id); return { closed: true, outcome: 'passed', item: { id } }; },
+  };
+  for (const f of FILERS) boardStubs[f] = async () => (filedOk ? { ok: true, amendment: { id: 3 }, item: { ...item } } : { ok: false, reason: 'proposer_would_lose_their_seat' });
+  const saved = {};
+  for (const [k, v] of Object.entries(stubs)) { saved[`db.${k}`] = db[k]; db[k] = v; }
+  for (const [k, v] of Object.entries(boardStubs)) { saved[`board.${k}`] = board[k]; board[k] = v; }
+  try {
+    return await fn({ votes, closes });
+  } finally {
+    for (const [k, v] of Object.entries(saved)) {
+      const [obj, key] = k.split('.');
+      (obj === 'db' ? db : board)[key] = v;
+    }
+  }
+}
+
+for (const filer of FILERS) {
+  test(`${filer}: the sole member of a one-yes board decides by filing, and the vote is theirs on the record`, async () => {
+    await world({}, async ({ votes, closes }) => {
+      const out = await sole[filer]({ proposedBy: '42' });
+      assert.equal(out.ok, true);
+      assert.deepEqual(out.decided, { closed: true, outcome: 'passed', cast_via: 'filed' });
+      assert.equal(votes.length, 1);
+      assert.equal(votes[0].voter_id, '42', 'attributed to the member who filed');
+      assert.equal(votes[0].direction, 'yes');
+      assert.equal(votes[0].cast_via, 'filed', 'the record says how it was cast');
+      assert.ok(votes[0].cast_at, 'and when');
+      assert.deepEqual(closes, [7], 'closed through the ordinary close path');
+    });
+  });
+
+  test(`${filer}: a second member on the board — nothing is cast, the sitting waits`, async () => {
+    await world({ members: ['42', '43'] }, async ({ votes, closes }) => {
+      const out = await sole[filer]({ proposedBy: '42' });
+      assert.equal(out.decided, undefined);
+      assert.deepEqual(votes, []);
+      assert.deepEqual(closes, []);
+    });
+  });
+
+  for (const rule of ['consent', 'majority', 'unanimous']) {
+    test(`${filer}: under ${rule} a sole member's filing still waits for their vote`, async () => {
+      await world({ constitution: { ...MONARCHY, pass_rule: rule } }, async ({ votes, closes }) => {
+        const out = await sole[filer]({ proposedBy: '42' });
+        assert.equal(out.decided, undefined);
+        assert.deepEqual(votes, []);
+        assert.deepEqual(closes, []);
+      });
+    });
+  }
+
+  test(`${filer}: a caller who is not the sole member — the sitting is left open, exactly as today`, async () => {
+    await world({ members: ['42'] }, async ({ votes, closes }) => {
+      const out = await sole[filer]({ proposedBy: '43' });
+      assert.equal(out.ok, true);
+      assert.equal(out.decided, undefined);
+      assert.deepEqual(votes, []);
+      assert.deepEqual(closes, []);
+    });
+  });
+
+  test(`${filer}: a refused filing comes back untouched, and nothing is cast`, async () => {
+    await world({ filedOk: false }, async ({ votes }) => {
+      assert.deepEqual(await sole[filer]({ proposedBy: '42' }), { ok: false, reason: 'proposer_would_lose_their_seat' });
+      assert.deepEqual(votes, []);
+    });
+  });
+}
+
+test('the yes goes through the real castVote: membership is re-checked under the item\'s snapshot', async () => {
+  // resolve says 42 is the one member, but the per-request re-check says 42 no longer
+  // holds the rank (demoted between the two reads): the cast is refused, nothing closes.
+  await world({}, async ({ votes, closes }) => {
+    db.builderHoldsRankActive = async () => false;
+    const out = await sole.proposeLaws({ proposedBy: '42' });
+    assert.equal(out.decided, undefined);
+    assert.deepEqual(votes, []);
+    assert.deepEqual(closes, []);
+  });
+});
+
+test('a cast marked "filed" is refused on anything but an amendment, and as a no', async () => {
+  await world({ subjectType: 'full_idea' }, async ({ votes }) => {
+    assert.equal((await board.castVote({ itemId: 7, voterId: '42', direction: 'yes', castVia: 'filed' })).reason, 'bad_cast_via');
+    assert.deepEqual(votes, []);
+  });
+  await world({ subjectType: 'genesis_stage' }, async () => {
+    assert.equal((await board.castVote({ itemId: 7, voterId: '42', direction: 'yes', castVia: 'filed' })).reason, 'bad_cast_via');
+  });
+  await world({}, async () => {
+    assert.equal((await board.castVote({ itemId: 7, voterId: '42', direction: 'no', reasonMd: 'no', sectionKey: 'purpose', castVia: 'filed' })).reason, 'bad_cast_via');
+    assert.equal((await board.castVote({ itemId: 7, voterId: '42', direction: 'yes', castVia: 'by_magic' })).reason, 'bad_cast_via');
+  });
+});
+
+test('a confirm that fails leaves the filing standing and the sitting open', async () => {
+  await world({}, async () => {
+    board.maybeCloseAfterVote = async () => { throw new Error('db down'); };
+    const out = await sole.proposeCharter({ proposedBy: '42' });
+    assert.equal(out.ok, true);
+    assert.equal(out.decided, undefined);
+  });
+});