@bongos/core 1.25.17 → 1.25.19

package/modules/lifecycle/first-read.js

@@ -19,8 +19,12 @@
 // position), and every filed ref is remembered (lifecycle_repo_map_filed), so a second
 // map that names the same goal or task again plans to file nothing for it.
 //
-// ROOM TO GROW. Unknown top-level keys are kept, not refused — task 1005281 adds a
-// `recommended_modules` section the same way, with no change to this version's shape.
+// ROOM TO GROW. Unknown top-level keys are kept, not refused, so a later section needs
+// no change to this version's shape. `recommended_modules` (task 1005281) is the first:
+// modules from THIS project's live list that would do a job better than what the code
+// has (first-read-catalog.js supplies the list; a key not on it is refused on submit).
+// A recommendation is a suggestion: accepting files a draft task to switch it on, and
+// dismissing records the no, so a re-run does not raise it again.
 //
 // Pure — no I/O. The DB half is first-read-db.js; the HTTP surface routes/first-read.js;
 // the CLI scripts/bongos/first-read.js; the Genesis step that hands out the prompt is
@@ -41,12 +45,13 @@ const LIMITS = Object.freeze({
   GOALS: 20,
   TASKS_PER_GOAL: 30,
   NEXT: 50,
+  MODULES: 10,
   BYTES: 60000,
 });
 const TASK_STATES = ['done', 'in_progress', 'not_started'];
 const NEXT_KINDS = ['error', 'mishap', 'gap'];
 // Top-level keys this version reads. Anything else is kept as-is for a later reader.
