@bongos/core 1.25.23 → 1.25.25

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

@@ -30,7 +30,8 @@
     stage_tasks_unfinished: 'This stage still has unfinished tasks.',
     not_current_stage: 'That stage is already behind you.',
     legislation_not_passed: 'Legislation has to pass the Board Room first.',
-    not_deciding: 'The plan is already settled.',
+    stage_closed: 'The Board Room has passed that stage, so its answers are fixed.',
+    stage_lock_unknown: 'The Board Room could not be read, so nothing was changed. Try again in a moment.',
   };
 
   // What saving the plan did to the government, when it was not settled in the same
@@ -99,9 +100,17 @@
 
   // ── decide ────────────────────────────────────────────────────────────────
 
+  // Task 1005107: the same form REVISES a saved plan — it opens with the founder's own
+  // answers, and saving the same plan again changes nothing on the server.
   function decideHtml(g, gov) {
+    var p = g.plan || null;
+    if (p && p.government && gov) gov = Object.assign({}, gov, { recommended: { key: p.government } });
+    if (p && p.expected_builders && gov) gov = Object.assign({}, gov, { headcount: p.expected_builders });
     var rows = g.stages.map(function (s) {
-      var opts = DAY_CHOICES.map(function (d) {
+      // A saved length that is not one of the presets is kept as its own choice, so
+      // reopening the plan never quietly changes it (task 1005107).
+      var choices = DAY_CHOICES.indexOf(s.days) < 0 ? DAY_CHOICES.concat([s.days]).sort(function (x, y) { return x - y; }) : DAY_CHOICES;
+      var opts = choices.map(function (d) {
         return '<option value="' + d + '"' + (d === s.days ? ' selected' : '') + '>' + d + (d === 1 ? ' day' : ' days') + '</option>';
       }).join('');
       return '<li class="genesis__plan-row">'
@@ -110,22 +119,25 @@
         + '<label class="genesis__plan-len"><span class="sr-only">Length of ' + esc(s.label) + '</span>'
         + '<select data-days="' + esc(s.key) + '">' + opts + '</select></label></li>';
     }).join('');
-    return '<p class="scroll__lede">Settle the plan and each stage becomes real tasks. '
-      + 'Everything is preset to our recommendation, so one click is enough.</p>'
+    return (p
+      ? '<p class="scroll__lede">Change any of your answers. Due dates follow the new lengths; a new government goes to the board like any charter change.</p>'
+      : '<p class="scroll__lede">Settle the plan and each stage becomes real tasks. '
+      + 'Everything is preset to our recommendation, so one click is enough.</p>')
       + '<ol class="genesis__plan">' + rows + '</ol>'
       + '<div class="genesis__picks">'
       + governmentHtml(gov)
       + '<fieldset class="genesis__pick"><legend>How many passes</legend>'
-      + radio('passes', '1', 'One', 'Each stage is decided once.', true)
-      + radio('passes', '2', 'Two', 'Once now, and again when your next builders join.', false)
+      + radio('passes', '1', 'One', 'Each stage is decided once.', !p || p.passes !== 2)
+      + radio('passes', '2', 'Two', 'Once now, and again when your next builders join.', !!p && p.passes === 2)
       + '</fieldset>'
       + '<fieldset class="genesis__pick"><legend>Advisors</legend>'
-      + radio('advisors', 'none', 'None for now', 'You can add advisors at any stage.', true)
-      + radio('advisors', 'cbaas', 'Cloud Bongos advisors', 'Our consultants review each stage.', false)
+      + radio('advisors', 'none', 'None for now', 'You can add advisors at any stage.', !p || p.advisors !== 'cbaas')
+      + radio('advisors', 'cbaas', 'Cloud Bongos advisors', 'Our consultants review each stage.', !!p && p.advisors === 'cbaas')
       + '</fieldset>'
-      + '<label class="genesis__check"><input type="checkbox" data-existing> It already exists, so gather what it has first</label>'
+      + '<label class="genesis__check"><input type="checkbox" data-existing' + (p && p.existing ? ' checked' : '') + '> It already exists, so gather what it has first</label>'
       + '</div>'
-      + '<div class="genesis__doors"><button type="button" class="btn-accent" data-genesis-plan>Use this plan</button></div>';
+      + '<div class="genesis__doors"><button type="button" class="btn-accent" data-genesis-plan>' + (p ? 'Save the plan' : 'Use this plan') + '</button>'
+      + (p ? '<button type="button" class="btn-ghost" data-genesis-plan-cancel>Keep it as it was</button>' : '') + '</div>';
   }
 
   function radio(name, value, label, hint, checked) {
@@ -157,6 +169,47 @@
       + '</fieldset>';
   }
 
+  // ── changing a finished stage's answers (task 1005107) ─────────────────────
+  // The stage's own record (GET /founding/work/:stage), opened in place with the answers
+  // already given. Save sends only what changed; nothing changed sends nothing.
+  function stageEditorHtml(w) {
+    if (!w) return '';
+    var rows = (w.questions || []).map(function (q) {
+      var cur = q.answer && q.answer.state === 'answered' ? (q.answer.text || '') : '';
+      var field = q.choices
+        ? '<select data-answer="' + esc(q.id) + '"><option value=""' + (cur ? '' : ' selected') + '>Not answered</option>'
+          + q.choices.map(function (c) { return '<option value="' + esc(c.key) + '"' + (c.key === cur ? ' selected' : '') + '>' + esc(c.label) + '</option>'; }).join('') + '</select>'
+        : '<textarea rows="3" data-answer="' + esc(q.id) + '">' + esc(cur) + '</textarea>';
+      return '<label class="genesis__edit-q"><b>' + esc(q.ask) + '</b>' + field + '</label>';
+    }).join('');
+    return '<section class="genesis__edit" aria-label="Change the ' + esc(w.stage) + ' answers">'
+      + '<h3 class="genesis__now-h">Change the ' + esc(w.stage) + ' answers</h3>'
+      + '<p class="genesis__note">Changing them does not reopen the stage.</p>' + rows
+      + '<label class="genesis__edit-q"><b>In your own words</b><textarea rows="5" data-page>' + esc(w.page || '') + '</textarea></label>'
+      + '<div class="genesis__doors"><button type="button" class="btn-accent" data-genesis-stage-save>Save changes</button>'
+      + '<button type="button" class="btn-ghost" data-genesis-stage-cancel>Leave it as it was</button></div></section>';
+  }
+
+  // stageChanges(w, host) → the writes the edited form needs, only for what changed.
+  function stageChanges(w, host) {
+    var out = [];
+    (w.questions || []).forEach(function (q) {
+      var el = host.querySelector('[data-answer="' + q.id + '"]');
+      if (!el) return;
+      var was = q.answer && q.answer.state === 'answered' ? (q.answer.text || '') : '';
+      var now = String(el.value || '').trim();
+      if (now === was.trim()) return;
+      var path = '/founding/work/' + encodeURIComponent(w.stage) + '/answers/' + encodeURIComponent(q.id);
+      if (now) out.push(['PUT', path, { state: 'answered', text: now }]);
+      else if (q.answer) out.push(['DELETE', path, null]);
+    });
+    var page = host.querySelector('[data-page]');
+    if (page && String(page.value || '').trim() !== String(w.page || '').trim()) {
+      out.push(['PUT', '/founding/work/' + encodeURIComponent(w.stage) + '/page', { page: String(page.value || '') }]);
+    }
+    return out;
+  }
+
   // ── the stages ────────────────────────────────────────────────────────────
 
   function lifeHtml(g) {
@@ -207,9 +260,15 @@
         // buildings it raises, and for a stage that wakes no room, what it earns.
         + '<span>' + esc(gainsText(s)) + esc(due) + '</span>'
         + (s.state === 'later' && s.can_close ? '<span><button type="button" class="btn-ghost" data-genesis-close="' + esc(s.key) + '">Put to the board</button></span>' : '')
+        // Task 1005107: a finished stage stays editable unless the Board Room passed it.
+        + (s.state === 'done' ? (s.locked
+          ? '<span class="genesis__stage-fixed">' + esc('Fixed: ' + s.locked.reason) + '</span>'
+          : '<span><button type="button" class="btn-ghost" data-genesis-stage-edit="' + esc(s.key) + '">Change its answers</button></span>') : '')
         + '</span>'
         + '<span class="genesis__stage-st">' + esc(stateText(s)) + '</span></li>';
-    }).join('') + '</ol>';
+    }).join('') + '</ol>'
+      // Task 1005107: the plan is never a trap — reopen it with the answers already given.
+      + (g.plan_editable && !g.demo ? '<div class="genesis__doors"><button type="button" class="btn-ghost" data-genesis-plan-edit>Change the plan</button></div>' : '');
   }
 
   // task 1005109: Copy prompt on each task still to do, so the founder pastes it into
