@bongos/core 1.25.22 → 1.25.24

package/modules/onboarding/genesis-home.js

@@ -209,6 +209,8 @@ function shapeGenesis({ mode, plan, tasks = {}, board = {}, stageAt = {}, boardR
       // What this stage left behind (task 1005115): null where the store is not read.
       document: documents[key] || null,
       all_finished: allFinished,
+      // task 1005107: a stage the Board Room passed is fixed; its answers read-only, with why.
+      locked: b && b.state === 'passed' ? { reason: require('./genesis-work').lockReason(key) } : null,
       board: b ? {
         state: b.state, item_id: b.item_id || null, needs: b.needs || null,
         one_vote_decides: !!b.one_vote_decides, waiting_on: b.waiting_on || [],
@@ -233,6 +235,8 @@ function shapeGenesis({ mode, plan, tasks = {}, board = {}, stageAt = {}, boardR
     day: mode.day,
     deciding: mode.stage === 'decide',
     plan: plan || null,
+    // The plan stays editable for as long as genesis is on (task 1005107): POST /founding/plan revises it.
+    plan_editable: !!plan,
     // The demo's time box when this genesis is a demo's (task 1004506), else null.
     demo: plan && plan.demo ? plan.demo : null,
     stages,
@@ -257,7 +261,7 @@ function seams(deps = {}) {
     government: deps.government !== undefined ? deps.government : api.resolveOptional('government'),
     // Each stage's document summary (task 1005115): the founder's store unless injected.
     // Fails soft in readGenesis, so a hall without the tables still renders.
-    documents: deps.documents !== undefined ? deps.documents : () => require('./genesis-work').readDocuments(),
+    documents: deps.documents !== undefined ? deps.documents : (extra) => require('./genesis-work').readDocuments(extra),
     now: deps.now,
   };
 }
@@ -317,7 +321,10 @@ async function readGenesis(deps = {}) {
   }
   let documents = {};
   if (typeof s.documents === 'function') {
-    try { documents = (await s.documents()) || {}; } catch (_) { documents = {}; } // the home still renders without them
+    // The board was just read: hand its passed stages over, so the documents need no second read.
+    const locks = {};
+    for (const [k, row] of Object.entries(board)) if (row && row.state === 'passed') locks[k] = { reason: require('./genesis-work').lockReason(k) };
+    try { documents = (await s.documents({ locks })) || {}; } catch (_) { documents = {}; } // the home still renders without them
   }
   return shapeGenesis({ mode, plan, tasks, board, stageAt, boardRoom: hasBoardRoom(s.government), documents });
 }
@@ -371,12 +378,13 @@ async function setEnabled(enabled, builderId, deps = {}) {
 }
 
 // savePlan — the decide stage's door: record the plan, file the five stages as tasks,
-// and move to scope. Only while deciding.
+// and move to scope. After that, the same door REVISES the plan (task 1005107; owner:
+// "the UI is very restricting to be in the flow and not be able to go back and edit").
 async function savePlan(body, builderId, deps = {}) {
   const s = seams(deps);
   const mode = await fm.foundingModeFor(modeDeps(s));
   if (!mode) return { ok: false, reason: 'not_founding' };
-  if (mode.stage !== 'decide') return { ok: false, reason: 'not_deciding' };
+  if (mode.stage !== 'decide') return revisePlan(body, builderId, s);
   const parsed = parsePlan(body);
   if (!parsed.ok) return parsed;
   if (!s.lifecycle || typeof s.lifecycle.seedGenesis !== 'function') return { ok: false, reason: 'no_board' };
@@ -387,6 +395,58 @@ async function savePlan(body, builderId, deps = {}) {
   return { ok: true, plan: parsed.plan, seeded: seeded && seeded.seeded, charter };
 }
 
+// revisePlan — change the settled plan while genesis is on. The decide stage is never
+// put to a sitting, so it is never fixed. Re-sending the same plan changes NOTHING (no
+// write, no side effect). A changed plan is saved and what was derived from it follows:
+//   days        each stage's due date is computed from the plan at read time, so it moves at once
+//   government  a different form is filed as a charter amendment, decided like any (applyGovernmentChoice)
+//   existing    turning it on files the gather-what-exists step (the seeder dedups); turning it
+//               off cannot take back a step already filed, and the answer says so
+// `could_not` lists, in words, every change it could not carry through. A demo's settled
+// time box and minutes are kept: the plan route does not carry them.
+async function revisePlan(body, builderId, s) {
+  const prevRow = await s.get(PLAN_KEY);
+  const prev = readPlanValue(prevRow && prevRow.value);
+  const parsed = parsePlan(body);
+  if (!parsed.ok) return parsed;
+  const plan = parsed.plan;
+  if (prev && prev.demo) { plan.demo = prev.demo; if (prev.minutes) plan.minutes = prev.minutes; }
+  const same = prev && JSON.stringify(canonPlan(prev)) === JSON.stringify(canonPlan(plan));
+  if (same) return { ok: true, revised: false, changed: [], could_not: [], plan: prev };
+  const changed = prev ? Object.keys(plan).filter((k) => JSON.stringify(prev[k]) !== JSON.stringify(plan[k])) : Object.keys(plan);
+  const couldNot = [];
+  await s.set(PLAN_KEY, JSON.stringify(plan), builderId);
+  let charter = null;
+  if (changed.includes('government')) {
+    charter = plan.government ? await applyGovernmentChoice(plan.government, builderId, s) : { state: 'none' };
+    if (charter.state === 'not_filed' || charter.state === 'needs_council') {
+      couldNot.push(`The government could not be changed to ${plan.government} here: ${GOV_NOT_FILED[charter.reason || charter.state] || GOV_NOT_FILED.charter_failed}. The one in force stays.`);
+    }
+  }
+  if (changed.includes('existing')) {
+    if (plan.existing && s.lifecycle && typeof s.lifecycle.seedGenesis === 'function') {
+      await s.lifecycle.seedGenesis({ builderId, existing: true });
+    } else if (!plan.existing) {
+      couldNot.push('The step for gathering what already exists stays on the board: a filed task is not taken back. Drop it there if it no longer applies.');
+    }
+  }
+  return { ok: true, revised: true, changed, could_not: couldNot, plan, charter };
+}
+
+// Why a government choice could not be filed, as a person would say it.
+const GOV_NOT_FILED = Object.freeze({
+  needs_council: 'it needs a council with a rank before it can seat anyone',
+  no_government: 'this project has no Board Room to file it with',
+  charter_failed: 'the change to the charter could not be filed',
+});
+
+// canonPlan — PURE. A plan with its keys in one order, so two equal plans compare equal.
+function canonPlan(p) {
+  const out = {};
+  for (const k of Object.keys(p).sort()) out[k] = p[k] && typeof p[k] === 'object' && !Array.isArray(p[k]) ? canonPlan(p[k]) : p[k];
+  return out;
+}
+
 // applyGovernmentChoice — the government picked at decide becomes the one in force
 // (task 1004656). It is filed as an ordinary charter amendment under the constitution
 // in force (the government port's proposeCharter), so the board decides it like any

package/modules/onboarding/genesis-work.js

@@ -297,9 +297,9 @@ function documentOf(s) {
     markdown: filled ? lines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd() + '\n' : '',
     counts: s.counts,
     updated_at: latest([s.updated_at, ...said.map((q) => q.answer.updated_at)]),
-    // Editing never reopens the stage. Task 1005107 narrows this for a stage the Board
-    // Room passed; until then every document is open to its author.
-    editable: true,
+    // Editing never reopens the stage. A stage the Board Room passed is fixed (task 1005107).
+    editable: !s.locked,
+    locked_reason: s.locked ? s.locked.reason : null,
     edit: {
       answer: `PUT /api/bongos/founding/work/${s.stage}/answers/:question`,
       page: `PUT /api/bongos/founding/work/${s.stage}/page`,
@@ -320,9 +320,11 @@ async function readDocument(stage, deps = {}) {
 // genesis home carries per stage, so the page shows each stage's document in place.
 async function readDocuments(deps = {}) {
   const out = {};
+  let locks = {};
+  try { locks = await locksFor(deps); } catch (_) { locks = {}; }
   for (const s of await readAll(deps)) {
-    const d = documentOf(s);
-    out[s.stage] = { title: d.title, filled: d.filled, updated_at: d.updated_at, editable: d.editable };
+    const d = documentOf({ ...s, locked: locks[s.stage] || null });
+    out[s.stage] = { title: d.title, filled: d.filled, updated_at: d.updated_at, editable: d.editable, locked_reason: d.locked_reason };
   }
   return out;
 }
@@ -441,10 +443,50 @@ async function readAll(deps = {}) {
   return shapeAll(await storeOf(deps).loadAll());
 }
 
+// ── which stages are fixed (task 1005107) ─────────────────────────────────────
+// The owner's smallest honest answer: any stage not yet closed is editable; a stage the
+// Board Room PASSED is shown read-only with a plain reason, because its answers are what
+// the team voted on. A stage that moved on without a Board Room (a solo founder's
+// finished tasks, task 1005115) stays editable: nobody voted on it. No government module
+// means no sitting, so nothing is fixed. If the Board Room cannot be read, writes are
+// refused rather than risk changing what was voted on.
+const lockReason = (stage) => `The Board Room passed the ${stage} stage, so its answers are fixed: they are what was voted on. To change them, put the change to the Board Room.`;
+
+// locksFor(deps) → { stage: { reason } } for every stage the Board Room passed. A caller
+// that has already read the board passes the answer in as deps.locks (one read per request).
+async function locksFor(deps = {}) {
+  if (deps.locks) return deps.locks;
+  const api = deps.api || require('../../src/module-api');
+  const gov = deps.government !== undefined ? deps.government : api.resolveOptional('government');
+  if (!gov || typeof gov.genesisStageStatus !== 'function') return {};
+  const st = await gov.genesisStageStatus();
+  const out = {};
+  for (const row of (st && st.stages) || []) {
+    if (row && row.state === 'passed' && isStage(row.key)) out[row.key] = { reason: lockReason(row.key) };
+  }
+  return out;
+}
+
+// guardWrite(stage, deps) → { refused } when the stage may not be written, else
+// { deps } carrying the lock read, so the read that answers the write reuses it. Every
+// write checks this first, before its own content checks, so a fixed stage always
+// answers stage_closed whatever was sent.
+async function guardWrite(stage, deps) {
+  let locks;
+  try { locks = await locksFor(deps); } catch (_) {
+    return { refused: { ok: false, reason: 'stage_lock_unknown', message: 'The Board Room could not be read, so nothing was changed. Try again in a moment.' } };
+  }
+  if (locks[stage]) return { refused: { ok: false, reason: 'stage_closed', message: locks[stage].reason } };
+  return { deps: { ...deps, locks } };
+}
+
 async function readStage(stage, deps = {}) {
   if (!isStage(stage)) return { ok: false, reason: 'unknown_stage' };
   const all = await readAll(deps);
   const work = all.find((s) => s.stage === stage);
+  let locks = {};
+  try { locks = await locksFor(deps); } catch (_) { locks = {}; }
+  work.locked = locks[stage] || null;
   if (stage === 'charter') work.advice = await charterAdvice(work, deps);
   return { ok: true, work };
 }
@@ -490,16 +532,22 @@ async function setDoor(stage, door, by, deps = {}) {
   return readStage(stage, deps);
 }
 
-async function setPage(stage, page, by, deps = {}) {
+async function setPage(stage, page, by, deps0 = {}) {
   if (!isStage(stage)) return { ok: false, reason: 'unknown_stage' };
+  const g = await guardWrite(stage, deps0);
+  if (g.refused) return g.refused;
+  const deps = g.deps;
   const words = text(page);
   if (words.length > LIMITS.page) return { ok: false, reason: 'page_too_long' };
   await storeOf(deps).upsertWork(stage, { page_md: words || null }, by);
   return readStage(stage, deps);
 }
 
-async function setLink(stage, url, by, deps = {}) {
+async function setLink(stage, url, by, deps0 = {}) {
   if (!isStage(stage)) return { ok: false, reason: 'unknown_stage' };
+  const g = await guardWrite(stage, deps0);
+  if (g.refused) return g.refused;
+  const deps = g.deps;
   const c = checkLink(url);
   if (!c.ok) return c;
   await storeOf(deps).upsertWork(stage, { link_url: c.value }, by);
@@ -508,7 +556,11 @@ async function setLink(stage, url, by, deps = {}) {
 
 // setAnswer — store or revise one answer. opts.ifEmpty (for carrying answers over,
 // task 1005274) writes only where the founder has said nothing yet.
-async function setAnswer(stage, questionId, body, by, deps = {}, opts = {}) {
+async function setAnswer(stage, questionId, body, by, deps0 = {}, opts = {}) {
+  if (!isStage(stage)) return { ok: false, reason: 'unknown_stage' };
+  const g = await guardWrite(stage, deps0);
+  if (g.refused) return g.refused;
+  const deps = g.deps;
   const c = checkAnswer(stage, questionId, body);
   if (!c.ok) return c;
   const { changed } = await storeOf(deps).writeAnswer(stage, questionId, c.value, by, opts);
@@ -517,8 +569,11 @@ async function setAnswer(stage, questionId, body, by, deps = {}, opts = {}) {
 }
 
 // clearAnswer — un-answer: the question goes back to empty (not to "skipped").
-async function clearAnswer(stage, questionId, by, deps = {}) {
+async function clearAnswer(stage, questionId, by, deps0 = {}) {
   if (!isStage(stage)) return { ok: false, reason: 'unknown_stage' };
+  const g = await guardWrite(stage, deps0);
+  if (g.refused) return g.refused;
+  const deps = g.deps;
   if (!questionFor(stage, questionId)) return { ok: false, reason: 'unknown_question' };
   const { cleared } = await storeOf(deps).clearAnswer(stage, questionId, by);
   const r = await readStage(stage, deps);
@@ -547,6 +602,6 @@ async function readContext(deps = {}) {
 // and are exercised through the operations (tests/genesis_work.mjs).
 module.exports = {
   STAGES, LIMITS, QUESTIONS, assistPrompt,
-  readDocument, readDocuments,
+  readDocument, readDocuments, lockReason,
   pgStore, readAll, readStage, setDoor, setPage, setLink, setAnswer, clearAnswer, answerHistory, readContext,
 };

package/modules/onboarding/routes/genesis-work.js

@@ -17,6 +17,7 @@ const handoff = require('../guide-handoff');   // the start-a-project guide's an
 
 const REFUSALS = {
   unknown_stage: 404, unknown_question: 404, bad_door: 400, bad_state: 400, bad_origin: 400,
+  stage_closed: 409, stage_lock_unknown: 503,
   unknown_fact: 400, bad_fact: 400, region_not_in_country: 400,
   empty_answer: 400, not_a_choice: 400, answer_too_long: 400, page_too_long: 400, link_too_long: 400, bad_link: 400,
 };
@@ -28,7 +29,7 @@ module.exports = function mountGenesisWorkRoutes(router, deps = {}) {
     try {
       const r = await fn(req);
       if (r && r.ok === false) {
-        return res.status(REFUSALS[r.reason] || 409).json({ error: { code: r.reason, message: r.reason, ...(r.expected ? { expected: r.expected } : {}) } });
+        return res.status(REFUSALS[r.reason] || 409).json({ error: { code: r.reason, message: r.message || r.reason, ...(r.expected ? { expected: r.expected } : {}) } });
       }
       res.set('Cache-Control', 'no-store');
       res.json(r);

package/package-lock.json

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

package/package.json

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

@@ -11900,5 +11900,17 @@
       "id": "1005129",
       "text": "Choosing how contributors are rewarded now shows, for every option, what the platform really requires and what is closed — and the project now remembers where it is and where its builders are, so those notes fit it."
     }
+  ],
+  "1.25.23": [
+    {
+      "id": "1005285",
+      "text": "In the builders' hall, a project still being founded no longer lists its closed rooms in the quick-jump search; only the rooms that are open can be found."
+    }
+  ],
+  "1.25.24": [
+    {
+      "id": "1005107",
+      "text": "A founder can now go back and change their Genesis plan after saving it, and change any earlier stage's answers until the Board Room has voted that stage through — a voted stage shows its answers with a plain reason why they a"
+    }
   ]
 }

package/scripts/hall-preview/README.md

@@ -24,6 +24,7 @@ node scripts/hall-preview/server.js                 # neutral pack, port 4600
 | `--fixture-me` | don't read your own account live — serve the checked-in `me.json` snapshot (see below) |
 | `--signed-out` | answer `/me` with a 401 — preview the signed-out sign-in card |
 | `--latency 3000` | hold every data read that many ms before answering, so a page's loading state (the hall's `.hall-loading` mark) stays on screen long enough to look at |
+| `--founding scope` | preview a project being founded, at that genesis stage (task 1005285): `/me.founding_mode` is the real `shapeFoundingMode`, `GET /founding/genesis` the real `shapeGenesis` over `fixtures/founding__genesis__tasks.json`, and a sleeping room's page is refused by the real `foundingPageGate` |
 
 Writes are not wired: any `POST/PATCH/DELETE` answers `501 preview_readonly` — except
 the canned writes in `server.js` and, since task 1004685, the five per-builder pref

package/scripts/hall-preview/server.js

@@ -74,6 +74,12 @@ const SIGNED_OUT = process.argv.includes('--signed-out');
 // fixtures answer in a millisecond, which is why no loader had ever been seen.
 const LATENCY = Math.max(0, Number(arg('--latency')) || 0);
 const BRAND_FILE = arg('--brand') || 'config/branding.neutral.json';
+// --founding <stage>: preview a project being founded, at that genesis stage (task 1005285).
+// The answers are the server's own code, never a hand-written copy: /me.founding_mode is
+// shapeFoundingMode (modules/onboarding/founding-mode.js), GET /founding/genesis is
+// shapeGenesis over fixtures/founding__genesis__tasks.json (modules/onboarding/genesis-home.js),
+// and a sleeping room's page is refused by the real foundingPageGate (src/bongos/).
+const FOUNDING_STAGE = arg('--founding');
 process.env.BONGOS_BRANDING_FILE = path.resolve(ROOT, BRAND_FILE);
 
 /* eslint-disable import/no-dynamic-require */
@@ -93,6 +99,18 @@ const { overrideKey, resolveLiveIdentity } = require('./live-identity');
 const { createPrefRecorder, readJsonBody } = require('./pref-writes');
 const PREFS = createPrefRecorder();
 
+let FOUNDING = null;
+let GENESIS = null;
+if (FOUNDING_STAGE) {
+  const fm = require(path.join(ROOT, 'modules', 'onboarding', 'founding-mode.js'));
+  const gh = require(path.join(ROOT, 'modules', 'onboarding', 'genesis-home.js'));
+  FOUNDING = fm.shapeFoundingMode({ active: 'true', stage: FOUNDING_STAGE, startedAt: new Date(Date.now() - 2 * 86400000).toISOString() });
+  if (!FOUNDING) throw new Error(`--founding: not a genesis stage: ${FOUNDING_STAGE} (one of ${fm.STAGES.join(', ')})`);
+  const tasks = JSON.parse(fs.readFileSync(path.join(FIXTURES, 'founding__genesis__tasks.json'), 'utf8'));
+  delete tasks._comment;
+  GENESIS = gh.shapeGenesis({ mode: FOUNDING, plan: gh.parsePlan({}).plan, tasks });
+}
+
 // The session is the ONE thing this harness reads from outside its own tree, and
 // it reads it through the FAIL-OPEN helper on purpose: apiCall/cliClient exit the
 // process on a 401, which would kill a preview over a cosmetic feature.
@@ -423,12 +441,17 @@ app.use((req, res, next) => {
   // wasn't resolved live falls through to its fixture exactly as before.
   const q = req.query || {};
   const live = liveOverrides.get(overrideKey(apiPath, q)) ?? liveOverrides.get(apiPath);
+  if (FOUNDING && apiPath === 'founding/genesis') {
+    const me = liveOverrides.get('me') ?? fixtureFor('me');
+    return res.json({ genesis: GENESIS, viewer_id: me && me.builder ? me.builder.id : null });
+  }
   const fix = live !== undefined ? live : fixtureFor(apiPath, q);
   if (fix === undefined) {
     console.log(`  no fixture: ${apiPath}  (add scripts/hall-preview/fixtures/${apiPath.replace(/\//g, '__')}.json)`);
     return res.status(404).json({ error: { code: 'no_fixture', message: apiPath } });
   }
   let payload = EMPTY ? emptied(fix) : fix;
+  if (FOUNDING && apiPath === 'me') payload = { ...payload, founding_mode: FOUNDING };
   if (RANK_OVERRIDE && apiPath === 'me') {
     payload = JSON.parse(JSON.stringify(payload));
     if (payload.builder) payload.builder.rank = RANK_OVERRIDE;
@@ -486,8 +509,15 @@ app.get('/', (req, res, next) => { if (!sendPage(res, 'index.html')) next(); });
 // fell through to the real gate and 302'd to sign-in (task 1003305).
 app.get(/^\/task\/\d+$/, (req, res, next) => { if (!sendPage(res, 'task.html')) next(); });
 app.get(/^\/idea\/\d+$/, (req, res, next) => { if (!sendPage(res, 'idea.html')) next(); });
+// --founding: a sleeping room's page answers as prod does, through the real gate (it
+// matches the apex /builders/<room> shape; the harness serves pages at the root).
+const foundingGate = FOUNDING
+  ? require(path.join(ROOT, 'src', 'bongos', 'founding-page-gate.js')).foundingPageGate({ isBuildersHost: () => true, read: async () => FOUNDING })
+  : null;
 app.get(/^\/([a-z-]+)$/, (req, res, next) => {
-  if (!sendPage(res, `${req.params[0]}.html`)) next();
+  const serve = () => { if (!sendPage(res, `${req.params[0]}.html`)) next(); };
+  if (!foundingGate) return serve();
+  return foundingGate({ path: `/builders${req.path}` }, res, serve);
 });
 
 // What the READING ROOM reads (task 1003306): the primer document and
@@ -554,6 +584,7 @@ function accountLine() {
   app.listen(PORT, '127.0.0.1', () => {
     console.log(`hall-preview: http://builders.localhost:${PORT}/`);
     console.log(accountLine());
+    if (FOUNDING) console.log(`  founding: stage ${FOUNDING.stage}; asleep: ${Object.keys(FOUNDING.asleep).join(', ') || 'none'}`);
     console.log(`  brand: ${BRAND_FILE}${EMPTY ? '  (EMPTY fixtures)' : ''}${MODULES_OFF.length ? `  modules off: ${MODULES_OFF.join(',')}` : ''}`);
     console.log('  pages:', Object.keys(stamped).map((f) => f.replace(/\.html$/, '')).sort().join(' '));
   });

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

@@ -229,7 +229,7 @@ function world({ withGovernment = true } = {}) {
     lifecycle, government, now, documents: null,
   });
   return {
-    store, tasks, board, opened, deps,
+    store, tasks, board, opened, deps, government,
     finish: (s) => tasks[s].forEach((t) => { t.status = 'shipped'; }),
     pass: (s) => { board[s] = { state: 'passed', item_id: '9', waiting_on: [] }; },
     tick: (days) => { now = new Date(now.getTime() + days * 86400000); },
@@ -251,7 +251,7 @@ test('decide → five stages through the Board Room → alive, and the hall open
   g = await gh.readGenesis(w.deps());
   assert.equal(g.stage, 'scope');
   assert.equal(g.can_close, false, 'a stage with unfinished tasks cannot be put to the board');
-  assert.equal((await gh.savePlan({}, 1, w.deps())).reason, 'not_deciding', 'the plan is settled once');
+  assert.equal((await gh.savePlan({}, 1, w.deps())).revised, false, 'the same plan again changes nothing (task 1005107)');
 
   for (const s of STAGES5) {
     assert.equal((await gh.readGenesis(w.deps())).stage, s);
@@ -446,6 +446,48 @@ test('task 1005115: each stage on the genesis home carries its document', async
   assert.equal(g.stages[0].document, null);
 });
 
+test('task 1005107: the plan can be changed after decide; the same plan again changes nothing', async () => {
+  const w = world();
+  w.government.proposeCharter = async ({ form }) => ({ ok: true, item: { id: 44, constitution: { pass_rule: 'first_ratifier' } }, reads_as: { name: form } });
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({ days: { scope: 7 } }, 1, w.deps());
+  let g = await gh.readGenesis(w.deps());
+  assert.equal(g.plan_editable, true);
+  const before = new Map(w.store);
+  const same = await gh.savePlan({ days: { scope: 7 } }, 1, w.deps());
+  assert.equal(same.ok, true);
+  assert.equal(same.revised, false);
+  assert.deepEqual([...w.store], [...before], 'leaving it unchanged writes nothing');
+  // A changed length moves the stage's due date at once.
+  const r = await gh.savePlan({ days: { scope: 10 } }, 1, w.deps());
+  assert.equal(r.revised, true);
+  assert.deepEqual(r.changed, ['days']);
+  g = await gh.readGenesis(w.deps());
+  assert.equal(g.stages[0].days, 10);
+  assert.equal(g.stage, 'scope', 'revising the plan never moves the stage');
+  // A different government is filed for the board, like any charter change.
+  const gov = await gh.savePlan({ days: { scope: 10 }, government: 'republic' }, 1, w.deps());
+  assert.equal(gov.charter.state, 'sitting');
+  assert.equal(gov.charter.item_id, '44');
+  // Turning "existing" off cannot take back a filed step, and it says so.
+  await gh.savePlan({ days: { scope: 10 }, government: 'republic', existing: true }, 1, w.deps());
+  const off = await gh.savePlan({ days: { scope: 10 }, government: 'republic', existing: false }, 1, w.deps());
+  assert.equal(off.could_not.length, 1);
+  assert.match(off.could_not[0], /stays on the board/);
+  assert.equal((await gh.savePlan({ days: { scope: 999 } }, 1, w.deps())).reason, 'bad_days', 'a revision is held to the same ranges');
+});
+
+test('task 1005107: a stage the Board Room passed is shown fixed, with why; one that has not is not', async () => {
+  const w = world();
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({}, 1, w.deps());
+  w.finish('scope');
+  w.pass('scope');
+  const g = await gh.readGenesis(w.deps());
+  assert.match(g.stages[0].locked.reason, /Board Room passed the scope stage/);
+  assert.equal(g.stages[1].locked, null);
+});
+
 test('the view: states, wakes, the life plates and a due date from the plan', () => {
   const mode = { stage: 'strategize', stage_number: 2, stage_count: 5, day: 9 };
   const g = gh.shapeGenesis({
@@ -704,6 +746,77 @@ test('task 1005115: with no Board Room the card says the stage moved by itself,
   assert.doesNotMatch(host.innerHTML, /The strategy<\/b>/, 'an empty document is not listed');
 });
 
+test('task 1005107: the card offers to change the plan, reopens it with the saved answers, and says which stages are fixed', async () => {
+  const genesis = gh.shapeGenesis({
+    mode: { stage: 'strategize', stage_number: 2, stage_count: 5, day: 3 },
+    plan: { days: { scope: 7, strategize: 9, charter: 4, legalize: 7, legislation: 3 }, passes: 2, advisors: 'cbaas', existing: true, government: null, expected_builders: null },
+    tasks: { scope: [{ id: '1', title: 'Scope', status: 'shipped' }], strategize: [{ id: '2', title: 'Strategy', status: 'ready' }] },
+    board: { scope: { state: 'passed', waiting_on: [] } },
+    stageAt: { strategize: '2026-10-08T00:00:00Z' },
+  });
+  const b = bootCard({ founding: true, data: { genesis, viewer_id: '1' } });
+  const click = await mountClickable(b);
+  assert.match(b.host.innerHTML, /data-genesis-plan-edit>Change the plan</);
+  assert.match(b.host.innerHTML, /Fixed: The Board Room passed the scope stage/);
+  assert.doesNotMatch(b.host.innerHTML, /data-genesis-plan>/, 'the plan form is not shown until asked for');
+  await click(fakeButton('data-genesis-plan-edit'));
+  assert.match(b.host.innerHTML, /data-genesis-plan>Save the plan</);
+  assert.match(b.host.innerHTML, /data-genesis-plan-cancel>Keep it as it was</);
+  assert.match(b.host.innerHTML, /value="2" checked/, 'two passes, as saved');
+  assert.match(b.host.innerHTML, /value="cbaas" checked/, 'advisors, as saved');
+  assert.match(b.host.innerHTML, /data-existing checked/, '"it already exists", as saved');
+  assert.match(b.host.innerHTML, /<option value="9" selected>9 days/, 'the stage length, as saved');
+  await click(fakeButton('data-genesis-plan-cancel'));
+  assert.doesNotMatch(b.host.innerHTML, /data-genesis-plan>/, 'keeping it as it was sends nothing and closes the form');
+  assert.ok(!b.calls.some((c) => c.startsWith('POST /founding/plan')));
+});
+
+test('task 1005107: a finished stage\'s answers are changed in place; unchanged sends nothing, a change sends only itself', async () => {
+  const genesis = gh.shapeGenesis({
+    mode: { stage: 'strategize', stage_number: 2, stage_count: 5, day: 3 },
+    plan: { days: {} },
+    tasks: { scope: [{ id: '1', title: 'Scope', status: 'shipped' }], strategize: [{ id: '2', title: 'Strategy', status: 'ready' }] },
+    stageAt: { strategize: '2026-10-08T00:00:00Z' },
+  });
+  const work = {
+    stage: 'scope', page: 'Old page',
+    questions: [
+      { id: 'what_creating', ask: 'What are you creating?', answer: { state: 'answered', text: 'A ledger' } },
+      { id: 'reach_who', ask: 'Who for?', answer: null },
+    ],
+  };
+  const b = bootCard({ founding: true, data: { genesis, viewer_id: '1', work } });
+  const click = await mountClickable(b);
+  assert.match(b.host.innerHTML, /data-genesis-stage-edit="scope">Change its answers</);
+  await click(fakeButton('data-genesis-stage-edit', 'scope'));
+  assert.ok(b.calls.includes('GET /api/bongos/founding/work/scope'));
+  assert.match(b.host.innerHTML, /<textarea rows="3" data-answer="what_creating">A ledger<\/textarea>/, 'opens with the answer already given');
+  assert.match(b.host.innerHTML, /data-page>Old page</);
+  // Leaving everything as it was sends nothing.
+  const values = { '[data-answer="what_creating"]': 'A ledger', '[data-answer="reach_who"]': '', '[data-page]': 'Old page' };
+  b.host.querySelector = (sel) => (sel in values ? { value: values[sel] } : null);
+  const before = b.calls.length;
+  await click(fakeButton('data-genesis-stage-save'));
+  assert.equal(b.calls.length, before, 'nothing changed: no request');
+  assert.deepEqual(b.toasts.slice(-1), ['Nothing changed.']);
+  // A change sends only that answer.
+  await click(fakeButton('data-genesis-stage-edit', 'scope'));
+  values['[data-answer="reach_who"]'] = 'Small bakeries';
+  const mark = b.calls.length;
+  await click(fakeButton('data-genesis-stage-save'));
+  assert.deepEqual(b.calls.slice(mark), ['PUT /api/bongos/founding/work/scope/answers/reach_who']);
+});
+
+test('task 1005107: a government the plan cannot file is explained in words, never as a code', async () => {
+  const w = world();
+  w.government.proposeCharter = async () => ({ ok: false, reason: 'council_needs_a_rank' });
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({}, 1, w.deps());
+  const r = await gh.savePlan({ government: 'foundation' }, 1, w.deps());
+  assert.match(r.could_not[0], /needs a council with a rank/);
+  assert.doesNotMatch(r.could_not[0], /needs_council|council_needs/);
+});
+
 test('the hall carries the five life plates byte-identical to the world\'s', () => {
   const world = path.join(ROOT, 'modules', 'public-landing', 'public', 'assets', 'world');
   const hall = path.join(ROOT, 'modules', 'hall-ui', 'public', 'genesis');

package/tests/genesis_work.mjs

@@ -399,6 +399,44 @@ if (import.meta.url === url.pathToFileURL(process.argv[1]).href) {
     assert.equal(all.charter.title, 'The charter');
   });
 
+  await test('task 1005107: a stage the Board Room passed is read-only with a plain reason; others stay editable', async () => {
+    let passed = ['scope'];
+    const government = { genesisStageStatus: async () => ({ stages: passed.map((key) => ({ key, state: 'passed' })) }) };
+    const deps = { store: memStore(), government };
+    const w = await gw.setAnswer('scope', 'what_creating', { text: 'A ledger' }, 1, deps);
+    assert.equal(w.ok, false);
+    assert.equal(w.reason, 'stage_closed');
+    assert.match(w.message, /Board Room passed the scope stage/);
+    assert.equal((await gw.setPage('scope', 'x', 1, deps)).reason, 'stage_closed');
+    assert.equal((await gw.setLink('scope', 'https://x.test', 1, deps)).reason, 'stage_closed');
+    assert.equal((await gw.clearAnswer('scope', 'what_creating', 1, deps)).reason, 'stage_closed');
+    const read = await gw.readStage('scope', deps);
+    assert.match(read.work.locked.reason, /fixed/);
+    const doc = (await gw.readDocument('scope', deps)).document;
+    assert.equal(doc.editable, false);
+    assert.match(doc.locked_reason, /what was voted on/);
+    assert.equal((await gw.readDocuments(deps)).scope.editable, false);
+    // A stage not passed stays editable, and so does one with no Board Room at all.
+    assert.equal((await gw.setAnswer('strategize', 'risks', { text: 'Time' }, 1, deps)).ok, true);
+    assert.equal((await gw.setAnswer('scope', 'what_creating', { text: 'A ledger' }, 1, { store: deps.store, government: null })).ok, true);
+    // When the Board Room cannot be read, nothing is written.
+    const broken = { store: deps.store, government: { genesisStageStatus: async () => { throw new Error('down'); } } };
+    assert.equal((await gw.setAnswer('strategize', 'risks', { text: 'Money' }, 1, broken)).reason, 'stage_lock_unknown');
+    passed = [];
+    assert.equal((await gw.setPage('scope', 'Now open again', 1, deps)).ok, true);
+  });
+
+  await test('task 1005107: a fixed stage answers stage_closed whatever was sent, and the board is read once per write', async () => {
+    let reads = 0;
+    const government = { genesisStageStatus: async () => { reads++; return { stages: [{ key: 'charter', state: 'passed' }] }; } };
+    const deps = { store: memStore(), government };
+    assert.equal((await gw.setPage('charter', 'x'.repeat(gw.LIMITS.page + 1), 1, deps)).reason, 'stage_closed', 'not page_too_long');
+    assert.equal((await gw.setAnswer('charter', 'no_such_question', { text: 'x' }, 1, deps)).reason, 'stage_closed', 'not unknown_question');
+    reads = 0;
+    assert.equal((await gw.setAnswer('strategize', 'risks', { text: 'Time' }, 1, deps)).ok, true);
+    assert.equal(reads, 1, 'the write and the read that answers it share one Board Room read');
+  });
+
   console.log(`\ngenesis_work: ${passed} passed, ${failed} failed`);
   if (failed) process.exit(1);
 }

package/tests/genesis_work_routes.mjs

@@ -34,12 +34,15 @@ app.use(express.json());
 const router = express.Router();
 // The project's facts (task 1005129) live in project_settings: an in-memory one here.
 const settings = new Map();
+let passedStages = [];
 mount(router, {
   store,
   getSetting: async (k) => (settings.has(k) ? { key: k, value: settings.get(k) } : null),
   setSetting: async (k, v) => { settings.set(k, String(v)); },
   factsMarker: null,
   payGates: null,
+  // The Board Room (task 1005107): the stages listed in `passedStages` read as passed.
+  government: { genesisStageStatus: async () => { if (!passedStages) throw new Error('board down'); return { stages: passedStages.map((key) => ({ key, state: 'passed' })) }; } },
 });
 app.use('/api/bongos', router);
 const server = app.listen(0);
@@ -100,6 +103,24 @@ try {
     assert.match(r.data.markdown, /Where its builders are: global/);
   });
 
+  await test('task 1005107: a write to a stage the Board Room passed is a 409 that says why', async () => {
+    passedStages = ['legislation'];
+    const r = await call('PUT', '/founding/work/legislation/page', { body: { page: 'x' } });
+    assert.equal(r.status, 409);
+    assert.equal(r.data.error.code, 'stage_closed');
+    assert.match(r.data.error.message, /Board Room passed the legislation stage/);
+    const d = await call('GET', '/founding/work/legislation/document', { as: OTHER });
+    assert.equal(d.data.document.editable, false);
+    passedStages = [];
+    assert.equal((await call('PUT', '/founding/work/legislation/page', { body: { page: 'x' } })).status, 200);
+    // When the Board Room cannot be read, the write is refused as a 503, never let through.
+    passedStages = null;
+    const down = await call('PUT', '/founding/work/legislation/page', { body: { page: 'y' } });
+    assert.equal(down.status, 503);
+    assert.equal(down.data.error.code, 'stage_lock_unknown');
+    passedStages = [];
+  });
+
   await test('a builder who is not the owner cannot write', async () => {
     for (const [m, p, body] of [
       ['PUT', '/founding/work/strategize/answers/risks', { text: 'x' }],