@bongos/core 1.24.73 → 1.24.75

package/modules/onboarding/genesis-home.js

@@ -326,10 +326,25 @@ async function applyGovernmentChoice(form, builderId, s) {
   return { state: 'not_filed', form, reason };
 }
 
-// closeStage — put the current stage to the Board Room. The finished-tasks gate is the
-// government module's (it checks the ids against the board); this only names the
-// stage's tasks. With no government module there is no Board Room to put it to, and
-// the founder's confirm closes the stage itself once its tasks are finished.
+// closeStage — CLOSE the current stage, in one call (task 1005121; owner ruling
+// 2026-11-07: "closing a stage shouldn't be such a big thing"). The answer says, by
+// itself, which of two things happened — a caller never needs a second request:
+//
+//   { ok: true,  closed: true,  stage, next_stage, item_id, confirm }
+//       The stage is closed and the project has moved on (`next_stage` null at
+//       legislation: the alive door, POST /founding/alive, is open instead).
+//       `confirm` is 'stage_close' when the founder's own yes carried it — the
+//       government port records that HOW on the vote (cast_via).
+//   { ok: false, closed: false, reason: 'sitting_open', stage, item_id, already_open,
+//     waiting: { pass_rule, needs, voted, waiting_on, closes_at, remaining_seconds },
+//     next }
+//       A real Board Room sitting is deciding it (more than one person, or a rule
+//       one yes cannot carry). Never ok: true — the stage did NOT close. The route
+//       answers 202 with this whole body; `next` says what to do, in words.
+//
+// With a government module the port's closeGenesisStage does the deciding (its
+// finished-tasks gate, the founder's confirm where one person decides). With none,
+// the founder's ask closes a finished stage itself. Same rule at every stage.
 async function closeStage(stageKey, builderId, deps = {}) {
   const s = seams(deps);
   const mode = await reconcile(s);
@@ -337,17 +352,59 @@ async function closeStage(stageKey, builderId, deps = {}) {
   if (mode.stage !== stageKey) return { ok: false, reason: 'not_current_stage', stage: mode.stage };
   const all = s.lifecycle && typeof s.lifecycle.genesisTasks === 'function' ? await s.lifecycle.genesisTasks() : {};
   const list = all[stageKey] || [];
+  const taskIds = list.map((t) => t.id);
   const gov = s.government;
+  const nextOf = (key) => (key === 'legislation' ? null : fm.STAGES[fm.STAGES.indexOf(key) + 1]);
+  const closedAnswer = async (itemId, confirm) => {
+    const after = await reconcile(s);
+    return {
+      ok: true, closed: true, stage: stageKey,
+      next_stage: stageKey === 'legislation' ? null : (after && after.stage) || nextOf(stageKey),
+      item_id: itemId, confirm,
+    };
+  };
+  if (gov && typeof gov.closeGenesisStage === 'function') {
+    const r = await gov.closeGenesisStage({ stageKey, taskIds, closedBy: builderId });
+    if (r.reason) return { ok: false, reason: r.reason, unfinished: r.unfinished || [] };
+    const itemId = r.item ? String(r.item.id) : null;
+    if (r.closed) return closedAnswer(itemId, r.cast ? r.cast.cast_via : null);
+    return sittingOpen(stageKey, itemId, !r.opened, r.status, builderId);
+  }
   if (gov && typeof gov.openGenesisStageClose === 'function') {
-    const r = await gov.openGenesisStageClose({ stageKey, taskIds: list.map((t) => t.id), openedBy: builderId });
+    // An older government module without the one-call close: the sitting opens and
+    // the answer says so, rather than claiming a close that did not happen.
+    const r = await gov.openGenesisStageClose({ stageKey, taskIds, openedBy: builderId });
     if (!r.opened && r.reason !== 'already_open') return { ok: false, reason: r.reason, unfinished: r.unfinished || [] };
-    return { ok: true, item_id: r.item ? String(r.item.id) : null, already_open: !r.opened };
+    const board = await boardByStage(gov);
+    return sittingOpen(stageKey, r.item ? String(r.item.id) : null, !r.opened, board[stageKey] || null, builderId);
   }
   if (!list.length || !list.every((t) => FINISHED.includes(t.status))) return { ok: false, reason: 'stage_tasks_unfinished' };
   if (stageKey !== 'legislation') {
-    await fm.setFoundingMode({ stage: fm.STAGES[fm.STAGES.indexOf(stageKey) + 1] }, builderId, modeDeps(s));
+    await fm.setFoundingMode({ stage: nextOf(stageKey) }, builderId, modeDeps(s));
   }
-  return { ok: true, item_id: null, closed: true };
+  return { ok: true, closed: true, stage: stageKey, next_stage: nextOf(stageKey), item_id: null, confirm: null };
+}
+
+// The "a sitting is deciding it" answer: what happened, what it waits on, what next.
+function sittingOpen(stageKey, itemId, alreadyOpen, status, builderId) {
+  const st = status || {};
+  const waitingOn = Array.isArray(st.waiting_on) ? st.waiting_on : [];
+  const names = waitingOn.map((m) => m.display_name || m.github_login || `builder ${m.builder_id}`);
+  const callerWaited = waitingOn.some((m) => String(m.builder_id) === String(builderId));
+  let next = `The Board Room is deciding this stage (sitting ${itemId || 'open'}).`;
+  if (st.needs) next += ` Its rule: ${st.needs}`;
+  if (names.length) next += ` Still to vote: ${names.join(', ')}.`;
+  if (callerWaited && itemId) next += ` Your vote is one of them: POST /api/bongos/government/board/items/${itemId}/votes { "direction": "yes" }.`;
+  next += ' The stage moves on by itself when the sitting passes; there is nothing else to call.';
+  return {
+    ok: false, closed: false, reason: 'sitting_open', stage: stageKey, item_id: itemId, already_open: !!alreadyOpen,
+    waiting: {
+      pass_rule: st.pass_rule || null, needs: st.needs || null,
+      voted: Array.isArray(st.voted) ? st.voted : [], waiting_on: waitingOn,
+      closes_at: st.closes_at || null, remaining_seconds: st.remaining_seconds ?? null,
+    },
+    next,
+  };
 }
 
 // comeAlive — the last door. Only once legislation has passed (or, with no Board Room,

package/modules/onboarding/routes/onboarding.js

@@ -170,6 +170,20 @@ function mountGenesisRoutes(router) {
     })) return;
     next();
   }, handle((req) => genesis.savePlan(req.body || {}, req.builder.id)));