@@ -382,9 +441,10 @@
   function render(host, state) {
     var g = state.genesis;
     if (!g) { host.hidden = true; return; }
-    host.innerHTML = headHtml(g) + (g.deciding
-      ? decideHtml(g, state.gov)
-      : demoHtml(g) + lifeHtml(g) + votesHtml(g, state.viewer) + '<div class="genesis__grid">' + stagesHtml(g) + nowHtml(g, state.viewer) + '</div>');
+    host.innerHTML = headHtml(g) + (g.deciding || state.editingPlan
+      ? decideHtml(g.deciding ? Object.assign({}, g, { plan: null }) : g, state.gov)
+      : demoHtml(g) + lifeHtml(g) + votesHtml(g, state.viewer) + '<div class="genesis__grid">' + stagesHtml(g) + nowHtml(g, state.viewer) + '</div>'
+        + stageEditorHtml(state.stageWork));
     host.hidden = false;
   }
 
@@ -449,22 +509,44 @@
       if (!t || !host.contains(t)) return;
       if (t.hasAttribute('data-genesis-copy')) {
         copyPrompt(t, state);
+      } else if (t.hasAttribute('data-genesis-stage-edit')) {
+        act(send('GET', '/founding/work/' + encodeURIComponent(t.getAttribute('data-genesis-stage-edit'))).then(function (d) {
+          state.stageWork = d && d.work; render(host, state);
+        }));
+      } else if (t.hasAttribute('data-genesis-stage-cancel')) {
+        state.stageWork = null;
+        render(host, state);
+      } else if (t.hasAttribute('data-genesis-stage-save')) {
+        var writes = stageChanges(state.stageWork, host);
+        if (!writes.length) { state.stageWork = null; render(host, state); toast('Nothing changed.'); return; }
+        act(writes.reduce(function (p, w) { return p.then(function () { return send(w[0], w[1], w[2]); }); }, Promise.resolve())
+          .then(function () { state.stageWork = null; render(host, state); toast('Saved.'); }));
+      } else if (t.hasAttribute('data-genesis-plan-edit')) {
+        var exp = state.genesis && state.genesis.plan && state.genesis.plan.expected_builders;
+        act(loadGov(exp || null).then(function (gov) { state.gov = gov; state.editingPlan = true; render(host, state); }));
+      } else if (t.hasAttribute('data-genesis-plan-cancel')) {
+        state.editingPlan = false;
+        render(host, state);
       } else if (t.hasAttribute('data-genesis-plan')) {
         // The government picked here is filed as a charter amendment with the plan
         // (task 1004656). When the founder's one yes decides it, saving the plan is
         // that yes too, the same one-click fast-track the stage closes take.
         act(send('POST', '/founding/plan', planBody(host)).then(function (out) {
+          // A revision (task 1005107): say if nothing changed, and every change it could not carry.
+          if (out && out.revised === false) { state.editingPlan = false; render(host, state); toast('Nothing changed.'); return 'stay'; }
+          var held = !!(out && out.could_not && out.could_not.length);
+          if (held) toast(out.could_not.join(' '));
           var c = out && out.charter;
           if (c && c.state === 'sitting' && c.one_vote_decides && c.item_id) {
             return send('POST', '/government/board/items/' + encodeURIComponent(c.item_id) + '/votes', { direction: 'yes' })
               .catch(function () { return null; });
           }
           var said = charterNote(c);
-          if (!said) return null;
+          if (!said) return held ? window.OTB.sleep(3500) : null;
           toast(said);
           // Give the sentence time to be read before the reload takes it away.
           return window.OTB.sleep(3500);
-        }).then(function () { window.location.reload(); }));
+        }).then(function (r) { if (r !== 'stay') window.location.reload(); }));
       } else if (t.hasAttribute('data-genesis-close')) {
         // One call (task 1005121): where the founder's one yes decides, the server
         // closes the stage with it; otherwise it answers 202 with what the sitting

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/modules/public-landing/public/projects.html

@@ -1558,6 +1558,12 @@ summary{min-height:24px;padding:3px 0;}
               <svg class="gh" viewBox="0 0 16 16" aria-hidden="true"><path d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27s1.36.09 2 .27c1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.01 8.01 0 0 0 16 8c0-4.42-3.58-8-8-8z"/></svg>
               Continue with GitHub
             </a>
+            <!-- No GitHub account yet (task 1005283): the same sign-in, opened on GitHub's
+                 sign-up page (signup=1), which offers "Continue with Google" and hands the
+                 sign-in straight back here once the account exists. Bongos cannot make a
+                 GitHub account for anyone; GitHub can, in one step, with Google. -->
+            <p class="finePrint" id="wizWhyGh">Your project’s files live in a GitHub repository, so it needs a GitHub account.</p>
+            <p class="finePrint" id="wizNoGh">No GitHub account? <a id="wizSignup" href="/api/bongos/auth/web/start?via=github&amp;signup=1&amp;return=/projects%3Fview%3Dnew&amp;repos=1">Make one free with Google</a>. On GitHub’s page choose <strong>Continue with Google</strong>, and you come straight back here.</p>
             <!-- Informed consent BEFORE GitHub's own wording (ADR 0155): the scope the
                  button asks for reads as "all your repositories" on GitHub's screen, so
                  the reason is stated here, on the path every founder actually takes. -->

package/package-lock.json

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

package/package.json

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

@@ -11906,5 +11906,17 @@
       "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"
+    }
+  ],
+  "1.25.25": [
+    {
+      "id": "1005283",
+      "text": "Someone with no GitHub account can now start a project. The creation page explains why GitHub is needed and offers a 'Make one free with Google' link. GitHub's own sign-up page opens, they continue with their Google account, a"
+    }
   ]
 }

