@bongos/core 1.24.74 → 1.24.76

package/modules/hall-ui/records/home-city.md

@@ -175,6 +175,27 @@ leaderboard.
 - Pinned in `tests/home_studio.mjs` and `tests/home_studio_widget.mjs` (real browser, empty states included); harness
   fixtures `copy-desk__studio.json` and `home__studio__works.json`.
 
+## The idea box — the ideator's Home opens on it (task 1005078)
+
+The owner's work-first hall (2026-11-04: "the hall is for doing work, not looking at stuff"), goal 1000095. In
+Ideating, the first thing on Home is a place to type an idea and file it; the sky and the ladder stay under it.
+
+- **One section, still.** `home-idea-box.js` is not a hall widget (Home's stats zone holds one): `home-city.js`
+  attaches it at the top of its section, the gallery's way, and `craftHome()` shows it in Ideating only. It shows
+  even when `GET /home/city` failed, because filing needs no picture of the other ideas.
+- **One box and a button** (owner, 2026-11-05: "the idea submission should only have one box"). Enter files and
+  Shift+Enter starts a new line (owner, same day); the box grows with what is typed. The first non-empty line is
+  the title and any lines after it are `body_md`. No kind or goal picker: it files `kind: 'feature'` through
+  `POST /inbox`, the sky composer's quick filing, and triage routes it. The top bar's + idea button is unchanged.
+- **What it says.** A refusal keeps the words and names the reason (`details.reason`, else the code); a filing
+  clears the box and links to Your thinking. It reads nothing.
+- **The setup guide hides in Ideating** (`#welcome-scroll`, `home-idea-box.css`): it is about building on your
+  own machine and pushed the box below the fold. Every other craft still shows it.
+- **Preview.** `scripts/hall-preview/server.js` answers `POST /inbox` with the canned `inbox.post.json`, so the
+  filed state can be seen. Pinned by `tests/home_idea_box.mjs` (8 cases, a real browser).
+- **Sign-off.** The owner saw it in the preview at 1440 dark and said "Looks right, ship it" (2026-11-05), then
+  asked for Enter / Shift+Enter, which was added before the ship.
+
 ## The governor's Home is the street (task 1005064)
 
 The owner, 2026-11-04, after the four Homes went live: "when you tab between the pages the home screen

package/modules/ideas/routes/blockers.js

@@ -79,6 +79,28 @@ function askRequired(req, body) {
   return !TEMPLATED_SOURCES.includes(body.source);
 }
 
+// CHECKED, NOT INFERRED (task 1005120). A blocker spends the owner's attention, the
+// scarcest thing a project has. One project's blocker asked its owner to "apply to
+// Plaid for OAuth" for days after the project's own shipped work found there was
+// nothing to apply for: it had been filed on an inference (one bank worked, one did
+// not) when the page that settled it was one click away. So the same filings that
+// owe an ask (an AI session, by hand) also owe `checked` — one sentence naming what
+// the session opened or ran that showed only a person can do this. It is written into
+// the blocker's body, so whoever re-reads the blocker later (the daily review re-checks
+// before asking again) can see what the claim rested on and test it against what has
+// shipped since. The floor is a length, because a length is all a server can judge;
+// it stops "probably needed", which is the shape the hunch takes.
+const CHECKED_MIN = 30;
+const CHECKED_REQUIRED_MESSAGE = 'An AI session files a blocker only after checking it really needs a person. '
+  + `Add "checked": one sentence (${CHECKED_MIN} characters or more) saying what you opened or ran that showed it, `
+  + 'for example the settings page you read or the command whose output you saw. If you have not checked, check first.';
+// The line names WHO checked, so a blocker is tracked back to its filer — the person a
+// re-check asks first — without a new column on the core-owned table.
+function checkedLine(checked, builder) {
+  const who = builder && builder.github_login ? ` (by @${builder.github_login})` : '';
+  return `**Checked before filing${who}:** ${String(checked).trim()}`;
+}
+
 // The `ideas.fileBlocker` port's writer: POST /blockers' shape and length rules, for a caller
 // inside the server, which has no request to validate. A refusal throws with code BAD_BLOCKER.
 function fileBlockerFromServer({ title, bodyMd = '', source, sourceRef } = {}) {
@@ -145,6 +167,8 @@ module.exports = function buildBlockersRouter() {
   // person answers (task 1004703, see THE ASK above); a slop ask files nothing
   // (400 `ask_refused`). An AI session filing by hand (a CLI session, any `source`
   // but a templated script's) must send one: without it, 400 `ask_required` (task 1004704).
+  // The same filing also sends `checked` — what it opened or ran that showed a person
+  // is needed — or 400 `checked_required`; it is appended to body_md (task 1005120).
   // → 201 { blocker, ask } (ask: the stored card, or null).
   router.post('/blockers', api.requireBuilder, async (req, res) => {
     if (validateOrRespond(req, res, {
@@ -153,6 +177,7 @@ module.exports = function buildBlockersRouter() {
       source: { type: 'string', maxLength: LIMITS.SOURCE },
       source_ref: { type: 'string', maxLength: LIMITS.SOURCE_REF },
       ask: { type: 'object' },
+      checked: { type: 'string', maxLength: LIMITS.TITLE },
     })) return;
     const body = req.body || {};
     let verdict = null;
@@ -177,10 +202,31 @@ module.exports = function buildBlockersRouter() {
         return res.fail('ask_refused', { status: 400, message: gov.refusalLine(verdict.errors), details: { errors: verdict.errors } });
       }
     }
+    // After the ask, so a filing with no card hears about the card first (task 1005120).
+    const checked = typeof body.checked === 'string' ? body.checked.trim() : '';
+    if (askRequired(req, body) && checked.length < CHECKED_MIN) {
+      return res.fail('checked_required', {
+        status: 400,
+        message: CHECKED_REQUIRED_MESSAGE,
+        details: { field: 'checked', min_length: CHECKED_MIN },
+      });
+    }
+    const bodyMd = checked
+      ? [String(body.body_md ?? '').trim(), checkedLine(checked, req.builder)].filter(Boolean).join('\n\n')
+      : (body.body_md ?? '');
+    // body_md was validated on its own; the check line is added after, so the whole is
+    // held to the same cap rather than quietly growing past it.
+    if (bodyMd.length > LIMITS.DESCRIPTION) {
+      return res.fail('body_too_long', {
+        status: 400,
+        message: `The blocker's text and its "checked" line come to ${bodyMd.length} characters; ${LIMITS.DESCRIPTION} at most. Shorten the body.`,
+        details: { field: 'body_md', max_length: LIMITS.DESCRIPTION },
+      });
+    }
     try {
       const blocker = await blockers.createBlocker({
         title: body.title,
-        bodyMd: body.body_md ?? '',
+        bodyMd,
         source: body.source ?? 'manual',
         sourceRef: body.source_ref ?? null,
       });

package/modules/onboarding/genesis-home.js

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

package/modules/onboarding/routes/onboarding.js

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

package/package-lock.json

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

package/package.json

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

@@ -11469,5 +11469,23 @@
       "id": "1005142",
       "text": "The hall has a game mode: once it is on, every page opens full screen with no sidebar, and Escape brings the menus back when you need them."
     }
+  ],
+  "1.24.76": [
+    {
+      "id": "1005078",
+      "text": "In Ideating mode, Home now opens on a single box to type and file an idea — press Enter to file it, Shift+Enter for a new line."
+    },
+    {
+      "id": "1005120",
+      "text": "Blockers now cost a real check to file: an AI session must say what it looked at that showed a person is needed, and that note stays on the blocker. The daily blocker review now re-checks each one against what has shipped sinc"
+    },
+    {
+      "id": "1005012",
+      "text": "The Deploy page now says in one plain line whether the project is up to date. When it is, it says merged work in that version is live and that the next version arrives on its own (or waits, if the project is set to stay put)."
+    },
+    {
+      "id": "1005121",
+      "text": "Closing a project-setup stage is now one step: if the founder alone decides, the stage closes and the project moves on at once; if others must vote, the answer says who and what to do next instead of falsely reporting success."
+    }
   ]
 }

package/scripts/bongos/blocker-recheck.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// scripts/bongos/blocker-recheck.js — what has shipped since a blocker was filed that may
+// already answer it (task 1005120).
+//
+// WHY. A blocker is a claim about the world, made on a date, by a session that has long
+// since ended. One project's blocker asked its owner to "apply to Plaid for Chase and Bank of
+// America OAuth" for days after the project's own shipped work had found there was nothing
+// to apply for — nothing ever re-read it, and it had no linked tasks, so no promotion would
+// ever surface it. /blocker-review runs this before putting a blocker to a person again: it
+// lists the shipped work since the filing that shares the blocker's subject, so the session
+// reads that first and offers to close the blocker when the answer is already in.
+//
+// IT SUGGESTS, IT NEVER DECIDES. A word overlap is a reason to read a task, not proof the
+// blocker is answered; closing one is still a person's verdict in the review. So the match is
+// deliberately simple and explainable (shared subject words, each shown), never a score a
+// reader has to trust.
+//
+// usage: node scripts/bongos/blocker-recheck.js <blocker-id> [--json]
+
+'use strict';
+
+// Words that say nothing about a blocker's SUBJECT. Short words are dropped by length.
+const STOP = new Set([
+  'about', 'after', 'again', 'already', 'also', 'apply', 'because', 'before', 'being', 'blocker',
+  'cannot', 'could', 'does', 'done', 'each', 'from', 'have', 'into', 'just', 'make', 'more', 'must',
+  'need', 'needs', 'only', 'other', 'owner', 'should', 'some', 'still', 'than', 'that', 'their',
+  'them', 'then', 'there', 'these', 'they', 'this', 'those', 'through', 'until', 'very', 'want',
+  'were', 'what', 'when', 'where', 'which', 'while', 'will', 'with', 'without', 'would', 'your',
+  'task', 'tasks', 'work', 'page', 'pages', 'project',
+  // Words nearly every shipped summary in this ledger carries, so they say nothing about a
+  // blocker's subject (measured against a live blocker: these alone matched ten tasks).
+  'back', 'both', 'check', 'checks', 'core', 'main', 'once', 'open', 'itself', 'shipped', 'test',
+  'tests', 'version', 'versions', 'instance', 'server', 'update', 'copy', 'first', 'every', 'now',
+]);
+
+/** The subject words of a text: lower-cased, 4+ letters, not a stop word. */
+function subjectWords(text) {
+  const out = new Set();
+  for (const w of String(text || '').toLowerCase().match(/[a-z][a-z0-9]{3,}/g) || []) {
+    if (!STOP.has(w)) out.add(w);
+  }
+  return out;
+}
+
+/**
+ * Shipped tasks AFTER the blocker was filed that share at least `minShared` subject words
+ * with its title + body, most shared first, then newest. PURE.
+ * Each result: { id, short_name, title, shipped_at, value_summary, shared: [words] }.
+ */
+function relatedShipped(blocker, tasks, { minShared = 2, max = 10 } = {}) {
+  const filed = Date.parse(blocker && blocker.created_at);
+  if (!Number.isFinite(filed)) return [];
+  // The TITLE names the subject; a long body mostly carries generic words that match
+  // everything. The body is used only when the title alone is too thin to match on.
+  let want = subjectWords(blocker.title);
+  if (want.size < minShared) want = subjectWords(`${blocker.title || ''} ${blocker.body_md || ''}`);
+  const hits = [];
+  for (const t of Array.isArray(tasks) ? tasks : []) {
+    if (!t || t.status !== 'shipped') continue;
+    const at = Date.parse(t.shipped_at);
+    if (!Number.isFinite(at) || at <= filed) continue;
+    const have = subjectWords(`${t.title || ''} ${t.value_summary || ''}`);
+    const shared = [...want].filter((w) => have.has(w)).sort();
+    if (shared.length >= minShared) {
+      hits.push({ id: t.id, short_name: t.short_name || null, title: t.title, shipped_at: t.shipped_at, value_summary: t.value_summary || null, shared });
+    }
+  }
+  hits.sort((a, b) => (b.shared.length - a.shared.length) || (Date.parse(b.shipped_at) - Date.parse(a.shipped_at)));
+  return hits.slice(0, max);
+}
+
+/** The lines /blocker-review reads. Never "nothing is related" as proof the blocker holds. */
+function reportLines(blocker, hits) {
+  const head = `Blocker ${blocker.id} - "${blocker.title}" (filed ${String(blocker.created_at).slice(0, 10)})`;
+  if (!hits.length) {
+    return [head, '  No shipped work since it was filed shares its subject. That is not proof it still holds: re-run the check it names, if any.'];
+  }
+  return [head, `  ${hits.length} shipped since it was filed may answer it — read these before asking again:`,
+    ...hits.map((h) => `  - task ${h.id}${h.short_name ? ` - ${h.short_name}` : ''} (shipped ${String(h.shipped_at).slice(0, 10)}; shares: ${h.shared.join(', ')})${h.value_summary ? `\n      ${h.value_summary}` : ''}`)];
+}
+
+async function main(argv) {
+  const id = Number(argv[0]);
+  if (!Number.isInteger(id) || id <= 0) {
+    console.error('usage: node scripts/bongos/blocker-recheck.js <blocker-id> [--json]');
+    return 2;
+  }
+  const { cliClient } = require('./cli-lib');
+  const api = await cliClient();
+  const b = await api.request('GET', `/blockers/${id}`);
+  if (!b.ok || !b.data || !b.data.blocker) {
+    console.error(`blocker ${id}: could not be read (${b.status})`);
+    return 1;
+  }
+  const t = await api.request('GET', '/tasks?status=shipped&limit=1000');
+  if (!t.ok) {
+    console.error(`shipped tasks could not be read (${t.status}), so nothing was re-checked`);
+    return 1;
+  }
+  const tasks = Array.isArray(t.data) ? t.data : (t.data && t.data.tasks) || [];
+  const hits = relatedShipped(b.data.blocker, tasks);
+  if (argv.includes('--json')) console.log(JSON.stringify({ blocker_id: id, related: hits }, null, 2));
+  else console.log(reportLines(b.data.blocker, hits).join('\n'));
+  return 0;
+}
+
+module.exports = { subjectWords, relatedShipped, reportLines };
+
+if (require.main === module) {
+  main(process.argv.slice(2)).then((code) => { process.exitCode = code; }, (e) => { console.error(e.message); process.exitCode = 1; });
+}

package/scripts/bongos/government-walk.js

@@ -801,12 +801,12 @@ async function runWalk() {
   for (const stage of genesis.PROPER) {
     store.tasks.get(STAGE_TASK_IDS[stage]).status = 'shipped';
     let itemId = null;
-    await check(`${stage}: its finished stage is put to the board`, 'a sitting under the chosen government', async () => {
+    await check(`${stage}: its finished stage is put to the board`, '202 not closed, a sitting under the chosen government', async () => {
       const r = await call(FOUNDER, 'POST', `/founding/stages/${stage}/close`);
       itemId = r.json && r.json.item_id;
       const snap = itemId && itemOf(itemId) ? itemOf(itemId).constitution : {};
-      const reads = charter.readCharter(snap).form;
-      return { got: `${r.status}, sitting under ${reads}`, pass: r.status === 200 && !!itemId && reads === CHOSEN };
+      const reads = charter.readCharter(snap).form, notClosed = !!r.json && r.json.closed === false && r.json.reason === 'sitting_open'; // task 1005121: never a 200 for an open stage
+      return { got: `${r.status} ${notClosed ? 'not closed' : 'closed?'}, a sitting under ${reads}`, pass: r.status === 202 && notClosed && !!itemId && reads === CHOSEN };
     });
     await check(`${stage}: the founder alone cannot close it; every trusted member's yes does`, 'open, open, passed', async () => {
       const after = await voteAll(itemId, timocrats);
@@ -1267,7 +1267,7 @@ async function walkNewMachinery({ call, code, vote, voteAll, check, section, sta
   });
   let matter = null;
   await check('With an ask, the AI session\'s blocker is filed and carries its card', '201; the blocker reads back with its question', async () => {
-    const r = await call(CY, 'POST', '/blockers', { title: 'Walk needs a decision', ask: GOOD_ASK }, 'cli');
+    const r = await call(CY, 'POST', '/blockers', { title: 'Walk needs a decision', ask: GOOD_ASK, checked: 'Ran the walk against the stub server and read its refusal for this exact card.' }, 'cli');
     const id = r.json && r.json.blocker && r.json.blocker.id;
     matter = id ? `blockers:${id}` : null;
     const back = await call(CY, 'GET', `/blockers/${id}`);

package/scripts/gds/blocker-recheck.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// scripts/gds/blocker-recheck.js — @bongos-forwarder (task 1004848). Generated by
+// scripts/bongos/codemod-rename-scripts-gds.js; do not edit.
+// The real script is scripts/bongos/blocker-recheck.js. This forwarder keeps callers that still name
+// the old path working, and warns once so they get repointed. Task 1003706 removes it.
+'use strict';
+require('../bongos/forwarder.js').forward(module, 'blocker-recheck.js');

package/scripts/hall-preview/server.js

@@ -182,6 +182,7 @@ const FIXTURE_FALLBACKS = [
 // and changes nothing: the harness has no state to change, and the page reads
 // the same fixtures again on reload. Anything absent is still refused.
 const CANNED_WRITES = [
+  ['POST', /^inbox$/, 'inbox.post'],
   ['PUT', /^copy-desk\/pages\/[a-z0-9-]+:[a-z0-9-]+\/draft$/, 'copy-desk__pages__draft.put'],
   ['POST', /^copy-desk\/pages\/[a-z0-9-]+:[a-z0-9-]+\/submit$/, 'copy-desk__pages__submit.post'],
   ['POST', /^copy-desk\/pages\/[a-z0-9-]+:[a-z0-9-]+\/claim$/, 'copy-desk__pages__claim.post'],

package/src/module-api.js

@@ -81,7 +81,7 @@ const { sleep } = require('./sleep');
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.24.74'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.24.76'; // 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/deploy_page_projects.mjs

@@ -238,6 +238,55 @@ test('a box with nothing newer offers no button', async () => {
   const b = boot({ controlPlane: preview('1', 'cloudbongos', { behind: false, recommended_version: null }) });
   await b.settle();
   assert.match(b.panel(), /There is nothing to deploy/);
+  assert.doesNotMatch(b.panel(), /id="dp-preview-1"/);
+});
+
+// ---- the plain status line and the deploy-now button (task 1005012) ----------------
+//
+// The owner opened this page to put merged work live and found neither a button nor a
+// sentence: the box was already on the newest version, which it had reached by itself on
+// its update rule, and the page said only "nothing to deploy". So the box now LEADS with
+// one plain line — up to date or not — and says how the next version arrives.
+
+test('up to date: says so in words, names the version, and says the next one arrives on its own', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { behind: false, recommended_version: null, served_version: '1.24.1', update_channel: 'minor' }) });
+  await b.settle();
+  const html = b.panel();
+  assert.match(html, /dp-status dp-status--ok/, 'a status line, in the ok tone');
+  assert.match(html, /<strong>Up to date\.<\/strong>/);
+  assert.match(html, /1\.24\.1/);
+  assert.match(html, /merged work inside core 1\.24\.1 is live/);
+  assert.match(html, /arrives on its own/, 'the update rule moves it, so nothing needs pressing');
+  assert.match(html, /not live until a published version carries it/, 'and merged work after it is still waiting');
+});
+
+test('up to date on Stay put: says a newer version waits for a person, not that it arrives', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { behind: false, recommended_version: null, update_channel: 'pinned' }) });
+  await b.settle();
+  const html = b.panel();
+  assert.match(html, /<strong>Up to date\.<\/strong>/);
+  assert.doesNotMatch(html, /arrives on its own/);
+  assert.match(html, /waits until you change the update rule/);
+});
+
+test('behind: a plain "not up to date" line and ONE primary deploy-now button', async () => {
+  const b = boot({ controlPlane: preview('1', 'cloudbongos', { update_channel: 'patch' }) });
+  await b.settle();
+  const html = b.panel();
+  assert.match(html, /dp-status dp-status--behind/);
+  assert.match(html, /<strong>Not up to date\.<\/strong> Core <strong>1\.19\.871<\/strong> is published; this project still runs 1\.19\.800\./);
+  assert.match(html, /class="btn btn--primary" id="dp-preview-1">Deploy core 1\.19\.871 now<\/button>/);
+  assert.doesNotMatch(html, /See what would change/, 'the old two-word step label is gone');
+  assert.equal((html.match(/btn--primary/g) || []).length, 1, 'exactly one primary action');
+});
+
+test('the deploy-now button still leaves going live to a person: it opens the confirm, it moves nothing', async () => {
+  const b = boot();
+  await b.settle();
+  b.els.get('dp-preview-1')._on.click();
+  await b.settle();
+  assert.ok(b.posts.every((p) => p.body && p.body.dry_run === true), 'only the dry-run check is asked for');
+  assert.match(b.panel(), /id="dp-confirm-1"/, 'the person confirms the move themselves');
 });
 
 test('a box that did not answer is never rendered as up to date', async () => {

package/tests/genesis_home.mjs

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