-  router.post('/founding/stages/:stage/close', api.requireBuilder, owns, handle((req) => genesis.closeStage(String(req.params.stage), req.builder.id)));
+  // task 1005121: one call. 200 { closed: true, next_stage } when the stage closed;
+  // 202 { ok: false, closed: false, reason: 'sitting_open', waiting, next } when a
+  // real sitting is deciding it — never a success for a stage that did not close.
+  router.post('/founding/stages/:stage/close', api.requireBuilder, owns, async (req, res) => {
+    try {
+      const r = await genesis.closeStage(String(req.params.stage), req.builder.id);
+      res.set('Cache-Control', 'no-store');
+      if (r && r.reason === 'sitting_open') return res.status(202).json(r);
+      if (r && r.ok === false) return refuse(res, r);
+      res.json(r);
+    } catch (err) {
+      api.logger('onboarding').error('[onboarding] genesis', err);
+      res.status(500).json({ error: { code: 'genesis_failed', message: 'internal error' } });
+    }
+  });
   router.post('/founding/alive', api.requireBuilder, owns, handle((req) => genesis.comeAlive(req.builder.id)));
 }

package/package-lock.json

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

package/package.json

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

@@ -11463,5 +11463,17 @@
       "id": "1005140",
       "text": "When a project's board votes in a new form of government, that choice now stays in force after the server restarts. Before, it was quietly lost on every restart and the project fell back to the original one-person rule. A proj"
     }
+  ],
+  "1.24.74": [
+    {
+      "id": "1005142",
+      "text": "The hall has a game mode: once it is on, every page opens full screen with no sidebar, and Escape brings the menus back when you need them."
+    }
+  ],
+  "1.24.75": [
+    {
+      "id": "1005121",
+      "text": "Closing a project-setup stage is now one step: if the founder alone decides, the stage closes and the project moves on at once; if others must vote, the answer says who and what to do next instead of falsely reporting success."
+    }
   ]
 }

package/scripts/bongos/government-walk.js