package/src/bongos/auth-github.js

@@ -291,6 +291,22 @@ function buildAuthorizeUrl(state, redirectUri, { repos = false, switchAccount =
   return u.toString();
 }
 
+// GitHub's own sign-up page, for a person with no GitHub account (task 1005283). It is the page GitHub's sign-in screen links as "Create an account"
+// during an OAuth sign-in: `return_to` carries the authorize step back, so once the
+// account exists (GitHub's sign-up offers "Continue with Google") GitHub resumes the
+// SAME sign-in — same state, same scope — and our callback lands the person where they
+// started. Only github.com's own authorize path is ever handed on; anything else is null
+// and the caller falls back to the plain authorize redirect.
+function githubSignupUrl(authorizeUrl) {
+  let u;
+  try { u = new URL(String(authorizeUrl)); } catch { return null; }
+  if (u.protocol !== 'https:' || u.host !== 'github.com' || u.pathname !== '/login/oauth/authorize') return null;
+  const signup = new URL('https://github.com/signup');
+  signup.searchParams.set('return_to', u.pathname + u.search);
+  signup.searchParams.set('source', 'oauth');
+  return signup.toString();
+}
+
 async function completeWebFlow({ code, redirectUri, userAgent, captureRepoToken = false }) {
   const { accessToken, scope: grantedScope } = await exchangeCodeForToken(code, redirectUri);
   const ghUser = await fetchGithubUser(accessToken);
@@ -386,6 +402,7 @@ async function completeWebFlow({ code, redirectUri, userAgent, captureRepoToken
 // slashes on origin are trimmed so `https://hub/` and `https://hub` behave alike.
 
 module.exports = {
+  githubSignupUrl,
   buildAuthorizeUrl,
   completeWebFlow,
   exchangeCodeForToken,

package/src/bongos/auth.js

@@ -58,7 +58,7 @@ const { branding, userAgent } = require('../branding');
 
 const { SCOPE, authConfigured, grantedScopeCoversRepos, idpConfigured, idpEnabled, loadIdpConfig, scopeForWebFlow } = require('./auth-config.js');
 const { firstAdminLogin, firstTimeAdmissionBlocked, instanceNeedsFirstAdmin, joinabilityMode, maybeSeatFirstAdmin, membershipKind, notifyHubOfInvite, openEnrollmentEnabled, readAppStatusFromHub, readApplicantProfileFromHub, readApplicantViewFromHub, webAdmissionStatus } = require('./auth-admission.js');
-const { buildAuthorizeUrl, completeWebFlow, pollDeviceFlow, startDeviceFlow } = require('./auth-github.js');
+const { buildAuthorizeUrl, githubSignupUrl, completeWebFlow, pollDeviceFlow, startDeviceFlow } = require('./auth-github.js');
 const { buildIdpAuthorizeUrl, completeDeviceExchange, completeIdpFlow, idpAuthorizeUrl, loadHubPublicKey, logoutTokenJtiSeenAndRecord, readApplicationVouch, verifyHubAssertion, verifyHubLogoutToken } = require('./auth-idp.js');
 const { addDiscordGuildMember, buildDiscordAuthorizeUrl, discordAuthorizeUrl, discordBotConfigured, discordConfigured, exchangeDiscordCode, fetchDiscordUser, isValidDiscordUserId, loadDiscordBotToken, loadDiscordCreds, removeDiscordGuildMember } = require('./auth-discord.js');
 
@@ -854,6 +854,7 @@ module.exports = {
   startDeviceFlow,
   pollDeviceFlow,
   buildAuthorizeUrl,
+  githubSignupUrl,
   scopeForWebFlow,
   grantedScopeCoversRepos,
   buildIdpAuthorizeUrl,

package/src/bongos/routes/auth.js

@@ -710,6 +710,7 @@ module.exports = function buildAuthRouter() {
     // ?switch=1 — sign in as a DIFFERENT GitHub account (task 1004789): show
     // GitHub's account picker instead of re-using the one logged in there.
     const wantsSwitch = req.query.switch === '1' || req.query.switch === 'true';
+    const wantsSignup = req.query.signup === '1' || req.query.signup === 'true'; // no GitHub account yet: its sign-up page (task 1005283)
     // A sign-in begun on a satellite hub host (builders./status.) restarts on
     // the canonical host (task 1004357). The handshake cookies are host-only now,
     // and the callback always lands on the canonical host, so a state cookie set
@@ -720,8 +721,7 @@ module.exports = function buildAuthRouter() {
       const raw = safeReturnTo(req.query.return) || safeReturnTo(req.headers.referer) || '/';
       const back = raw.startsWith('/') ? `https://${host}${raw}` : raw;
       const params = new URLSearchParams({ return: back });
-      if (wantsRepos) params.set('repos', '1');
-      if (wantsSwitch) params.set('switch', '1');
+      for (const [k, on] of [['repos', wantsRepos], ['switch', wantsSwitch], ['signup', wantsSignup]]) if (on) params.set(k, '1');
       if (req.query.via === 'github') params.set('via', 'github');
       return res.redirect(`${WEB_REDIRECT_ORIGIN.replace(/\/+$/, '')}${apiBase(req)}/auth/web/start?${params}`);
     }
@@ -729,7 +729,7 @@ module.exports = function buildAuthRouter() {
     // host (a builder who signed in on the apex, then opened builders.): no
     // GitHub round-trip, just hand that host its copy. A repo-scope sign-in
     // still goes to GitHub — it exists to ask for the broader grant.
-    if (!wantsRepos && !wantsSwitch) {
+    if (!wantsRepos && !wantsSwitch && !wantsSignup) {
       const target = safeReturnTo(req.query.return);
       if (target && !target.startsWith('/')) {
         try {
@@ -746,7 +746,7 @@ module.exports = function buildAuthRouter() {
     // lands on one chooser — Continue with GitHub or Continue with Google — so no
     // page needs its own pair of buttons. `via=github` is the GitHub button (and
     // any door that needs GitHub itself); "New account" names a GitHub account.
-    if (req.query.via !== 'github' && !wantsSwitch && googleConfigured()) {
+    if (req.query.via !== 'github' && !wantsSwitch && !wantsSignup && googleConfigured()) {
       const ret = safeReturnTo(req.query.return) || safeReturnTo(req.headers.referer);
       const gh = new URLSearchParams({ via: 'github' });
       if (ret) gh.set('return', ret);
@@ -803,9 +803,9 @@ module.exports = function buildAuthRouter() {
     // Federate through the hub when configured (ADR 0141 §1); otherwise the direct
     // GitHub authorize, carrying the repo-scope opt-in. Same CSRF state cookie either
     // way — the callback validates it identically, so the hub leg is CSRF-protected too.
-    res.redirect(auth.idpConfigured()
-      ? auth.buildIdpAuthorizeUrl(state, redirectUri)
-      : auth.buildAuthorizeUrl(state, redirectUri, { repos: wantsRepos, switchAccount: wantsSwitch }));
+    if (auth.idpConfigured()) return res.redirect(auth.buildIdpAuthorizeUrl(state, redirectUri));
+    const authorizeUrl = auth.buildAuthorizeUrl(state, redirectUri, { repos: wantsRepos, switchAccount: wantsSwitch });
+    res.redirect((wantsSignup && auth.githubSignupUrl(authorizeUrl)) || authorizeUrl);
   });
 
   // GET /auth/web/handoff?code=&return= — the far side of the one-time session

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