@bongos/core 1.21.89 → 1.21.90

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.21.89",
-  "core_contract": "1.21.89",
-  "source_commit": "38831cab07720823a9b92f0aa037b3305693ad97",
+  "core_version": "1.21.90",
+  "core_contract": "1.21.90",
+  "source_commit": "2dd5be5837e93b2d103d299c09f9337f17c8797b",
   "source_ref": "HEAD",
-  "built_at": "2026-10-09T05:42:09.000Z",
+  "built_at": "2026-10-09T05:58:47.014Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 590,
     "agent_docs_stubbed": 28,
-    "functional_verbatim": 3002,
+    "functional_verbatim": 3003,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 3621,
-  "tree_sha256": "7fa7282960adb921e05b5c6cf71a5bf2c41ac5d644f0d88f96329253dd5d08b4",
+  "file_count": 3622,
+  "tree_sha256": "5b43a0f4fea472ff637381cb9e1b3e09954adaaeca4030de5e80e8a5ff0d4965",
   "files": [
     {
       "path": ".claude/skills/ask-for-help/SKILL.md",
@@ -332,7 +332,7 @@
     {
       "path": "clients/bongos-client/index.d.ts",
       "mode": "0000644",
-      "sha256": "69597dbfaec21fe07620c9d78ba2942553ecc383a3e05ca1895549c5ab234a92"
+      "sha256": "963ca486acac3ab8f532e729adc5be1823c67be1f46f6fbd6364386066517ebd"
     },
     {
       "path": "clients/bongos-client/index.mjs",
@@ -2317,12 +2317,12 @@
     {
       "path": "docs/api-reference.md",
       "mode": "0000644",
-      "sha256": "5733dfc12bf37b73be9cdcd7951503a26a96da2498a71bee38d028fc8cfa243c"
+      "sha256": "d31cb1d2be0b2cfaba9cde0815fd2656ffd0db7f1ce1a1d9295926537501d679"
     },
     {
       "path": "docs/api/openapi.json",
       "mode": "0000644",
-      "sha256": "ec1612a7950896500daf83e236dbd3dbaadcdff4bc8ad23881b555a1f1916f4e"
+      "sha256": "fdc092f72bf761431cef7279a5aef6013acc31b3fa0e9191e5583186df73a3c4"
     },
     {
       "path": "docs/architecture.md",
@@ -2862,7 +2862,7 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "ed9b33963a8eda8788054e7169167a48e8bb4505871c045b8ff1340a8e3b18f8"
+      "sha256": "0a5d631b97f6fea01a2941927406f27e2ea58ed9914bacbfd60effbaf920a5ad"
     },
     {
       "path": "docs/modules-contract.md",
@@ -5157,7 +5157,7 @@
     {
       "path": "modules/government/routes/government.js",
       "mode": "0000644",
-      "sha256": "52bd577d606e072982545d91e4a05a94160cfedcf9e07ffdc90f06b75f0aeee1"
+      "sha256": "a77bd940b28aba83d1a567cfe6a0fc984688fa2b2b443d5ca80e79e02e55d95f"
     },
     {
       "path": "modules/government/routes/rank-sync.js",
@@ -10097,12 +10097,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "96f4fb223dd4ef57d829c81de1280ccf1c72049e7ab139b6ac46fa32a5a4b5a6"
+      "sha256": "9c11125be8e792dab7ec2cf20dc39ebd25bc7e9a5d6a3c9ed0638dd65a6c2a5c"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "ab7b4495de3efe672e1f513a6e6fec4bbd0f014ec9911f88d7d179311d4ced0d"
+      "sha256": "9cae3f7cea2893dd528990e19282d6a416886584bd210a3b51a1086796b9419d"
     },
     {
       "path": "public-docs/index.html",
@@ -10122,7 +10122,7 @@
     {
       "path": "release-notes.json",
       "mode": "0000644",
-      "sha256": "09e072fc45fdf0b997e752cb937c419bdbee49acb61dccbbadf270a2dd931637"
+      "sha256": "8864e076c0c535fb2bd5fee5149905b4c36ca41e8f1de18d702b7c82267cfc01"
     },
     {
       "path": "scripts/cron/style_guide_audit.sh",
@@ -12382,7 +12382,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "52f06dc54b008a397b074ef55a59566ea44fd9654c584f4a00194a200b21a34a"
+      "sha256": "a5a148f77f78c978b7526e75795fb74dfd5cf42fa10a77aa75b7c2f977fbff76"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -14314,6 +14314,11 @@
       "mode": "0000644",
       "sha256": "cf7e31016f76de229e3fb1bf68558fec10011aef041e2acc763fd53bcff24061"
     },
+    {
+      "path": "tests/government_board_routes.mjs",
+      "mode": "0000644",
+      "sha256": "86ab4c52a0b14c4d44f3bcfb48d80461bfbe7ca57ad9eb6da4f6ffa3ba130729"
+    },
     {
       "path": "tests/government_board_summons.mjs",
       "mode": "0000644",

package/clients/bongos-client/index.d.ts

@@ -363,7 +363,7 @@ export interface PostGoalsReorderResponse { ok: boolean; goals: unknown }
 export interface PostGoalsRequest { version_id: string; title: string; subtitle?: string; description?: string; scope_modules?: string[]; succeeds_goal_id?: number; category_id?: number; admit_reason?: string; spec_task?: boolean }
 export interface PostGoalsResponse { ok: boolean; goal: unknown; succeeds_goal_id: unknown; category_advisory: unknown; admitted: unknown; spec_task: unknown }
 export interface PostGovernmentAssignmentsRequest { builder_id: number; rank_key: string }
-export interface PostGovernmentBoardCharterRequest { form?: string; franchise?: string; council_rank?: string; pass_rule?: string; rationale_md?: string; acknowledge_self_removal?: boolean }
+export interface PostGovernmentBoardCharterRequest { form?: string; franchise?: string; council_rank?: string; pass_rule?: string; window_minutes?: unknown; rationale_md?: string; acknowledge_self_removal?: boolean }
 export interface PostGovernmentBoardCharterResponse { ok: boolean; amendment: unknown; item: unknown; reads_as: unknown }
 export interface PostGovernmentBoardDecisionRulesRequest { rules: unknown[]; rationale_md?: string }
 export interface PostGovernmentBoardDecisionRulesResponse { ok: boolean; amendment: unknown; item: unknown; rules: unknown }

package/docs/api/openapi.json

@@ -30306,6 +30306,7 @@
             "type": "string",
             "maxLength": 32
           },
+          "window_minutes": {},
           "rationale_md": {
             "type": "string",
             "maxLength": 5000

package/docs/api-reference.md

@@ -348,7 +348,7 @@ Base path: `/api/bongos`. Ranks (enforced server-side, [ADR 0016](adr/0016-trust
 | GET | `/api/bongos/government/assignments` | `archon` | — | government.manage — every builder↔rank assignment row. |
 | POST | `/api/bongos/government/assignments` | `archon` | `builder_id`, `rank_key` | government.manage — assign a CUSTOM rank to a builder. |
 | DELETE | `/api/bongos/government/assignments/:builderId/:rankKey` | `archon` | — | government.manage — remove a custom-rank assignment. |
-| POST | `/api/bongos/government/board/charter` | `metic+archon` | `form`, `franchise`, `council_rank`, `pass_rule`, `rationale_md`, `acknowledge_self_removal` | board.item.open — the genesis charter + legislation choice (task 1004427, spec D10): a form of government and/or its two live settings (f… |
+| POST | `/api/bongos/government/board/charter` | `metic+archon` | `form`, `franchise`, `council_rank`, `pass_rule`, `window_minutes`, `rationale_md`, `acknowledge_self_removal` | board.item.open — the genesis charter + legislation choice (task 1004427, spec D10): a form of government and/or its two live settings (f… |
 | POST | `/api/bongos/government/board/decision-rules` | `metic+archon` | `rules`, `rationale_md` | board.item.open — propose a change to WHO DECIDES WHAT (task 1004529): one or more buildings' rows of the decision-rules table, filed as … |
 | GET | `/api/bongos/government/board/genesis-stages` | `any-builder` | — | board.vote.cast — the founding band's read (task 1004429): each genesis stage's latest sitting, and who it is still waiting on under the … |
 | GET | `/api/bongos/government/board/items` | `any-builder` | — | board.vote.cast — the Board Room view: open items with their clock, the OPEN BALLOT, the closed history (R16 of goal 1000069). |

package/docs/module-api-changelog.md

@@ -3010,5 +3010,7 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.21.87 with no explicit bump. run 37888371878. (task 1002620)
   1.21.89 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.21.88 with no explicit bump. run 37889772259. (task 1002620)
+  1.21.90 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.21.89 with no explicit bump. run 37891104032. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/modules/government/routes/government.js

@@ -750,6 +750,10 @@ module.exports = function buildGovernmentRouter() {
       franchise: { type: 'string', maxLength: 32 },
       council_rank: { type: 'string', maxLength: RANK_KEY_MAX },
       pass_rule: { type: 'string', maxLength: 32 },
+      // Declared with no type rule: null (no clock) or a whole number, which the
+      // check just below enforces. Left out, the strict schema refused every
+      // request carrying a clock as an unknown field (found by task 1004655).
+      window_minutes: {},
       rationale_md: { type: 'string', maxLength: 5000 },
       acknowledge_self_removal: { type: 'boolean' },
     })) return;

package/package-lock.json

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

package/package.json

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

@@ -9364,5 +9364,11 @@
       "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"
     }
+  ],
+  "1.21.90": [
+    {
+      "id": "1004655",
+      "text": "Three government actions now have tests that check them the way the site really answers: choosing a form of government, taking back your own proposal before anyone votes, and seeing who each founding stage is still waiting on."
+    }
   ]
 }

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

@@ -0,0 +1,361 @@
+// tests/government_board_routes.mjs — route-level tests for three Board Room
+// routes that had none (task 1004655):
+//
+//   POST /government/board/charter               (the genesis charter pick)
+//   POST /government/board/items/:itemId/withdraw (a proposer takes back a sitting)
+//   GET  /government/board/genesis-stages        (who each founding stage waits on)
+//
+// The module/SQL walls are pinned elsewhere (government_charter_forms.mjs,
+// government_board_withdraw.mjs, government_board_genesis_stage.mjs). What those
+// cannot see is the HTTP mapping: which atom gates each route, which status and
+// error code each refusal becomes, and that the SESSION builder (never the body)
+// is the proposer. So this drives a real express app through the real router
+// and the real board / board-withdraw logic, with the REAL requirePermission
+// gate resolving a STUB government port on the seam and the db slice
+// monkeypatched by property — the tests/government_routes.mjs pattern.
+//
+// The live constitution is this checkout's neutral monarchy (rank:archon,
+// first_ratifier) — a guard test below pins that, because the charter cases
+// depend on it.
+//
+// Run:  node --test tests/government_board_routes.mjs
+
+import { strict as assert } from 'node:assert';
+import { test, after } from 'node:test';
+import http from 'node:http';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+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 api = require(path.join(ROOT, 'src', 'module-api.js'));
+const seams = require(path.join(ROOT, 'src', 'module-seams.js'));
+const govDb = require(path.join(GOV, 'db.js'));
+const config = require(path.join(GOV, 'config.js'));
+const { readCharter } = require(path.join(GOV, 'charter.js'));
+const { attachFail } = require(path.join(ROOT, 'src', 'bongos', 'middleware', 'error-envelope.js'));
+const express = require('express');
+
+const SESSION_ID = 42;
+const MONARCHY = Object.freeze({
+  membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true,
+});
+
+// ── harness ─────────────────────────────────────────────────────────────────
+
+// Every db function a test stubs is recorded, then restored after the test.
+const calls = [];
+async function withDb(stubs, fn) {
+  const originals = {};
+  for (const [k, v] of Object.entries(stubs)) {
+    originals[k] = govDb[k];
+    govDb[k] = (...args) => { calls.push([k, ...args]); return v(...args); };
+  }
+  try { return await fn(); } finally { for (const [k, v] of Object.entries(originals)) govDb[k] = v; }
+}
+const called = (name) => calls.filter(([k]) => k === name);
+
+// Fake the session (requireBuilder is captured at router build time); keep the
+// REAL requirePermission gate, which resolves the government port per request.
+const realRequireBuilder = api.requireBuilder;
+api.requireBuilder = (req, res, next) => { req.builder = { id: SESSION_ID, rank: 'archon' }; next(); };
+
+function grant(keys) {
+  seams._reset();
+  seams.registerProvider('government', { resolveBuilderPermissions: async () => keys });
+}
+const ALL = ['board.item.open', 'board.vote.cast'];
+grant(ALL);
+
+const buildGovernmentRouter = require(path.join(GOV, 'routes', 'government.js'));
+const app = express();
+app.use(express.json());
+app.use(attachFail);
+app.use(buildGovernmentRouter());
+const server = http.createServer(app);
+await new Promise((r) => server.listen(0, '127.0.0.1', r));
+const BASE = `http://127.0.0.1:${server.address().port}`;
+
+after(() => {
+  server.close();
+  api.requireBuilder = realRequireBuilder;
+  seams._reset();
+});
+
+async function call(method, p, body) {
+  calls.length = 0;
+  const res = await fetch(`${BASE}${p}`, {
+    method,
+    headers: body === undefined ? {} : { 'content-type': 'application/json' },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  let json = null;
+  try { json = await res.json(); } catch { /* no body */ }
+  return { status: res.status, json };
+}
+
+// The db a successful charter filing walks through: the amendment row, then
+// its sitting under the constitution IN FORCE.
+const filingDb = (over = {}) => ({
+  builderHoldsRankActive: async () => true,
+  getRankByKey: async () => null,
+  createAmendment: async (a) => ({ id: '5', proposed: a.proposed, proposed_by: a.proposedBy }),
+  openBoardItem: async (a) => ({
+    id: '21', subject_type: a.subjectType, subject_id: '5', opened_by: a.openedBy,
+    constitution: a.constitution, closes_at: null, closed_at: null,
+  }),
+  getActiveBuildersWithRank: async () => [],
+  ...over,
+});
+
+test('this checkout runs the neutral monarchy (the charter cases below depend on it)', () => {
+  assert.equal(readCharter(config.loadGovernmentConfig().board).form, 'monarchy');
+});
+
+// ── the rank wall ───────────────────────────────────────────────────────────
+
+// Holding the OTHER board atom is not enough: charter and withdraw need
+// board.item.open, the stage read needs board.vote.cast. One test per route, so
+// a broken gate names its route.
+const unreachable = {
+  listLatestGenesisStageItems: async () => { throw new Error('must not be reached'); },
+  getBoardItemForVote: async () => { throw new Error('must not be reached'); },
+  createAmendment: async () => { throw new Error('must not be reached'); },
+};
+for (const [method, p, body, held, missing] of [
+  ['POST', '/government/board/charter', { form: 'direct-democracy' }, 'board.vote.cast', 'board.item.open'],
+  ['POST', '/government/board/items/21/withdraw', {}, 'board.vote.cast', 'board.item.open'],
+  ['GET', '/government/board/genesis-stages', undefined, 'board.item.open', 'board.vote.cast'],
+]) {
+  test(`${method} ${p} refuses a builder without ${missing} (403 permission_forbidden), before the db`, async () => {
+    grant([held]);
+    try {
+      await withDb(unreachable, async () => {
+        const r = await call(method, p, body);
+        assert.equal(r.status, 403, `${method} ${p} must deny without ${missing}`);
+        assert.equal(r.json.error.code, 'permission_forbidden');
+        assert.equal(calls.length, 0, 'the refusal is before the db');
+      });
+    } finally { grant(ALL); }
+  });
+}
+
+// ── POST /government/board/charter ──────────────────────────────────────────
+
+test('charter: a new form is filed as an amendment by the SESSION builder, 201 with what it reads as', async () => {
+  await withDb(filingDb(), async () => {
+    // A body cannot name the proposer: the strict schema refuses the field outright.
+    const spoof = await call('POST', '/government/board/charter', { form: 'direct-democracy', proposed_by: 999 });
+    assert.equal(spoof.status, 400);
+    assert.equal(spoof.json.error.code, 'validation_failed');
+    assert.equal(called('createAmendment').length, 0);
+
+    const r = await call('POST', '/government/board/charter', { form: 'direct-democracy' });
+    assert.equal(r.status, 201);
+    assert.equal(r.json.ok, true);
+    assert.equal(r.json.reads_as.form, 'direct-democracy');
+    assert.equal(r.json.item.id, '21');
+    const [filed] = called('createAmendment');
+    assert.ok(filed, 'an amendment was filed');
+    assert.equal(filed[1].proposed.membership, 'rank:xenos+');
+    assert.equal(filed[1].proposedBy, SESSION_ID, 'the proposer is the session, never the body');
+    const [opened] = called('openBoardItem');
+    assert.equal(opened[1].openedBy, SESSION_ID);
+    assert.deepEqual(opened[1].constitution, config.loadGovernmentConfig().board,
+      'the sitting runs under the constitution IN FORCE, not the one proposed');
+  });
+});
+
+test('charter: picking the form already in force is no_change 409 and files nothing', async () => {
+  await withDb(filingDb(), async () => {
+    const r = await call('POST', '/government/board/charter', { form: 'monarchy' });
+    assert.equal(r.status, 409);
+    assert.equal(r.json.error.code, 'no_change');
+    assert.equal(called('createAmendment').length, 0);
+  });
+});
+
+test('charter: an unreadable choice is invalid_charter 400 naming the reason, and files nothing', async () => {
+  await withDb(filingDb(), async () => {
+    for (const [body, reason] of [
+      [{ form: 'no-such-form' }, 'unknown_form'],
+      [{}, 'nothing_chosen'],
+      [{ franchise: 'nobody-knows' }, 'unknown_franchise'],
+      [{ pass_rule: 'coin_toss' }, 'unknown_pass_rule'],
+      [{ franchise: 'council' }, 'council_needs_a_rank'],
+    ]) {
+      const r = await call('POST', '/government/board/charter', body);
+      assert.equal(r.status, 400, JSON.stringify(body));
+      assert.equal(r.json.error.code, 'invalid_charter', JSON.stringify(body));
+      assert.equal(r.json.error.details.reason, reason, JSON.stringify(body));
+    }
+    // A council must be a rank that exists; the refusal names the key.
+    const ghost = await call('POST', '/government/board/charter', { franchise: 'council', council_rank: 'ghosts' });
+    assert.equal(ghost.status, 400);
+    assert.equal(ghost.json.error.code, 'invalid_charter');
+    assert.equal(ghost.json.error.details.reason, 'unknown_council_rank');
+    assert.equal(ghost.json.error.details.rank_key, 'ghosts');
+    assert.equal(called('createAmendment').length, 0);
+  });
+});
+
+test('charter: a malformed body is refused before the board is asked', async () => {
+  await withDb(filingDb(), async () => {
+    const typed = await call('POST', '/government/board/charter', { form: 7 });
+    assert.equal(typed.status, 400);
+    assert.equal(typed.json.error.code, 'validation_failed');
+    const clock = await call('POST', '/government/board/charter', { form: 'direct-democracy', window_minutes: 1.5 });
+    assert.equal(clock.status, 400);
+    assert.equal(clock.json.error.code, 'invalid_proposal');
+    assert.equal(clock.json.error.details.reason, 'bad_window_minutes');
+    assert.equal(called('createAmendment').length, 0);
+  });
+});
+
+test('charter: a clock (window_minutes) is accepted and filed with the proposal', async () => {
+  // The handler reads window_minutes and the charter builder files it, so the
+  // strict schema must declare it — otherwise every request carrying a clock
+  // is refused as an unknown field and the clock can never be chosen here.
+  await withDb(filingDb(), async () => {
+    const r = await call('POST', '/government/board/charter', { pass_rule: 'consent', window_minutes: 90 });
+    assert.equal(r.status, 201, JSON.stringify(r.json));
+    const [filed] = called('createAmendment');
+    assert.equal(filed[1].proposed.window_minutes, 90);
+    assert.equal(filed[1].proposed.pass_rule, 'consent');
+  });
+});
+
+test('charter: a pick that unseats the proposer is 409 proposer_would_lose_their_seat until acknowledged', async () => {
+  await withDb(filingDb({ builderHoldsRankActive: async () => false }), async () => {
+    const r = await call('POST', '/government/board/charter', { form: 'direct-democracy' });
+    assert.equal(r.status, 409);
+    assert.equal(r.json.error.code, 'proposer_would_lose_their_seat');
+    assert.equal(r.json.error.details.membership, 'rank:xenos+');
+    assert.deepEqual(r.json.error.details.retry_with, { acknowledge_self_removal: true });
+    assert.ok(r.json.error.details.what_this_means, 'the refusal carries the words the hall shows');
+    assert.equal(called('createAmendment').length, 0, 'nothing is filed on the refusal');
+
+    const ack = await call('POST', '/government/board/charter', { form: 'direct-democracy', acknowledge_self_removal: true });
+    assert.equal(ack.status, 201, 'the acknowledged pick files');
+    assert.equal(called('createAmendment').length, 1);
+  });
+});
+
+test('charter: a db failure is a plain 500 charter_failed', async () => {
+  await withDb(filingDb({ createAmendment: async () => { throw new Error('boom'); } }), async () => {
+    const r = await call('POST', '/government/board/charter', { form: 'direct-democracy' });
+    assert.equal(r.status, 500);
+    assert.equal(r.json.error.code, 'charter_failed');
+  });
+});
+
+// ── POST /government/board/items/:itemId/withdraw ───────────────────────────
+
+const openItem = (over = {}) => ({
+  id: '21', subject_type: 'constitutional_amendment', subject_id: '5', opened_by: String(SESSION_ID),
+  constitution: MONARCHY, closed_at: null, expired: false, ...over,
+});
+const withdrawDb = (over = {}) => ({
+  getBoardItemForVote: async () => openItem(),
+  getVotesForItem: async () => [],
+  withdrawBoardItem: async ({ itemId }) => ({ ...openItem(), id: String(itemId), closed_at: 'T', outcome: 'withdrawn' }),
+  ...over,
+});
+
+test('withdraw: the proposer takes back their own unvoted sitting — 200, closed as withdrawn', async () => {
+  await withDb(withdrawDb(), async () => {
+    const r = await call('POST', '/government/board/items/21/withdraw', {});
+    assert.equal(r.status, 200);
+    assert.equal(r.json.ok, true);
+    assert.equal(r.json.item_closed, true);
+    assert.equal(r.json.outcome, 'withdrawn');
+    const [w] = called('withdrawBoardItem');
+    assert.ok(w, 'the write ran');
+    assert.equal(w[1].itemId, '21');
+    assert.equal(w[1].builderId, SESSION_ID, 'the withdrawer is the session builder');
+  });
+});
+
+test('withdraw: someone who did not open the sitting is refused 403 not_proposer', async () => {
+  for (const openedBy of ['99', null]) {
+    await withDb(withdrawDb({ getBoardItemForVote: async () => openItem({ opened_by: openedBy }) }), async () => {
+      const r = await call('POST', '/government/board/items/21/withdraw', {});
+      assert.equal(r.status, 403, `opened_by ${openedBy}`);
+      assert.equal(r.json.error.code, 'not_proposer');
+      assert.equal(r.json.error.details.item_id, 21);
+      assert.equal(called('withdrawBoardItem').length, 0, 'nothing is written');
+    });
+  }
+});
+
+test('withdraw: once anyone has voted it is refused 409 votes_cast', async () => {
+  const votes = [{ voter_id: '43', direction: 'no' }];
+  await withDb(withdrawDb({ getVotesForItem: async () => votes }), async () => {
+    const r = await call('POST', '/government/board/items/21/withdraw', {});
+    assert.equal(r.status, 409);
+    assert.equal(r.json.error.code, 'votes_cast');
+    assert.equal(called('withdrawBoardItem').length, 0, 'the voters keep their say');
+  });
+});
+
+test('withdraw: missing, closed, expired and raced sittings each get their own refusal', async () => {
+  for (const [over, status, code] of [
+    [{ getBoardItemForVote: async () => null }, 404, 'item_not_found'],
+    [{ getBoardItemForVote: async () => openItem({ closed_at: 'T', outcome: 'passed' }) }, 409, 'item_closed'],
+    [{ getBoardItemForVote: async () => openItem({ expired: true }) }, 409, 'vote_window_expired'],
+    // A vote landing between the reads and the write: the guarded write finds no row.
+    [{ withdrawBoardItem: async () => null }, 409, 'item_changed'],
+  ]) {
+    await withDb(withdrawDb(over), async () => {
+      const r = await call('POST', '/government/board/items/21/withdraw', {});
+      assert.equal(r.status, status, code);
+      assert.equal(r.json.error.code, code);
+    });
+  }
+});
+
+test('withdraw: a non-numeric item id is 400 before the db', async () => {
+  await withDb(withdrawDb(), async () => {
+    const r = await call('POST', '/government/board/items/abc/withdraw', {});
+    assert.equal(r.status, 400);
+    assert.equal(r.json.error.code, 'bad_item_id');
+    assert.equal(calls.length, 0);
+  });
+});
+
+// ── GET /government/board/genesis-stages ────────────────────────────────────
+
+test('genesis-stages: five stages, and an open sitting names who it is still waiting on', async () => {
+  const sitting = {
+    id: '90', subject_type: 'genesis_stage', subject_id: '3', opened_by: String(SESSION_ID),
+    opened_at: 'T0', closes_at: null, closed_at: null, outcome: null, remaining_seconds: null, constitution: MONARCHY,
+  };
+  const passed = { ...sitting, id: '80', subject_id: '1', closed_at: 'T1', outcome: 'passed' };
+  await withDb({
+    listLatestGenesisStageItems: async () => [passed, sitting],
+    getVotesForItems: async () => [],
+    getActiveBuildersWithRank: async () => [{ builder_id: '42', github_login: 'founder', display_name: 'Founder' }],
+  }, async () => {
+    const r = await call('GET', '/government/board/genesis-stages');
+    assert.equal(r.status, 200);
+    const stages = r.json.stages;
+    assert.deepEqual(stages.map((s) => s.key), ['scope', 'strategize', 'charter', 'legalize', 'legislation']);
+    assert.equal(stages[0].state, 'passed');
+    assert.equal(stages[1].state, 'not_put');
+    assert.equal(stages[2].state, 'sitting');
+    assert.equal(stages[2].item_id, '90');
+    assert.equal(stages[2].one_vote_decides, true);
+    assert.deepEqual(stages[2].waiting_on.map((m) => m.builder_id), ['42']);
+    assert.deepEqual(called('getVotesForItems')[0][1], ['90'], 'only the open sitting is asked for votes');
+  });
+});
+
+test('genesis-stages: a db failure is a plain 500 genesis_stage_read_failed', async () => {
+  await withDb({ listLatestGenesisStageItems: async () => { throw new Error('boom'); } }, async () => {
+    const r = await call('GET', '/government/board/genesis-stages');
+    assert.equal(r.status, 500);
+    assert.equal(r.json.error.code, 'genesis_stage_read_failed');
+  });
+});