@@ -801,12 +801,12 @@ async function runWalk() {
   for (const stage of genesis.PROPER) {
     store.tasks.get(STAGE_TASK_IDS[stage]).status = 'shipped';
     let itemId = null;
-    await check(`${stage}: its finished stage is put to the board`, 'a sitting under the chosen government', async () => {
+    await check(`${stage}: its finished stage is put to the board`, '202 not closed, a sitting under the chosen government', async () => {
       const r = await call(FOUNDER, 'POST', `/founding/stages/${stage}/close`);
       itemId = r.json && r.json.item_id;
       const snap = itemId && itemOf(itemId) ? itemOf(itemId).constitution : {};
-      const reads = charter.readCharter(snap).form;
-      return { got: `${r.status}, sitting under ${reads}`, pass: r.status === 200 && !!itemId && reads === CHOSEN };
+      const reads = charter.readCharter(snap).form, notClosed = !!r.json && r.json.closed === false && r.json.reason === 'sitting_open'; // task 1005121: never a 200 for an open stage
+      return { got: `${r.status} ${notClosed ? 'not closed' : 'closed?'}, a sitting under ${reads}`, pass: r.status === 202 && notClosed && !!itemId && reads === CHOSEN };
     });
     await check(`${stage}: the founder alone cannot close it; every trusted member's yes does`, 'open, open, passed', async () => {
       const after = await voteAll(itemId, timocrats);

package/src/module-api.js

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

package/tests/genesis_home.mjs

@@ -205,8 +205,13 @@ test('decide → five stages through the Board Room → alive, and the hall open
     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);
+    // task 1005121: a module without the one-call close only OPENS a sitting, and
+    // the answer must say so — never ok: true for a stage that did not close.
+    assert.equal(closed.ok, false);
+    assert.equal(closed.closed, false);
+    assert.equal(closed.reason, 'sitting_open');
     assert.equal(closed.item_id, '9');
+    assert.match(closed.next, /moves on by itself/);
     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');
@@ -355,3 +360,83 @@ test('the hall carries the five life plates byte-identical to the world\'s', ()
     }
   }
 });
+
+// ── task 1005121: closing a stage is ONE call ────────────────────────────────
+
+function oneCallWorld({ solo = true } = {}) {
+  const w = world();
+  const calls = [];
+  w.deps = ((base) => () => {
+    const d = base();
+    d.government = {
+      ...d.government,
+      closeGenesisStage: async ({ stageKey, taskIds, closedBy }) => {
+        calls.push({ stageKey, taskIds, closedBy });
+        if (!(w.tasks[stageKey] || []).every((t) => ['shipped', 'abandoned'].includes(t.status))) {
+          return { closed: false, reason: 'stage_tasks_unfinished', unfinished: [{ task_id: taskIds[0] }] };
+        }
+        if (solo) {
+          w.board[stageKey] = { state: 'passed', item_id: '9', waiting_on: [] };
+          return { closed: true, item: { id: 9 }, stage: { key: stageKey }, cast: { cast_via: 'stage_close', fresh: true } };
+        }
+        const status = {
+          key: stageKey, state: 'sitting', item_id: '9', pass_rule: 'consent', needs: 'Passes unless someone objects.',
+          voted: [], waiting_on: [{ builder_id: '1', display_name: 'Founder' }, { builder_id: '2', github_login: 'avery' }],
+          closes_at: 'T', remaining_seconds: 600,
+        };
+        w.board[stageKey] = status;
+        return { closed: false, item: { id: 9 }, stage: { key: stageKey }, opened: true, status, cast: null };
+      },
+    };
+    return d;
+  })(w.deps);
+  return { w, calls };
+}
+
+test('task 1005121: one call closes the stage and moves the project on, at every stage, the same way', async () => {
+  const { w, calls } = oneCallWorld();
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({}, 1, w.deps());
+  for (const s of STAGES5) {
+    assert.equal((await gh.closeStage(s, 1, w.deps())).reason, 'stage_tasks_unfinished');
+    w.finish(s);
+    const r = await gh.closeStage(s, 1, w.deps());
+    assert.equal(r.ok, true, `${s}: one call`);
+    assert.equal(r.closed, true);
+    assert.equal(r.stage, s);
+    assert.equal(r.confirm, 'stage_close', "the founder's confirm carried it, and the answer says how");
+    const next = s === 'legislation' ? null : STAGES5[STAGES5.indexOf(s) + 1];
+    assert.equal(r.next_stage, next, 'the answer names the next stage');
+    const g = await gh.readGenesis(w.deps());
+    assert.equal(g.stage, next || 'legislation', 'no second request: the project has already moved on');
+  }
+  assert.ok(calls.every((c) => String(c.closedBy) === '1'), 'the caller is who confirms');
+  assert.equal((await gh.readGenesis(w.deps())).can_come_alive, true, 'legislation closed: the alive door is open');
+});
+
+test('task 1005121: where a real sitting decides, the answer is not ok and says what it waits on and what to do', async () => {
+  const { w } = oneCallWorld({ solo: false });
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({}, 1, w.deps());
+  w.finish('scope');
+  const r = await gh.closeStage('scope', 1, w.deps());
+  assert.equal(r.ok, false, 'never ok: true for a stage that did not close');
+  assert.equal(r.closed, false);
+  assert.equal(r.reason, 'sitting_open');
+  assert.equal(r.item_id, '9');
+  assert.equal(r.waiting.pass_rule, 'consent');
+  assert.deepEqual(r.waiting.waiting_on.map((m) => m.builder_id), ['1', '2']);
+  assert.match(r.next, /Founder, avery/);
+  assert.ok(r.next.includes('Your vote is one of them: POST /api/bongos/government/board/items/9/votes'), r.next);
+  assert.equal((await gh.readGenesis(w.deps())).stage, 'scope', 'the stage holds until the sitting passes');
+});
+
+test('task 1005121: the close route answers 202 with the whole body for an open sitting, never a 200', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules', 'onboarding', 'routes', 'onboarding.js'), 'utf8');
+  const at = src.indexOf("router.post('/founding/stages/:stage/close'");
+  const route = src.slice(at, at + 700);
+  assert.ok(route.includes("r.reason === 'sitting_open') return res.status(202).json(r)"), 'an open sitting is a 202 with the whole body');
+  const hall = fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'genesis-home.js'), 'utf8');
+  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');
+});