-const KNOWN_KEYS = ['schema', 'summary', 'goals', 'next'];
+const KNOWN_KEYS = ['schema', 'summary', 'goals', 'next', 'recommended_modules'];
 const UNSAFE_KEYS = ['__proto__', 'constructor', 'prototype'];
 // The goal a `next` item lands under when it names no goal of the map.
 const NEXT_GOAL = Object.freeze({
@@ -55,6 +60,13 @@ const NEXT_GOAL = Object.freeze({
   why: 'Errors, mishaps and gaps the first read-through of the repository found, not tied to one goal.',
 });
 
+// The goal an accepted module recommendation lands under.
+const MODULES_GOAL = Object.freeze({
+  ref: 'goal:modules-the-first-read-recommends',
+  title: 'Modules the first read-through recommends',
+  why: 'Modules from this project\'s own list that the first read-through of the repository found would do a job better than what the code has now.',
+});
+
 // slug(text) → a stable lower-case key: the same title always gives the same ref.
 function slug(text) {
   return String(text || '').toLowerCase().normalize('NFKD').replace(/[̀-ͯ]/g, '')
@@ -65,6 +77,7 @@ function slug(text) {
 const goalRef = (title) => `goal:${slug(title)}`;
 const taskRef = (goalTitle, title) => `task:${slug(goalTitle)}:${slug(title)}`;
 const nextRef = (title) => `next:${slug(title)}`;
+const moduleRef = (key) => `module:${key}`;
 
 // ── the prompt ───────────────────────────────────────────────────────────────
 
@@ -88,9 +101,24 @@ function exampleMap() {
   };
 }
 
-// firstReadPrompt({ cli }) → the full text the owner hands their own AI session. It is
-// also the Genesis step's description, so the hall's copy-prompt carries all of it.
-function firstReadPrompt({ cli = 'npx bongos' } = {}) {
+// The recommended_modules entry shape, shown in the prompt beside the example map.
+const MODULE_EXAMPLE = { module: '<a key from the module list>', found: 'What in the code is weak, in one or two sentences.', why: 'Why this module does that job better.', seen_at: ['src/billing/'] };
+
+// catalogText(catalog) → the module list as prompt lines, or a line saying there is none.
+function catalogText(catalog) {
+  if (!Array.isArray(catalog)) return '   (The module list could not be read. Leave "recommended_modules" out.)';
+  if (!catalog.length) return '   (This project has no modules left to switch on. Leave "recommended_modules" out.)';
+  return catalog.map((m) => `   - ${m.key}: ${m.title}. ${m.summary}`.trimEnd()).join('\n');
+}
+
+// firstReadPrompt({ cli, catalog }) → the full text the owner hands their own AI session.
+// Without a catalog it is the Genesis step's description (fixed text, so the hall's
+// copy-prompt carries all of it) and tells the session to fetch the live module list;
+// with one (`bongos first-read prompt`) the list is printed in.
+function firstReadPrompt({ cli = 'npx bongos', catalog } = {}) {
+  const modules = catalog === undefined
+    ? [`   Get the modules this project can switch on: ${cli} first-read catalog`]
+    : ['   The modules this project can switch on (key: name. what it does):', catalogText(catalog)];
   return [
     'First read-through of a project that already exists. You are the owner\'s own AI session, working on their computer, on their subscription. Bongos itself never reads this repository.',
     '',
@@ -101,10 +129,13 @@ function firstReadPrompt({ cli = 'npx bongos' } = {}) {
     '   - Every goal, task and next item has a short "why" (one or two sentences, in plain words) and "seen_at" (where you saw it: file paths, with a line number when it helps). Reasons and places only, never copied code.',
     '   Use exactly this shape:',
     JSON.stringify(exampleMap(), null, 2).split('\n').map((l) => '   ' + l).join('\n'),
+    '   - Optional "recommended_modules": compare what the code does with the modules below. Where a module would clearly do a job better than what is there (a billing system that keeps failing, say), add one entry: "module" (its key, exactly as listed), "found" (what in the code is weak), "why" (why the module is better) and "seen_at". Recommend only from the list, at most ' + LIMITS.MODULES + '. When nothing on it beats what the code already has, leave the section out: no recommendation is a good answer.',
+    '     Entry shape: ' + JSON.stringify(MODULE_EXAMPLE),
+    ...modules,
     `3. Check the file: ${cli} first-read check ${MAP_FILE}  — fix anything it lists and check again.`,
     `4. Send it to Bongos: ${cli} first-read submit ${MAP_FILE}  — this files nothing yet; it prints the map's number and every item's ref.`,
-    '5. Walk the owner through the map in plain words, goal by goal. Ask which items to accept: all of them, some of them, or none.',
-    `6. Only after the owner says yes, accept exactly what they chose: ${cli} first-read accept <map number> --all, or --items <ref>,<ref>. If they want none of it: ${cli} first-read reject <map number>. Never accept on your own. Accepted items become draft goals and tasks; nothing can be worked on until someone promotes it.`,
+    '5. Walk the owner through the map in plain words, goal by goal, then any recommended modules. Ask which items to accept: all of them, some of them, or none. Recommendations are suggestions; anything they say no to can be dismissed.',
+    `6. Only after the owner says yes, accept exactly what they chose: ${cli} first-read accept <map number> --all, or --items <ref>,<ref>. Items they turn down: ${cli} first-read dismiss <map number> --items <ref>,<ref> (a later read-through will not raise them again). If they want none of it: ${cli} first-read reject <map number>. Never accept or dismiss on your own. Accepted items become draft goals and tasks; nothing can be worked on until someone promotes it, and an accepted module is a to-do to switch it on, never switched on by itself.`,
     'Running the read-through again later is safe: anything already accepted is not filed twice.',
   ].join('\n');
 }
@@ -130,11 +161,14 @@ function seenAt(errors, where, v) {
   return out;
 }
 
-// validateRepoMap(raw) → { ok: true, map, items } | { ok: false, errors: [string] }
+// validateRepoMap(raw, { catalog }) → { ok: true, map, items } | { ok: false, errors }
 // `map` is the normalised map (unknown top-level keys kept verbatim); `items` is the flat
-// review list: [{ ref, type: 'goal'|'task'|'next', title, why, seen_at, status?, kind?,
-// goal_ref }]. Every error names the field it is about, so a session can fix and retry.
-function validateRepoMap(raw) {
+// review list: [{ ref, type: 'goal'|'task'|'next'|'module', title, why, seen_at, status?,
+// kind?, found?, module?, goal_ref }]. Every error names the field it is about, so a
+// session can fix and retry. `catalog` ([{ key, title }], or null when unreadable) is
+// given on SUBMIT: every recommended key must be on it, and the title is the catalog's.
+// It is left out when re-reading a stored map, which was checked when it came in.
+function validateRepoMap(raw, { catalog } = {}) {
   const errors = [];
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return { ok: false, errors: ['the map must be a JSON object'] };
   if (raw.schema !== SCHEMA) errors.push(`schema must be "${SCHEMA}"`);
@@ -143,11 +177,14 @@ function validateRepoMap(raw) {
   const summary = text(errors, 'summary', raw.summary, LIMITS.SUMMARY);
   const goalsIn = raw.goals == null ? [] : raw.goals;
   const nextIn = raw.next == null ? [] : raw.next;
+  const modsIn = raw.recommended_modules == null ? [] : raw.recommended_modules;
   if (!Array.isArray(goalsIn)) errors.push('goals must be a list');
   if (!Array.isArray(nextIn)) errors.push('next must be a list');
+  if (!Array.isArray(modsIn)) errors.push('recommended_modules must be a list');
   if (errors.length) return { ok: false, errors };
   if (goalsIn.length > LIMITS.GOALS) errors.push(`goals lists more than ${LIMITS.GOALS}`);
   if (nextIn.length > LIMITS.NEXT) errors.push(`next lists more than ${LIMITS.NEXT}`);
+  if (modsIn.length > LIMITS.MODULES) errors.push(`recommended_modules lists more than ${LIMITS.MODULES}`);
   if (!goalsIn.length && !nextIn.length) errors.push('the map has no goals and nothing next — list at least one');
 
   const items = [];
@@ -201,9 +238,33 @@ function validateRepoMap(raw) {
     if (ref && claimRef(ref, w)) items.push({ ref, type: 'next', title, why, seen_at: where, kind, goal_ref: gref });
     next.push({ title, kind, goal, why, seen_at: where });
   });
+  const known = Array.isArray(catalog) ? new Map(catalog.map((m) => [m.key, m])) : null;
+  const recommended = [];
+  modsIn.slice(0, LIMITS.MODULES).forEach((m, mi) => {
+    const w = `recommended_modules[${mi}]`;
+    if (!m || typeof m !== 'object' || Array.isArray(m)) { errors.push(`${w} must be an object`); return; }
+    const key = text(errors, `${w}.module`, m.module, LIMITS.TITLE);
+    const found = text(errors, `${w}.found`, m.found, LIMITS.WHY);
+    const why = text(errors, `${w}.why`, m.why, LIMITS.WHY);
+    const where = seenAt(errors, w, m.seen_at);
+    if (!key) return;
+    if (catalog !== undefined && !(known && known.has(key))) {
+      errors.push(known
+        ? `${w}.module "${key}" is not a module this project can switch on — use a key from the module list (first-read catalog)`
+        : `${w}.module: the module list could not be read here, so no module can be recommended — leave recommended_modules out`);
+      return;
+    }
+    const title = known ? known.get(key).title : (text([], '', m.title, LIMITS.TITLE) || key);
+    const ref = moduleRef(key);
+    if (seen.has(ref)) { errors.push(`${w}.module repeats a module already recommended`); return; }
+    seen.add(ref);
+    items.push({ ref, type: 'module', module: key, title, found, why, seen_at: where, goal_ref: MODULES_GOAL.ref });
+    recommended.push({ module: key, title, found, why, seen_at: where });
+  });
   if (errors.length) return { ok: false, errors };
 
   const map = { schema: SCHEMA, summary, goals, next };
+  if (recommended.length) map.recommended_modules = recommended;
   // Forward-compatible: a later section (task 1005281's recommended_modules) rides along.
   // Prototype-shaped keys are never copied (CWE-1321): a later section is plain data.
   for (const [k, v] of Object.entries(raw)) if (!KNOWN_KEYS.includes(k) && !UNSAFE_KEYS.includes(k)) map[k] = v;
@@ -213,19 +274,24 @@ function validateRepoMap(raw) {
 // ── acceptance ───────────────────────────────────────────────────────────────
 
 function describe(item, mapId) {
-  const lines = [item.why, '', `Seen at: ${item.seen_at.join(', ')}`];
+  const lines = item.type === 'module'
+    ? [`Found: ${item.found}`, '', `Why the ${item.title} module: ${item.why}`, '', `Seen at: ${item.seen_at.join(', ')}`,
+      'Switching it on is done on the Modules page by whoever may turn modules on; this task is the reminder.']
+    : [item.why, '', `Seen at: ${item.seen_at.join(', ')}`];
   if (item.status && item.status !== 'not_started') lines.push(`Status when read: ${item.status.replace('_', ' ')}`);
   lines.push('', `From the first read-through of the repository (map ${mapId}, ${item.ref}). A draft: promote it when it is right.`);
   return lines.join('\n');
 }
 
-// planAcceptance({ items, mapId, select, filedRefs }) → { goals, tasks, skipped, unknown }
-//   select    'all' | [ref] — what the owner said yes to. Nothing else is planned.
-//   filedRefs Set of refs already filed by an earlier accept (any map) — never filed again.
+// planAcceptance({ items, mapId, select, filedRefs, dismissedRefs }) → { goals, tasks, skipped, unknown }
+//   select        'all' | [ref] — what the owner said yes to. Nothing else is planned.
+//   filedRefs     Set of refs already filed by an earlier accept (any map) — never filed again.
+//   dismissedRefs Set of refs the owner said no to before — 'all' skips them; naming one
+//                 explicitly files it (the owner changed their mind).
 // A chosen task or next item brings its goal along (a task needs a home); a goal that is
 // already filed is reused by ref. A task whose status is `done` is history, not work:
 // it is shown in review but never filed.
-function planAcceptance({ items, mapId, select, filedRefs = new Set() }) {
+function planAcceptance({ items, mapId, select, filedRefs = new Set(), dismissedRefs = new Set() }) {
   const byRef = new Map(items.map((i) => [i.ref, i]));
   const wanted = select === 'all' ? items.map((i) => i.ref) : [...new Set(Array.isArray(select) ? select : [])];
   const unknown = wanted.filter((r) => !byRef.has(r));
@@ -234,10 +300,8 @@ function planAcceptance({ items, mapId, select, filedRefs = new Set() }) {
   const skipped = [];
   const needGoal = (ref) => {
     if (!ref || filedRefs.has(ref) || goals.has(ref)) return;
-    if (ref === NEXT_GOAL.ref) {
-      goals.set(ref, { ref, title: NEXT_GOAL.title, description: NEXT_GOAL.why });
-      return;
-    }
+    const fixed = ref === NEXT_GOAL.ref ? NEXT_GOAL : ref === MODULES_GOAL.ref ? MODULES_GOAL : null;
+    if (fixed) { goals.set(ref, { ref, title: fixed.title, description: fixed.why }); return; }
     const g = byRef.get(ref);
     if (g) goals.set(ref, { ref, title: g.title, description: describe(g, mapId) });
   };
@@ -245,13 +309,14 @@ function planAcceptance({ items, mapId, select, filedRefs = new Set() }) {
     const it = byRef.get(ref);
     if (!it) continue;
     if (filedRefs.has(ref)) { skipped.push({ ref, reason: 'already_filed' }); continue; }
+    if (select === 'all' && dismissedRefs.has(ref)) { skipped.push({ ref, reason: 'dismissed' }); continue; }
     if (it.type === 'goal') { needGoal(ref); continue; }
     if (it.type === 'task' && it.status === 'done') { skipped.push({ ref, reason: 'already_done' }); continue; }
     needGoal(it.goal_ref);
     tasks.push({
       ref,
       goalRef: it.goal_ref,
-      title: it.title,
+      title: it.type === 'module' ? `Switch on the ${it.title} module` : it.title,
       description: describe(it, mapId),
       kind: it.type === 'next' && it.kind !== 'gap' ? 'bug' : 'feature',
     });
@@ -260,6 +325,6 @@ function planAcceptance({ items, mapId, select, filedRefs = new Set() }) {
 }
 
 module.exports = {
-  SCHEMA, MAP_FILE, LIMITS, NEXT_GOAL,
+  SCHEMA, MAP_FILE, LIMITS, NEXT_GOAL, MODULES_GOAL,
   exampleMap, firstReadPrompt, validateRepoMap, planAcceptance,
 };

package/modules/lifecycle/migrations/lifecycle_023_repo_map_dismissed.sql

@@ -0,0 +1,19 @@
+-- lifecycle_023_repo_map_dismissed.sql — the owner's "no" to an item of a repository
+-- map is remembered too (task 1005281, goal 1000106).
+--
+-- A module recommendation is a suggestion the owner accepts OR dismisses. A dismissed
+-- item is a row in lifecycle_repo_map_filed with kind 'dismissed' and no entity, so a
+-- later read-through's "accept all" does not raise it again. Naming it explicitly later
+-- still files it: the accept upserts over a 'dismissed' row only, never over a filed one.
+-- Works for every item type, not only modules.
+
+ALTER TABLE lifecycle_repo_map_filed ALTER COLUMN entity_id DROP NOT NULL;
+
+ALTER TABLE lifecycle_repo_map_filed DROP CONSTRAINT IF EXISTS lifecycle_repo_map_filed_kind_chk;
+ALTER TABLE lifecycle_repo_map_filed ADD CONSTRAINT lifecycle_repo_map_filed_kind_chk
+  CHECK (kind IN ('goal', 'task', 'dismissed'));
+
+-- A filed item points at what it became; a dismissed one points at nothing.
+ALTER TABLE lifecycle_repo_map_filed DROP CONSTRAINT IF EXISTS lifecycle_repo_map_filed_entity_chk;
+ALTER TABLE lifecycle_repo_map_filed ADD CONSTRAINT lifecycle_repo_map_filed_entity_chk
+  CHECK ((kind = 'dismissed') = (entity_id IS NULL));

package/modules/lifecycle/routes/first-read.js

@@ -13,23 +13,34 @@ const express = require('express');
 const api = require('../../../src/module-api');
 const fr = require('../first-read');
 const store = require('../first-read-db');
+const modulesCatalog = require('../first-read-catalog');
 
 const { asyncHandler, parseId, validateOrRespond } = api;
 
 module.exports = function buildFirstReadRouter() {
   const router = express.Router();
 
-  // rank: any-builder — the prompt and the shape are instructions, not project data.
-  router.get('/first-read/prompt', api.requireBuilder, (req, res) => {
-    res.json({ schema: fr.SCHEMA, file: fr.MAP_FILE, prompt: fr.firstReadPrompt(), example: fr.exampleMap(), limits: fr.LIMITS });
-  });
+  // rank: any-builder — the prompt and the shape are instructions, not project data. The
+  // prompt carries the live module list (task 1005281), so a session recommends from it.
+  router.get('/first-read/prompt', api.requireBuilder, asyncHandler('GET /first-read/prompt', async (req, res) => {
+    const catalog = await modulesCatalog.switchOnCatalog();
+    res.json({ schema: fr.SCHEMA, file: fr.MAP_FILE, prompt: fr.firstReadPrompt({ catalog }), example: fr.exampleMap(), limits: fr.LIMITS, catalog });
+  }, { errorCode: 'first_read_prompt_failed' }));
+
+  // rank: any-builder — the modules this project can switch on, the only ones a map may
+  // recommend. `available: false` when the list cannot be read here.
+  router.get('/first-read/catalog', api.requireBuilder, asyncHandler('GET /first-read/catalog', async (req, res) => {
+    const catalog = await modulesCatalog.switchOnCatalog();
+    res.json({ available: Array.isArray(catalog), modules: catalog || [] });
+  }, { errorCode: 'first_read_catalog_failed' }));
 
   // rank: goal.create — a map is a planning proposal for this project. Stores it
   // pending; files nothing. A malformed map is refused with every error named.
   router.post('/first-read/maps', api.requireBuilder, api.requirePermission('goal.create'), asyncHandler('POST /first-read/maps', async (req, res) => {
     // The envelope is checked here; the map inside it by first-read.js, which names every error.
     if (validateOrRespond(req, res, { map: { required: true, type: 'object' } })) return undefined;
-    const out = await store.submitMap({ raw: req.body.map, builderId: req.builder.id });
+    const catalog = await modulesCatalog.switchOnCatalog();
+    const out = await store.submitMap({ raw: req.body.map, builderId: req.builder.id, catalog });
     if (!out.ok) return res.fail('invalid_map', 400, { errors: out.errors });
     return res.status(201).json({
       map_id: out.map_id, status: out.status,
@@ -66,6 +77,17 @@ module.exports = function buildFirstReadRouter() {
       return res.json(out);
     }, { errorCode: 'first_read_accept_failed' }));
 
+  // rank: goal.create — the owner's no to named items (a module recommendation, usually).
+  // Files nothing; a later "accept all" passes them by.
+  router.post('/first-read/maps/:id/dismiss', api.requireBuilder, api.requirePermission('goal.create'), asyncHandler('POST /first-read/maps/:id/dismiss', async (req, res) => {
+    const mapId = parseId(req, res, { positiveInt: true });
+    if (mapId == null) return undefined;
+    if (validateOrRespond(req, res, { items: { required: true, type: 'array', itemsType: 'string', maxItems: 500 } })) return undefined;
+    const out = await store.dismissItems({ mapId, refs: req.body.items, builderId: req.builder.id });
+    if (!out.ok) { const { code, status, ...rest } = out; return res.fail(code, status, rest); }
+    return res.json(out);
+  }, { errorCode: 'first_read_dismiss_failed' }));
+
   // rank: goal.create — the owner's no. Files nothing.
   router.post('/first-read/maps/:id/reject', api.requireBuilder, api.requirePermission('goal.create'), asyncHandler('POST /first-read/maps/:id/reject', async (req, res) => {
     const mapId = parseId(req, res, { positiveInt: true });

package/modules/onboarding/genesis-home.js

@@ -27,6 +27,15 @@
 // as `board.genesis_stage.passed` (the route factory listens), and every read
 // reconciles again, so a missed nudge cannot strand a stage.
 //
+// WITH NO BOARD ROOM (task 1005115; owner, 2026-11-07: "I would automatically proceed").
+// A project without the government module has nobody to put a stage to, so a stage
+// whose tasks are all finished moves on BY ITSELF — reconcile does it, on every read and
+// on every ship — and the view says so (`moved`: from, to, what woke). There is no
+// close button to press on that path. Where there IS a Board Room the sitting stays:
+// a team deciding together is not the same act as a solo founder acknowledging their
+// own work. Either way, each stage leaves a DOCUMENT behind (genesis-work.js
+// documentOf) that the founder can edit at any time without reopening the stage.
+//
 // THE BOUNDARY. Core through ../../src/module-api.js; the lifecycle and government
 // modules through their ports only (resolveOptional), never a require.
 
@@ -158,7 +167,11 @@ function taskState(t) {
 // task, named in `waits_on`) or 'open' — decided here, never re-derived in a browser.
 //   board   { stage: genesisStageStatus row } or {}
 //   stageAt { stage: ISO } — when each stage began, for its due date
-function shapeGenesis({ mode, plan, tasks = {}, board = {}, stageAt = {} }) {
+//   boardRoom  false on a project with no government module: stages advance by
+//              themselves, so nothing is ever "closable" and the alive door opens on
+//              finished legislation tasks (task 1005115)
+//   documents  { stage: { title, filled, updated_at, editable } } from genesis-work.js
+function shapeGenesis({ mode, plan, tasks = {}, board = {}, stageAt = {}, boardRoom = true, documents = {} }) {
   const at = fm.STAGES.indexOf(mode.stage);
   const stages = PROPER.map((key) => {
     const info = STAGE_INFO[key];
@@ -190,7 +203,10 @@ function shapeGenesis({ mode, plan, tasks = {}, board = {}, stageAt = {} }) {
       total: list.length,
       // task 1005199: this stage (the current one or any later one) can be put to
       // the Board Room now — its tasks are all finished and it is not already there.
-      can_close: at >= 1 && idx >= at && allFinished && !onBoard,
+      can_close: boardRoom && at >= 1 && idx >= at && allFinished && !onBoard,
+      // What this stage left behind (task 1005115): null where the store is not read.
+      document: documents[key] || null,
+      all_finished: allFinished,
       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 || [],
@@ -200,6 +216,14 @@ function shapeGenesis({ mode, plan, tasks = {}, board = {}, stageAt = {} }) {
   const now = stages.find((s) => s.state === 'now') || null;
   const sitting = now && now.board && now.board.state === 'sitting';
   const passed = now && now.board && now.board.state === 'passed';
+  // The last move, so a presentation can say plainly that it happened and what opened
+  // (task 1005115). Derived from the stage stamps, never stored twice.
+  const prev = at >= 2 ? fm.STAGES[at - 1] : null;
+  const moved = prev && stageAt[mode.stage] ? {
+    from: prev, to: mode.stage, at: stageAt[mode.stage],
+    how: boardRoom ? 'board_passed' : 'tasks_finished',
+    opened: fm.WAKES[prev] || [],
+  } : null;
   return {
     stage: mode.stage,
     stage_number: mode.stage_number,
@@ -211,9 +235,12 @@ function shapeGenesis({ mode, plan, tasks = {}, board = {}, stageAt = {} }) {
     demo: plan && plan.demo ? plan.demo : null,
     stages,
     // The close door: every task of the current stage finished, and not already sitting.
-    can_close: !!(now && now.total > 0 && now.finished === now.total && !sitting && !passed),
-    // Alive: the last stage has passed its sitting.
-    can_come_alive: !!(now && now.key === 'legislation' && passed),
+    can_close: !!(boardRoom && now && now.total > 0 && now.finished === now.total && !sitting && !passed),
+    // Alive: the last stage has passed its sitting — or, with no Board Room, its tasks
+    // are all finished.
+    can_come_alive: !!(now && now.key === 'legislation' && (boardRoom ? passed : now.total > 0 && now.finished === now.total)),
+    board_room: boardRoom,
+    moved,
   };
 }
 
@@ -226,9 +253,18 @@ function seams(deps = {}) {
     set: deps.setSetting || api.projectSettings.set,
     lifecycle: deps.lifecycle !== undefined ? deps.lifecycle : api.resolveOptional('lifecycle.kickoffSeed'),
     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(),
     now: deps.now,
   };
 }
+
+// hasBoardRoom(gov) — can a stage be put to a sitting at all? Without one a finished
+// stage advances by itself (task 1005115).
+const hasBoardRoom = (gov) => !!(gov && (typeof gov.closeGenesisStage === 'function'
+  || typeof gov.openGenesisStageClose === 'function'));
+const allDone = (list) => !!(list && list.length && list.every((t) => FINISHED.includes(t.status)));
 const modeDeps = (s) => ({ getSetting: s.get, setSetting: s.set, government: s.government, now: s.now });
 
 async function boardByStage(gov) {
@@ -245,6 +281,15 @@ async function boardByStage(gov) {
 async function reconcile(s) {
   let mode = await fm.foundingModeFor(modeDeps(s));
   if (!mode || !PROPER.includes(mode.stage) || mode.stage === 'legislation') return mode;
+  if (!hasBoardRoom(s.government)) {
+    // No Board Room: finished work IS the decision (task 1005115). Move past every
+    // stage whose tasks are all finished, in order; legislation waits for the alive door.
+    const all = s.lifecycle && typeof s.lifecycle.genesisTasks === 'function' ? await s.lifecycle.genesisTasks() : {};
+    while (mode && PROPER.includes(mode.stage) && mode.stage !== 'legislation' && allDone(all[mode.stage])) {
+      mode = await fm.setFoundingMode({ stage: fm.STAGES[fm.STAGES.indexOf(mode.stage) + 1] }, null, modeDeps(s));
+    }
+    return mode;
+  }
   const board = await boardByStage(s.government);
   while (mode && PROPER.includes(mode.stage) && mode.stage !== 'legislation'
     && board[mode.stage] && board[mode.stage].state === 'passed') {
@@ -268,7 +313,11 @@ async function readGenesis(deps = {}) {
     const row = await s.get(fm.stageAtKey(key));
     if (row && row.value) stageAt[key] = row.value;
   }
-  return shapeGenesis({ mode, plan, tasks, board, stageAt });
+  let documents = {};
+  if (typeof s.documents === 'function') {
+    try { documents = (await s.documents()) || {}; } catch (_) { documents = {}; } // the home still renders without them
+  }
+  return shapeGenesis({ mode, plan, tasks, board, stageAt, boardRoom: hasBoardRoom(s.government), documents });
 }
 
 // startFounding — a brand-new project enters genesis (founding-birth.js calls this once
@@ -403,6 +452,13 @@ async function closeStage(stageKey, builderId, deps = {}) {
   // stage's pass waits for the earlier ones. A stage already behind, or the decide
   // pre-stage, is still refused.
   if (!PROPER.includes(stageKey)) return { ok: false, reason: 'unknown_stage' };
+  // No Board Room (task 1005115): the stage already moved on by itself when its tasks
+  // finished, so asking to close it again is answered with what happened, not refused.
+  if (!hasBoardRoom(s.government) && PROPER.includes(mode.stage)
+    && fm.STAGES.indexOf(stageKey) < fm.STAGES.indexOf(mode.stage)) {
+    // next_stage is where the project IS now, which may be several stages on.
+    return { ok: true, closed: true, stage: stageKey, next_stage: mode.stage, item_id: null, confirm: null, already: true };
+  }
   if (!PROPER.includes(mode.stage) || fm.STAGES.indexOf(stageKey) < fm.STAGES.indexOf(mode.stage)) {
     return { ok: false, reason: 'not_current_stage', stage: mode.stage };
   }
@@ -546,7 +602,12 @@ async function putFinishedStages(deps = {}) {
 // stage; on a project that is not founding this costs the one genesis.enabled read.
 // Best-effort: the founder's own close button is still there if this misses.
 async function onTaskShipped(deps = {}) {
-  try { return await putFinishedStages(deps); } catch (_) { return []; }
+  try {
+    const s = seams(deps);
+    // No Board Room: the ship that finishes a stage moves the project on (task 1005115).
+    if (!hasBoardRoom(s.government)) { await reconcile(s); return []; }
+    return await putFinishedStages(deps);
+  } catch (_) { return []; }
 }
 
 module.exports = {