package/tests/goal_map_page.mjs

@@ -434,9 +434,9 @@ await test('the page is the sky\'s own surface — the same sheet and the same s
   assert.match(html, /<main id="hall-main" class="sky-stage">/, 'the sky is drawn in the stage, the skip link\'s target');
   const scripts = (h) => [...h.matchAll(/<script src="\/builders\/([^"?]+)\?v=([^"]+)"/g)].map((m) => [m[1], m[2]]);
   // criterion-uat-ui.js (task 1004402): the rings' UAT state words, shared with the goal page.
-  assert.deepEqual(scripts(html).filter((s) => !['dom-utils.js', 'shell-trail.js', 'craft-mode.js', 'shell.js'].includes(s[0])).map((s) => s[0]), ['idea-objects.js', 'criterion-uat-ui.js', 'sky-data.js', 'sky-layout.js', 'sky-draw.js', 'sky-interaction.js', 'sky-panel.js', 'sky-composer.js', 'sky-tour.js']);
+  assert.deepEqual(scripts(html).filter((s) => !['dom-utils.js', 'shell-game.js', 'shell-trail.js', 'craft-mode.js', 'shell.js'].includes(s[0])).map((s) => s[0]), ['idea-objects.js', 'criterion-uat-ui.js', 'sky-data.js', 'sky-layout.js', 'sky-draw.js', 'sky-interaction.js', 'sky-panel.js', 'sky-composer.js', 'sky-tour.js']);
   // Both doors load the shell (tasks 1004327, 1004430); the SKY's files are the same.
-  const skyScripts = (h) => scripts(h).filter((s) => !['dom-utils.js', 'shell-trail.js', 'craft-mode.js', 'shell.js'].includes(s[0]));
+  const skyScripts = (h) => scripts(h).filter((s) => !['dom-utils.js', 'shell-game.js', 'shell-trail.js', 'craft-mode.js', 'shell.js'].includes(s[0]));
   assert.deepEqual(skyScripts(html), skyScripts(thinking), 'the two doors load the same sky files at the same stamp');
   assert.equal(html.match(/thinking\.css\?v=([^"]+)/)[1], thinking.match(/thinking\.css\?v=([^"]+)/)[1]);
   assert.match(read('thinking.css'), /body\[data-page\] \.sky-stage \{/, 'the sheet dresses the one stage both doors draw in inside the hall');

package/tests/government_board_genesis_stage.mjs

@@ -303,3 +303,86 @@ test('the port carries the open and the status; the status route is pinned on th
   const pins = fs.readFileSync(path.join(ROOT, 'src', 'bongos', 'route-rank-check.js'), 'utf8');
   assert.match(pins, /'GET \/government\/board\/genesis-stages': 'perm:board\.vote\.cast'/);
 });
+
+// ── task 1005121: closing a stage is ONE call ────────────────────────────────
+
+const { closeGenesisStage } = require(path.join(GOV, 'genesis-close.js'));
+
+test('task 1005121: under Monarchy / BDFL closeGenesisStage opens, confirms and CLOSES in one call, and records HOW', async () => {
+  const votes = [];
+  let karma = 0;
+  const passed = await capturing('board.genesis_stage.passed', () => withDb({
+    getTaskStatuses: async () => [{ id: '101', status: 'shipped' }],
+    openBoardItem: async (args) => ({ ...stageItem(), constitution: MONARCHY, opened_by: args.openedBy }),
+    getBoardItemForVote: async () => stageItem(),
+    builderHoldsRankActive: async (id) => id === FOUNDER,
+    getActiveBuildersWithRank: async () => [member(FOUNDER, 'founder')],
+    getBoardItemAuthor: async (item) => item.opened_by,
+    insertBoardVote: async (row) => { const v = { ...row, voter_id: row.voterId, cast_via: row.castVia }; votes.push(v); return v; },
+    insertVoteKarma: async () => { karma += 1; },
+    getVotesForItem: async () => votes,
+    closeBoardItem: async ({ outcome }) => ({ ...stageItem(), closed_at: 'T', outcome }),
+    insertAuthorRatifyKarma: async () => true,
+  }, async () => {
+    const out = await closeGenesisStage({ stageKey: 'charter', taskIds: [101], closedBy: FOUNDER });
+    assert.equal(out.closed, true, 'the answer says CLOSED — no second request needed');
+    assert.equal(out.stage.key, 'charter');
+    assert.equal(out.cast.cast_via, 'stage_close');
+  }));
+  assert.equal(votes.length, 1);
+  assert.equal(votes[0].castVia, 'stage_close', 'the vote row records it was a confirm given by closing the stage');
+  assert.equal(votes[0].direction, 'yes');
+  assert.equal(karma, 0, 'the confirm decided nothing the ask had not — no vote karma');
+  assert.equal(passed.length, 1, 'the genesis home hears the pass');
+});
+
+test('task 1005121: where one yes cannot carry it, nothing is cast and the answer says what the sitting waits on', async () => {
+  let inserted = 0;
+  await withDb({
+    getTaskStatuses: async () => [{ id: '101', status: 'shipped' }],
+    openBoardItem: async () => ({ ...stageItem({ constitution: CONSENT }) }),
+    insertBoardVote: async () => { inserted += 1; return null; },
+    listLatestGenesisStageItems: async () => [stageItem({ constitution: CONSENT })],
+    getVotesForItems: async () => [],
+    getActiveBuildersWithRank: async () => [member(FOUNDER, 'founder'), member(AVERY, 'avery')],
+  }, async () => {
+    const out = await closeGenesisStage({ stageKey: 'charter', taskIds: [101], closedBy: FOUNDER });
+    assert.equal(out.closed, false);
+    assert.equal(out.opened, true);
+    assert.equal(out.item.id, '90');
+    assert.equal(out.status.state, 'sitting');
+    assert.deepEqual(out.status.waiting_on.map((m) => m.builder_id), [FOUNDER, AVERY]);
+    assert.ok(out.status.needs, 'the rule, in words');
+  });
+  assert.equal(inserted, 0, 'no vote is cast on anyone\'s behalf under a rule one person cannot carry');
+});
+
+test('task 1005121: a refusal from the gate passes straight through, nothing opened', async () => {
+  await withDb({
+    getTaskStatuses: async () => [{ id: '101', status: 'active' }],
+    openBoardItem: async () => { throw new Error('must not be reached'); },
+  }, async () => {
+    const out = await closeGenesisStage({ stageKey: 'charter', taskIds: [101], closedBy: FOUNDER });
+    assert.equal(out.closed, false);
+    assert.equal(out.reason, 'stage_tasks_unfinished');
+  });
+});
+
+test('task 1005121: cast_via stage_close is internal, genesis-only and yes-only; the vote route never passes it', async () => {
+  assert.equal((await castVote({ itemId: '90', voterId: FOUNDER, direction: 'yes', castVia: 'proxy' })).reason, 'bad_cast_via');
+  await withDb({
+    getBoardItemForVote: async () => ({ ...stageItem(), subject_type: 'full_idea' }),
+    insertBoardVote: async () => { throw new Error('must not be reached'); },
+  }, async () => {
+    assert.equal((await castVote({ itemId: '90', voterId: FOUNDER, direction: 'yes', castVia: 'stage_close' })).reason, 'bad_cast_via');
+  });
+  const routes = fs.readFileSync(path.join(GOV, 'routes', 'government.js'), 'utf8');
+  const call = routes.slice(routes.indexOf('const out = await board.castVote({'), routes.indexOf('const out = await board.castVote({') + 300);
+  assert.doesNotMatch(call, /castVia|cast_via/, 'a request can never claim its vote was a stage-close confirm');
+  assert.ok(routes.includes("closeGenesisStage: require('../genesis-close').closeGenesisStage"), 'the one-call close is on the port');
+  const sql = fs.readFileSync(path.join(GOV, 'migrations', 'government_038_vote_cast_via.sql'), 'utf8');
+  assert.match(sql, /cast_via text NOT NULL DEFAULT 'ballot'/, 'every vote before the column reads as a ballot');
+  assert.match(sql, /cast_via IN \('ballot', 'stage_close'\) AND \(cast_via = 'ballot' OR direction = 'yes'\)/);
+  const dbSrc = fs.readFileSync(path.join(GOV, 'db.js'), 'utf8');
+  assert.match(dbSrc, /INSERT INTO government_board_votes \(item_id, voter_id, direction, reason_md, section_key, cast_via\)/);
+});

package/tests/government_seed.mjs

@@ -54,6 +54,7 @@ const NON_GRANT_MIGRATIONS = new Set([
   'government_032_ask_flags.sql',                  // the reword list: matters a reader flagged as unclear (owner 2026-10-23)
   '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)
 ]);
 
 // Permission keys RENAMED after the grant migrations that first granted them.

package/tests/hall_city.mjs

@@ -289,7 +289,7 @@ test('the city sits in the hall chrome, behind the shell\'s full-screen switch',
   // task 1004685 (the living city): gov-living.js, the model under the drawing, and
   // gov-feeds.js, its one reader per page (shared with the shell's tally), load before it
   // task 1004702: the card answers its first ask in place, so the deck's card and sender (and the desk rows under them) load before the page
-  assert.deepEqual(scripts, ['dom-utils', 'shell-trail', 'craft-mode', 'shell', 'hall-dialog', 'palette', 'gov-living', 'gov-feeds', 'city-draw', 'hall-kit', 'street-draw', 'street-card', 'street-inside', 'street-desk', 'street-deck', 'city-decide', 'city-switchboard', 'city'], 'the shell first, then the shared dialog (task 1005085), as on every hall page');
+  assert.deepEqual(scripts, ['dom-utils', 'shell-game', 'shell-trail', 'craft-mode', 'shell', 'hall-dialog', 'palette', 'gov-living', 'gov-feeds', 'city-draw', 'hall-kit', 'street-draw', 'street-card', 'street-inside', 'street-desk', 'street-deck', 'city-decide', 'city-switchboard', 'city'], 'the shell first, then the shared dialog (task 1005085), as on every hall page');
   // task 1004925: every script but dom-utils.js is deferred, so none holds up the
   // parser; defer runs them in document order, which is why the order above still
   // holds. dom-utils.js stays synchronous: the one-escaper guard

package/tests/hall_fullscreen.mjs

@@ -25,6 +25,8 @@ const HALL = path.join(ROOT, 'modules/hall-ui/public');
 const SHELL = fs.readFileSync(path.join(HALL, 'shell.js'), 'utf8');
 // task 1004492: the way back lives in shell-trail.js, which every page loads first.
 const TRAIL = fs.readFileSync(path.join(HALL, 'shell-trail.js'), 'utf8');
+// task 1005142: game mode, the hall-wide half of the switch; every page loads it before the shell.
+const GAME = fs.readFileSync(path.join(HALL, 'shell-game.js'), 'utf8');
 const read = (f) => fs.readFileSync(path.join(HALL, f), 'utf8');
 
 // Boot the shell once — one page load. `store` is the browser's localStorage and
@@ -125,11 +127,16 @@ function boot({ page = 'thinking', optIn = true, store = {}, storageThrows = fal
   };
   sandbox.globalThis = sandbox;
   vm.createContext(sandbox);
+  vm.runInContext(GAME, sandbox, { filename: 'shell-game.js' });
   vm.runInContext(TRAIL, sandbox, { filename: 'shell-trail.js' });
   vm.runInContext(SHELL, sandbox, { filename: 'shell.js' });
   const root = documentObj.documentElement;
   return {
     store,
+    game: () => windowObj.OTBShellGame,
+    gameStamp: () => root.dataset.game === 'on',
+    // The "how to leave" line: showing = the shell created it and it is not hidden.
+    hintShowing: () => els.has('fullscreen-hint') && els.get('fullscreen-hint').hidden === false,
     button: () => getElementById('fullscreen-toggle'),
     on: () => root.dataset.fullscreen === 'on',
     plain: () => root.dataset.fullscreenPlain === 'on',
@@ -477,3 +484,97 @@ test('source: full screen hides the sidebar and foot, and collapses the top bar
   assert.match(css, /html\[data-fullscreen="on"\] \.topbar-side > :not\(\.fullscreen-toggle\)/);
   assert.doesNotMatch(css, /html\[data-fullscreen="on"\] \.app-topbar \{ display: none/);
 });
+
+// GAME MODE (task 1005142, BONGOS-V3 R02). The spec's done-when: no page shows the
+// sidebar in game mode. Game mode is hall-wide — one key, read by the SAME switch
+// — so these drive the real shell-game.js + shell.js the way a reader moves
+// through the hall: page after page over one browser store.
+test('game mode: EVERY page opens without its bars — plain, laid-out, and one that remembers "off"', () => {
+  const store = { 'hall-game': 'on', 'hall-fullscreen:goals': 'off' };
+  for (const [page, optIn] of [['goals', false], ['work', false], ['thinking', true], ['city', true]]) {
+    const p = boot({ page, optIn, store });
+    assert.equal(p.on(), true, `${page} opens in full screen`);
+    assert.equal(p.gameStamp(), true, `${page}: html[data-game="on"]`);
+    assert.equal(p.plain(), optIn === false, `${page}: the plain mark still follows the page`);
+  }
+  assert.equal(boot({ page: 'goals', optIn: false, store: {} }).on(), false, 'and outside game mode nothing changed');
+});
+
+test('game mode: every hall page carries the switch — none opts out, and each loads shell-game.js before the shell', () => {
+  const pages = fs.readdirSync(HALL).filter((f) => f.endsWith('.html'));
+  assert.ok(pages.length >= 30, `found ${pages.length} hall pages`);
+  for (const f of pages) {
+    const html = read(f);
+    assert.doesNotMatch(html, /data-fullscreen-switch="off"/, `${f} must not opt out: it would keep its sidebar in game mode`);
+    assert.match(html, /id="app-topbar"/, `${f}: the top bar is where the shell renders the switch`);
+    const tags = [...html.matchAll(/<script src="\/builders\/([a-z-]+)\.js[^"]*"( defer)?><\/script>/g)].map((m) => [m[1], !!m[2]]);
+    const game = tags.findIndex((t) => t[0] === 'shell-game');
+    const shell = tags.findIndex((t) => t[0] === 'shell');
+    assert.ok(game >= 0 && game < shell, `${f} loads shell-game.js before shell.js`);
+    assert.equal(tags[game][1], tags[shell][1], `${f}: both load the same way, so the order holds`);
+  }
+});
+
+test('game mode: leaving brings the bars back for THIS page only, and never rewrites a page\'s own memory', () => {
+  const store = { 'hall-game': 'on', 'hall-fullscreen:thinking': 'on' };
+  const goals = boot({ page: 'goals', optIn: false, store });
+  goals.press('Escape');
+  assert.equal(goals.on(), false, 'Escape still leaves');
+  assert.equal(store['hall-fullscreen:goals'], undefined, 'nothing remembered for the page');
+  assert.equal(boot({ page: 'goals', optIn: false, store }).on(), true, 'the next load opens without bars again');
+  const sky = boot({ page: 'thinking', store });
+  sky.button().click();
+  assert.equal(sky.on(), false, 'the corner button leaves too');
+  assert.equal(store['hall-fullscreen:thinking'], 'on', 'the sky\'s own choice survives game mode');
+});
+
+test('game mode: the Escape hand-off is unchanged — a press the page used, or one in a field, does not leave', () => {
+  const p = boot({ page: 'goals', optIn: false, store: { 'hall-game': 'on' } });
+  p.press('Escape', { pageUses: true });
+  assert.equal(p.on(), true, 'a page listener that called preventDefault keeps the press');
+  p.press('Escape', { target: { tagName: 'TEXTAREA' } });
+  assert.equal(p.on(), true);
+});
+
+test('game mode: set() switches the page live, and turning it off hands each page back its own memory', () => {
+  const store = { 'hall-fullscreen:thinking': 'on' };
+  const goals = boot({ page: 'goals', optIn: false, store });
+  goals.game().set(true);
+  assert.equal(store['hall-game'], 'on');
+  assert.equal(goals.on(), true, 'on at once, no reload');
+  assert.ok(goals.resizes() >= 1, 'a page that sizes to its box is told to re-measure');
+  goals.game().set(false);
+  assert.equal(goals.on(), false, 'goals remembered nothing, so its bars return');
+  assert.equal(goals.gameStamp(), false);
+  assert.equal(store['hall-fullscreen:goals'], undefined, 'and switching the mode wrote nothing for the page');
+  const sky = boot({ page: 'thinking', store: Object.assign(store, { 'hall-game': 'on' }) });
+  sky.game().set(false);
+  assert.equal(sky.on(), true, 'the sky had chosen full screen itself, and keeps it');
+});
+
+test('game mode: ?game=on / ?game=off set it from the URL; anything else is ignored', () => {
+  const store = {};
+  assert.equal(boot({ page: 'work', optIn: false, store, search: '?game=on' }).on(), true);
+  assert.equal(store['hall-game'], 'on');
+  assert.equal(boot({ page: 'goals', optIn: false, store }).on(), true, 'and it holds on the next page');
+  assert.equal(boot({ page: 'work', optIn: false, store, search: '?game=off' }).on(), false);
+  boot({ page: 'work', optIn: false, store, search: '?game=%22%3E%3Cimg%3E' });
+  assert.equal(store['hall-game'], 'off', 'a value that is not on/off is not stored');
+});
+
+test('game mode: how to leave is said once per tab, not on every page; outside it the shell\'s rule stands', () => {
+  const store = { 'hall-game': 'on' };
+  const session = {};
+  assert.equal(boot({ page: 'goals', optIn: false, store, session }).hintShowing(), true, 'the first page says it');
+  assert.equal(boot({ page: 'work', optIn: false, store, session }).hintShowing(), false, 'the next does not repeat it');
+  const own = { 'hall-fullscreen:thinking': 'on' };
+  assert.equal(boot({ page: 'thinking', store: own, session: {} }).hintShowing(), true);
+  assert.equal(boot({ page: 'thinking', store: own, session: {} }).hintShowing(), true, 'a remembered page says it on every open, as before');
+});
+
+test('game mode: storage that throws leaves the hall out of game mode, with the switch working', () => {
+  const p = boot({ page: 'goals', optIn: false, storageThrows: true, search: '?game=on' });
+  assert.equal(p.on(), false);
+  p.button().click();
+  assert.equal(p.on(), true);
+});

package/tests/hall_my_agents.mjs

@@ -443,7 +443,7 @@ test('PAGE: in the hall family, with no prototype key', () => {
   assert.deepEqual(sheets, ['style.css', 'oversight.css', 'speciality-tools.css', 'my-agents.css'],
     'rides the oversight archetype; the shared speciality sheet (task 1005052) before its own, so the page skin wins');
   const scripts = [...html.matchAll(/src="\/builders\/([a-z-]+)\.js/g)].map((m) => m[1]);
-  assert.deepEqual(scripts.slice(0, 4), ['dom-utils', 'shell-trail', 'craft-mode', 'shell']); // dom-utils first: the shell escapes through it (task 1004876)
+  assert.deepEqual(scripts.slice(0, 5), ['dom-utils', 'shell-game', 'shell-trail', 'craft-mode', 'shell']); // dom-utils first: the shell escapes through it (task 1004876)
   for (const s of ['gov-living', 'gov-positions', 'my-agents', 'speciality-tools']) assert.ok(scripts.includes(s), `loads ${s}.js`);
   assert.doesNotMatch(html, /ma-key|data-proto|Prototype data/, 'nothing on the page is prototype data, so there is no key');
   assert.doesNotMatch(read('my-agents.js'), /governor-overlay/, 'and it reads no overlay');

package/tests/hall_street.mjs

@@ -490,7 +490,7 @@ test('the page holds the prototype\'s header, the street, the readings and the c
   assert.match(html, /<a class="street-mark" id="streetHome" href="\/builders\/city"[^>]*>\{\{productName\}\}</);
   for (const id of ['hudNeeds', 'hudMoving', 'hudShare', 'streetMode', 'streetSigns', 'streetPins', 'streetDoors', 'streetCard']) assert.match(html, new RegExp(`id="${id}"`), id);
   const scripts = [...html.matchAll(/<script src="\/builders\/([a-z-]+)\.js/g)].map((m) => m[1]);
-  assert.deepEqual(scripts.filter((s) => !/^street-(deck|office)$/.test(s)), ['dom-utils', 'shell-trail', 'craft-mode', 'shell', 'hall-dialog', 'palette', 'gov-living', 'gov-feeds', 'city-draw', 'street-draw', 'street-card', 'street-inside', 'street-depth', 'street-desk', 'street-amend', 'street'], 'the hall shell (task 1004544), the living model and its one reader (task 1004685: city-draw.js counts with it, so it loads first), the shared kit, then the card (task 1004528), the interiors (task 1004526), the living street\'s exterior (street-depth.js), the floor desk (task 1004558) and the drafted amendment (task 1004530); the deck rides beside them');
+  assert.deepEqual(scripts.filter((s) => !/^street-(deck|office)$/.test(s)), ['dom-utils', 'shell-game', 'shell-trail', 'craft-mode', 'shell', 'hall-dialog', 'palette', 'gov-living', 'gov-feeds', 'city-draw', 'street-draw', 'street-card', 'street-inside', 'street-depth', 'street-desk', 'street-amend', 'street'], 'the hall shell (task 1004544), the living model and its one reader (task 1004685: city-draw.js counts with it, so it loads first), the shared kit, then the card (task 1004528), the interiors (task 1004526), the living street\'s exterior (street-depth.js), the floor desk (task 1004558) and the drafted amendment (task 1004530); the deck rides beside them');
   assert.equal(City.STREET_HREF, '/builders/street', 'the city\'s door is this page');
 });
 

package/tests/nav_permission_atoms.mjs

@@ -102,7 +102,7 @@ test('the hall-preview fixture carries every atom /me resolves', () => {
 // task 1005051: Roadmap left it (folded into Goals; /roadmap redirects).
 // task 1005070: the remembered nav (the rail paints before /me).
 // task 1005088: the sidebar mark is drawn by reference to the one brand mark.
-const SHELL_SHA = '2845bfedfaf7846f';
+const SHELL_SHA = 'e9c13c142bcd2a95';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);