@bongos/core 1.25.19 → 1.25.20

package/modules/public-landing/public/projects.html

@@ -1579,6 +1579,8 @@ summary{min-height:24px;padding:3px 0;}
                 <h2 id="p1-h"><span class="n">01</span>Your project</h2>
                 <!-- auto-fill: the answers this account gave on its most recent project -->
                 <p class="fillOffer" id="physFillOffer" hidden><button type="button" class="linklike" id="physFromAccount">Fill these in from my last project</button></p>
+                <!-- the guide's answers (task 1005274): shown only when this page filled itself in from the plan -->
+                <p class="fillOffer hint" id="guideFill" hidden>Filled in from your talk with the guide. Change anything you like. <a id="guideFileLink" href="#" download="PROJECT-HANDOFF.md">Download the plan for your AI</a></p>
                 <!-- the demo route (task 1004420, BV2.PS09): opened in place at the top of part
                      01 by the small link under the heading; the rest of the page is unchanged
                      and marked "demo" (D9). The fit check is a copy of modules/provisioning/demo.js
@@ -5213,6 +5215,77 @@ summary{min-height:24px;padding:3px 0;}
     });
     paintTeam(state.teamShape || null);
 
+    /* ── the guide's answers (task 1005274) ──
+       A founder who talked with the start-a-project guide (modules/front-door-guide) is
+       never asked the same thing twice. This browser holds their chat in localStorage
+       (the landing's guide-scene.js writes it); once they are signed in, the chat moves
+       onto their account (POST …/attach) and its plan fills in what it covers, and ONLY
+       what is still unanswered: the kind, the sentence, the extras. The name stays the
+       founder's (the plan has none). Every field stays the ordinary control it always
+       was, so each answer is editable. The create then says from_guide, and the hub
+       carries the plan's scope answers and the hand-off file into the new project
+       (modules/provisioning/guide-handoff.js). No chat in this browser: nothing is read
+       and nothing changes. */
+    var GUIDE_KEY = 'cb-front-door-guide';
+    var guideAsked = false;
+    function guideChat() {
+      try {
+        if (!(window.__MODULES__ && window.__MODULES__.enabled && window.__MODULES__.enabled['front-door-guide'])) return null;
+        var g = JSON.parse(localStorage.getItem(GUIDE_KEY) || 'null');
+        return g && g.id && g.token ? g : null;
+      } catch (e) { return null; }
+    }
+    /* applyGuidePlan(plan) — fills the unanswered fields from a plan; returns what it filled. */
+    function applyGuidePlan(plan) {
+      var filled = [];
+      if (!plan || typeof plan !== 'object') return filled;
+      if (!state.projType && plan.project_type && root.querySelector('#typeCards .tpill[data-type="' + plan.project_type + '"]')) {
+        state.projType = plan.project_type; filled.push('type');
+      }
+      if (!String(state.description || '').trim() && typeof plan.summary === 'string' && plan.summary.trim()) {
+        state.description = plan.summary.trim().slice(0, 600); filled.push('description');
+      }
+      if (state.modules === null && Array.isArray(plan.modules) && plan.modules.length) {
+        state.modules = plan.modules.map(function (m) { return m && m.key; }).filter(function (k) { return typeof k === 'string' && k; });
+        filled.push('modules');
+      }
+      return filled;
+    }
+    function paintGuideFill() {
+      var note = $('guideFill');
+      if (!note) return;
+      note.hidden = !state.fromGuide;
+      $('guideFileLink').href = API + '/front-door-guide/mine/handoff.md?name=' + encodeURIComponent(String(state.name || '').trim());
+    }
+    function guidePrefill() {
+      if (guideAsked || !me) return;
+      var g = guideChat();
+      if (!g) return;
+      guideAsked = true;
+      fetch(API + '/front-door-guide/conversations/' + encodeURIComponent(g.id) + '/attach', {
+        method: 'POST', credentials: 'same-origin',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ token: g.token })
+      }).catch(function () { return null; }).then(function () {
+        return fetch(API + '/front-door-guide/mine', { credentials: 'same-origin' });
+      }).then(function (res) {
+        return res && res.ok ? res.json() : null;
+      }).then(function (data) {
+        var plan = data && data.conversation && data.conversation.plan;
+        if (!plan) return;
+        applyGuidePlan(plan);
+        state.fromGuide = true;
+        saveDraft();
+        paintType(state.projType || null);
+        $('f-desc').value = state.description || '';
+        renderModules();
+        paintSetup();
+        paintCreate();
+        paintGuideFill();
+      }).catch(function () { /* the guide is a convenience: the page works without it */ });
+    }
+    paintGuideFill();
+
     /* ── the module picker (task 1002339, BV1.R20) ──
        ONE public read gives the panel both halves it needs: `optional` is the
        catalog it renders, `bundles` is what each project type preselects
@@ -6933,6 +7006,9 @@ summary{min-height:24px;padding:3px 0;}
                has commits rejects as unrelated history. state.mode already tracked
                greenfield|adopt for the UI — it has to reach the server too. */
             onboard_mode: state.mode === 'adopt' ? 'adopt' : 'greenfield',
+            /* the page filled itself in from the guide's plan (task 1005274): the hub
+               carries the scope answers and the hand-off file into the new project */
+            from_guide: state.fromGuide ? true : undefined,
             /* the ship row (task 1004629): becomes the new project's own ship mode */
             ship_mode: shipModeChoice()
           })
@@ -6963,6 +7039,8 @@ summary{min-height:24px;padding:3px 0;}
             demo_invites: state.demo && state.demo.invites && state.demo.invites.length ? state.demo.invites.slice() : undefined
           }));
           sessionStorage.removeItem(DRAFT_KEY);
+          /* the guide's chat has done its job: a second project must not fill in from it */
+          if (state.fromGuide) localStorage.removeItem(GUIDE_KEY);
         } catch (e) {}
         createBusy = false;
         renderDone();
@@ -8568,6 +8646,7 @@ summary{min-height:24px;padding:3px 0;}
         $('f-owner').value = state.owner;
         saveDraft();
       }
+      guidePrefill();
       if (currentView === 'new') enter(false);
     }
 

package/package-lock.json

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

package/package.json

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

@@ -11858,5 +11858,15 @@
       "id": "1005115",
       "text": "A solo founder's Genesis now moves to the next stage by itself when a stage's work is finished, and every stage leaves a named document (the scope, the strategy...) they can come back and edit any time."
     }
+  ],
+  "1.25.20": [
+    {
+      "id": "1005112",
+      "text": "While a new project is being set up, the menu now shows only the rooms that are open, a room that just opened is highlighted, a closed room can't be reached by its address, and the later setup stages say what finishing them ea"
+    },
+    {
+      "id": "1005274",
+      "text": "A founder who planned their project with the guide now finds the project form and the first Genesis question already filled in, plus a plan file for their own AI."
+    }
   ]
 }

package/src/bongos/founding-page-gate.js

@@ -0,0 +1,67 @@
+'use strict';
+
+// src/bongos/founding-page-gate.js — A SLEEPING ROOM IS NOT REACHABLE BY URL (task 1005112).
+//
+// While a project is being founded, the hall's sidebar holds only the rooms its genesis
+// stages have opened. Hiding a room and refusing its page are ONE change: a room nobody
+// can see but anyone can type the address of would be a wall the product only claims to
+// have. So this is the page half. It asks the server's own answer, the onboarding port's
+// foundingModeFor() (the same read /me carries as founding_mode.asleep, keyed by the
+// sidebar's room ids), and never a browser's opinion (ADR 0016).
+//
+// A sleeping room's page answers with a redirect home carrying ?asleep=<room>&opens=<stage>,
+// where the shell says what the room is and which stage opens it, instead of a dead end.
+//
+// What it never touches: a project that is not founding (foundingModeFor answers null,
+// and the page is served exactly as before), a room that is awake, the Primer and the
+// Board Room (never asleep), and every page that is not one of the rooms below. An
+// unreadable founding state is null too, so a failure opens the page, never shuts it:
+// founding-mode.js fails closed to OFF for the same reason (a hall wrongly asleep would
+// hijack it). Rooms are keyed by the sidebar id, and each room's page slug IS that id.
+
+const path = require('path');
+const seams = require('../module-seams');
+
+// The rooms a genesis stage can put to sleep (founding-mode.js WAKES + WAKES_WHEN_ALIVE),
+// by page slug. tests/founding_page_gate.mjs holds this list to that map.
+const ROOM_PAGE_RE = /^\/builders\/(work|goals|goal-map|collab|roster)(?:\.html)?\/?$/;
+
+// asleepRoomFor(room, founding) — PURE. The room id when that room sleeps under this
+// founding answer, else null.
+function asleepRoomFor(room, founding) {
+  if (!founding || founding.active !== true || !founding.asleep || typeof founding.asleep !== 'object') return null;
+  return Object.prototype.hasOwnProperty.call(founding.asleep, room) ? room : null;
+}
+
+// readFounding() — the server's answer, or null on any failure (fail open: OFF).
+async function readFounding(resolve = seams.resolveOptional) {
+  try {
+    const onboarding = resolve('onboarding');
+    if (!onboarding || typeof onboarding.foundingModeFor !== 'function') return null;
+    return await onboarding.foundingModeFor();
+  } catch (_) {
+    return null;
+  }
+}
+
+// foundingPageGate({ skip, isBuildersHost, read }) — the Express middleware. `skip(req)`
+// is the caller's module-surface test; `read` is injectable for tests. The founding read
+// is made only for one of the five room pages, so every other request pays nothing.
+function foundingPageGate({ skip = () => false, isBuildersHost = () => false, read = readFounding } = {}) {
+  return async function gate(req, res, next) {
+    if (skip(req) || !String(req.path || '').startsWith('/builders')) return next();
+    const m = ROOM_PAGE_RE.exec(path.posix.normalize(req.path));
+    if (!m) return next();
+    let founding = null;
+    try { founding = await read(); } catch (_) { founding = null; } // fail open: OFF
+    const room = asleepRoomFor(m[1], founding);
+    if (!room) return next();
+    const opens = String(founding.asleep[room] || '');
+    res.set('Cache-Control', 'no-store');
+    return res.redirect(302, `${isBuildersHost(req) ? '' : '/builders'}/?asleep=${encodeURIComponent(room)}`
+      + (/^[a-z]{1,20}$/.test(opens) ? `&opens=${opens}` : ''));
+  };
+}
+
+// One export: the pure parts are proven through it (tests/founding_page_gate.mjs).
+module.exports = { foundingPageGate };

package/src/bongos/serve-internal.js

@@ -50,6 +50,7 @@ const { linkPreviewTags } = require('../link-preview');
 const { prelaunchGate } = require('./prelaunch-gate');
 const { platformVisibilityGate } = require('./platform-visibility-gate');
 const { schemaPending } = require('./schema-lag');
+const { foundingPageGate } = require('./founding-page-gate');
 const { clientModules, isModuleEnabled } = require('../modules');
 const { hallWidgetScripts, moduleWebSurfaces } = require('../module-loader/loader');
 const { resolveCoreRoot, resolveDocsRoot, resolveInstanceRoot, resolveEnv } = require('../instance-config');
@@ -1353,6 +1354,8 @@ function mountInternalSurfaces(app) {
     }
     next();
   });
+  // task 1005112: a founding project's sleeping room is refused by URL, after sign-in.
+  app.use(foundingPageGate({ skip: isModuleSurfaceHost, isBuildersHost }));
 
   // task 1965: the read-only Task Board (/board, task 751) was consolidated into
   // the Work page (/work) — the hall keeps one task-listing surface. 301 old

package/src/branding.js

@@ -112,6 +112,10 @@ const ENV_OVERRIDES = [
   // The ship mode the founder picked in the wizard (task 1004629), empty when none was.
   // resolveShipMode reads it only while project_settings['ship.mode'] is unset.
   ['SHIP_MODE', ['founding', 'shipMode']],
+  // The start-a-project guide's hand-off (task 1005274, modules/provisioning/guide-handoff.js): base64url
+  // JSON { scope, markdown }, empty when the founder never used the guide. modules/onboarding/guide-handoff.js
+  // writes it once: the scope answers as carried over, and the hand-off file. SERVER-ONLY, like the birth.
+  ['GUIDE_HANDOFF', ['founding', 'guideHandoff']],
 ];
 
 const isObj = (v) => v && typeof v === 'object' && !Array.isArray(v);

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

@@ -143,7 +143,8 @@ function makeHall() {
     documentElement: root,
     createElement: (t) => new El(t),
     querySelector: (sel) => (sel === '.app-body' ? appBody : null),
-    querySelectorAll: (sel) => (sel === '#app-sidebar .nav-item--asleep' ? nav.filter((a) => a.classList.contains('nav-item--asleep')) : []),
+    querySelectorAll: (sel) => (sel === '#app-sidebar .nav-item--asleep, #app-sidebar .nav-item--arrived'
+      ? nav.filter((a) => a.classList.contains('nav-item--asleep') || a.classList.contains('nav-item--arrived')) : []),
     getElementById: (id) => nav.find((a) => a.id === id) || appBody.children.find((c) => c.id === id) || null,
   };
   return { document, nav, appBody, root };
@@ -164,12 +165,12 @@ function sliceFn(name) {
   assert.ok(start > -1 && end > start, name + ' was located in shell.js');
   return SHELL.slice(start, end + 4);
 }
-function loadApplyFounding(document, access, brand = { identity: { productName: 'Kestrel' } }) {
+function loadApplyFounding(document, access, brand = { identity: { productName: 'Kestrel' } }, storage = null) {
   const wakeStart = SHELL.indexOf('  var WAKE_TEXT = {');
   const wakeEnd = SHELL.indexOf('};', wakeStart) + 2;
   assert.ok(wakeStart > -1, 'WAKE_TEXT was located in shell.js');
   const src = [SHELL.slice(wakeStart, wakeEnd), sliceEsc(), sliceFn('applyFounding')].join('\n');
-  return new Function('document', 'brand', 'access', 'window', `${src}\nreturn applyFounding;`)(document, brand, access, { OTB: realOTB() });
+  return new Function('document', 'brand', 'access', 'window', `${src}\nreturn applyFounding;`)(document, brand, access, { OTB: realOTB(), localStorage: storage || undefined });
 }
 
 const snapshot = (h) => JSON.stringify({
@@ -213,8 +214,8 @@ test('founding ON: the band above the topbar, and the rooms the server named asl
   const byId = (id) => h.nav.find((a) => a.id === 'nav-' + id);
   assert.ok(!byId('goals').classList.contains('nav-item--asleep'), 'scope is behind: goals is awake');
   assert.ok(byId('work').classList.contains('nav-item--asleep'), 'strategize is current: tasks still sleeps');
-  assert.equal(byId('work').children[0].textContent, 'opens after strategy', 'a sentence, never a raw slug');
-  assert.equal(byId('collab').children[0].textContent, 'opens when alive');
+  assert.equal(byId('work').children.length, 0, 'a hidden room carries no label nobody can see (task 1005112)');
+  assert.ok(byId('collab').classList.contains('nav-item--asleep'), 'community sleeps until alive');
   assert.ok(!byId('home').classList.contains('nav-item--asleep'), 'home is never put to sleep');
 });
 
@@ -227,7 +228,7 @@ test('founding OFF after ON restores the hall exactly — OFF removes, it does n
   assert.notEqual(snapshot(h), before);
   access.founding = null;
   apply();
-  assert.equal(snapshot(h), before, 'band, asleep classes, wake tags and the root attribute are all gone');
+  assert.equal(snapshot(h), before, 'band, asleep classes and the root attribute are all gone');
 });
 
 test('the band escapes what it prints — a project name cannot inject markup', () => {
@@ -280,13 +281,13 @@ test('a failing waiting-on source never turns the mode off', async () => {
   assert.equal(f.waiting_on, null);
 });
 
-test('re-applying ON does not stack a second band or duplicate wake tags', () => {
+test('re-applying ON does not stack a second band or add anything to a room', () => {
   const h = makeHall();
   const access = { founding: fm.shapeFoundingMode({ active: 'true', stage: 'decide' }) };
   const apply = loadApplyFounding(h.document, access);
   apply(); apply();
   assert.equal(h.appBody.children.filter((c) => c.id === 'founding-band').length, 1);
-  assert.equal(h.nav.find((a) => a.id === 'nav-work').children.length, 1);
+  assert.equal(h.nav.find((a) => a.id === 'nav-work').children.length, 0);
 });
 
 // ── the wiring ──────────────────────────────────────────────────────────────
@@ -317,3 +318,78 @@ test('founding mode adds no page, no route and no nav item — it is a mode', ()
   const hall = fs.readdirSync(path.join(ROOT, 'modules', 'hall-ui', 'public'));
   assert.ok(!hall.some((f) => /^founding\./.test(f)), 'no founding page file');
 });
+
+// ── task 1005112: hidden, not dimmed; the arrival; the honest refusal ─────────
+
+test('a sleeping room is hidden by the sheet, and a group of sleeping rooms hides its head', () => {
+  const css = fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'style.css'), 'utf8');
+  assert.match(css, /\.nav-item--asleep \{ display: none; \}/, 'asleep is not drawn at all, never dimmed');
+  assert.doesNotMatch(css, /\.nav-item--asleep \{ opacity/);
+  assert.match(css, /html\[data-founding="on"\] \.nav-group:not\(:has\(\.nav-item:not\(\.nav-item--asleep\)/);
+});
+
+test('a room that woke since this browser last looked arrives marked, once (task 1005112)', () => {
+  const store = new Map();
+  const storage = { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, String(v)) };
+  const at = (stage) => ({ founding: fm.shapeFoundingMode({ active: 'true', stage }) });
+  const h1 = makeHall();
+  loadApplyFounding(h1.document, at('scope'), undefined, storage)();
+  assert.ok(!h1.nav.some((a) => a.classList.contains('nav-item--arrived')), 'the first look marks nothing');
+  const h2 = makeHall();
+  loadApplyFounding(h2.document, at('strategize'), undefined, storage)();
+  const arrived = h2.nav.filter((a) => a.classList.contains('nav-item--arrived')).map((a) => a.id);
+  assert.deepEqual(arrived.sort(), ['nav-goal-map', 'nav-goals'], 'scope finished: Goals and Sky arrive');
+  const h3 = makeHall();
+  loadApplyFounding(h3.document, at('strategize'), undefined, storage)();
+  assert.ok(!h3.nav.some((a) => a.classList.contains('nav-item--arrived')), 'the next page load: no mark again');
+  // Switching off removes the mark with everything else.
+  const access = at('charter');
+  const h4 = makeHall();
+  const before = snapshot(h4);
+  const apply = loadApplyFounding(h4.document, access, undefined, storage);
+  apply();
+  access.founding = null;
+  apply();
+  assert.equal(snapshot(h4), before);
+});
+
+test('the shell says, on Home, what a refused room is and which stage opens it (task 1005112)', () => {
+  const navStart = SHELL.indexOf('  var NAV = [');
+  const navEnd = SHELL.indexOf('  var NAV_COLLAPSE_KEY');
+  const wakeStart = SHELL.indexOf('  var WAKE_TEXT = {');
+  const wakeEnd = SHELL.indexOf('};', wakeStart) + 2;
+  const src = [SHELL.slice(navStart, navEnd), SHELL.slice(wakeStart, wakeEnd), sliceEsc(),
+    sliceFn('navItemById'), sliceFn('renderDeniedNotice')].join('\n');
+  let inserted = null;
+  let replaced = null;
+  const el = { querySelector: () => ({ addEventListener() {} }), setAttribute() {} };
+  const document = {
+    getElementById: (id) => (id === 'app-topbar' ? { insertAdjacentElement: (_, n) => { inserted = n; } } : null),
+    createElement: () => el,
+  };
+  const run = (search) => {
+    inserted = null;
+    new Function('document', 'window', 'history', 'brand', 'access', 'icon', 'chevronIcon',
+      `${src}\nreturn renderDeniedNotice;`)(document,
+      { location: { search, pathname: '/', hash: '' }, OTB: realOTB() },
+      { replaceState: (a, b, url) => { replaced = url; } }, {}, {}, () => '', () => '')();
+    return inserted;
+  };
+  const n = run('?asleep=goals&opens=scope');
+  assert.ok(n, 'a notice is drawn');
+  assert.match(n.innerHTML, /Goals isn’t open yet\. It opens after scope\. Finish that stage of founding here on Home\./);
+  assert.equal(replaced, '/', 'the query is stripped so a refresh does not re-show it');
+  assert.equal(run('?asleep=goals%3Cx&opens=scope'), null, 'a malformed room id draws nothing');
+  assert.match(run('?denied=page.view.government').innerHTML, /permission/, 'the old denial still reads the same');
+});
+
+test('the arrival mark survives the shell applying the mode a second time on one page', () => {
+  const store = new Map([['hall-founding-asleep', JSON.stringify({ goals: 'scope', 'goal-map': 'scope', 'board-room': 'charter' })]]);
+  const storage = { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, String(v)) };
+  const h = makeHall();
+  const apply = loadApplyFounding(h.document, { founding: fm.shapeFoundingMode({ active: 'true', stage: 'strategize' }) }, undefined, storage);
+  apply();
+  apply(); // /me settles, then the page reports: applyAccess runs again
+  const arrived = h.nav.filter((a) => a.classList.contains('nav-item--arrived')).map((a) => a.id).sort();
+  assert.deepEqual(arrived, ['nav-board-room', 'nav-goal-map', 'nav-goals']);
+});

package/tests/founding_page_gate.mjs

@@ -0,0 +1,105 @@
+// tests/founding_page_gate.mjs — A SLEEPING ROOM IS NOT REACHABLE BY URL (task 1005112).
+//
+// The sidebar hides a room a founding project has not opened; this is the other half,
+// the page. Everything here RUNS the real middleware (src/bongos/founding-page-gate.js)
+// over fake requests, fed by the real founding-mode shape (modules/onboarding/
+// founding-mode.js) — and, in the last cases, through the real port lookup — so the
+// server's /me answer and the page refusal are one rule.
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+
+const require = createRequire(import.meta.url);
+const { foundingPageGate } = require('../src/bongos/founding-page-gate.js');
+const seams = require('../src/module-seams.js');
+const fm = require('../modules/onboarding/founding-mode.js');
+
+const founding = (stage) => fm.shapeFoundingMode({ active: 'true', stage });
+const ROOMS = [...new Set([...Object.values(fm.WAKES).flat(), ...fm.WAKES_WHEN_ALIVE])];
+
+// Drive the middleware once; resolve with what it did.
+function run(pathname, { read, buildersHost = false, skip = false } = {}) {
+  return new Promise((resolve) => {
+    const res = {
+      headers: {},
+      set(k, v) { this.headers[k] = v; return this; },
+      redirect(code, url) { resolve({ redirect: url, code, headers: this.headers }); },
+    };
+    const opts = { isBuildersHost: () => buildersHost, skip: () => skip };
+    if (read) opts.read = read;
+    foundingPageGate(opts)({ path: pathname }, res, () => resolve({ next: true }));
+  });
+}
+
+test('every room a genesis stage can put to sleep is refused while it sleeps, and nothing else is', async () => {
+  // At 'decide' every room sleeps, so this is the whole list the gate must cover.
+  const read = async () => founding('decide');
+  for (const id of ROOMS) {
+    const out = await run(`/builders/${id}`, { read });
+    assert.ok(out.redirect, `${id} is refused while asleep`);
+  }
+  for (const never of ['primer', 'board-room', 'profile', 'task/12', 'settings', 'blockers', 'studio']) {
+    assert.deepEqual(await run(`/builders/${never}`, { read }), { next: true }, `${never} is never gated`);
+  }
+  // And the gate names no room the server never puts to sleep: a fake answer naming
+  // an unknown room changes nothing.
+  assert.deepEqual(await run('/builders/blockers', { read: async () => ({ active: true, asleep: { blockers: 'scope' } }) }), { next: true });
+});
+
+test('a sleeping room\'s page goes home, naming the room and the stage that opens it', async () => {
+  const out = await run('/builders/goals', { read: async () => founding('scope') });
+  assert.equal(out.code, 302);
+  assert.equal(out.redirect, '/builders/?asleep=goals&opens=scope');
+  assert.equal(out.headers['Cache-Control'], 'no-store', 'a refusal is never cached past the wake');
+  const sub = await run('/builders/work.html', { read: async () => founding('scope'), buildersHost: true });
+  assert.equal(sub.redirect, '/?asleep=work&opens=strategize', 'the builders. host form');
+  const alive = await run('/builders/roster/', { read: async () => founding('legislation') });
+  assert.equal(alive.redirect, '/builders/?asleep=roster&opens=alive');
+  const sneaky = await run('/builders//goal-map', { read: async () => founding('decide') });
+  assert.equal(sneaky.redirect, '/builders/?asleep=goal-map&opens=scope', 'a doubled slash is normalised, not a way past');
+});
+
+test('an awake room opens, and a later stage never takes one away', async () => {
+  assert.deepEqual(await run('/builders/goals', { read: async () => founding('strategize') }), { next: true });
+  assert.deepEqual(await run('/builders/work', { read: async () => founding('charter') }), { next: true });
+});
+
+test('a project that is not founding is untouched, and a failed read opens rather than shuts', async () => {
+  assert.deepEqual(await run('/builders/goals', { read: async () => null }), { next: true });
+  assert.deepEqual(await run('/builders/collab', { read: async () => ({ active: false }) }), { next: true });
+  assert.deepEqual(await run('/builders/goals', { read: async () => { throw new Error('db down'); } }), { next: true },
+    'a read that throws opens the page');
+});
+
+test('only the five room pages ever cost a founding read', async () => {
+  let reads = 0;
+  const read = async () => { reads += 1; return founding('decide'); };
+  for (const p of ['/builders/', '/builders/primer', '/builders/board-room', '/builders/task/5', '/api/bongos/me', '/goals']) {
+    assert.deepEqual(await run(p, { read }), { next: true }, p);
+  }
+  assert.deepEqual(await run('/builders/goals', { read, skip: true }), { next: true }, 'a module surface host is skipped');
+  assert.equal(reads, 0);
+});
+
+test('the default read is the onboarding port\'s foundingModeFor, the answer /me carries', async () => {
+  seams._reset();
+  try {
+    assert.deepEqual(await run('/builders/goals'), { next: true }, 'onboarding module off: not founding, page opens');
+    seams.registerProvider('onboarding', { foundingModeFor: async () => founding('scope') });
+    assert.equal((await run('/builders/goals')).redirect, '/builders/?asleep=goals&opens=scope');
+    seams._reset();
+    seams.registerProvider('onboarding', { foundingModeFor: async () => { throw new Error('settings table gone'); } });
+    assert.deepEqual(await run('/builders/goals'), { next: true }, 'a port that throws opens the page');
+  } finally {
+    seams._reset();
+  }
+});
+
+test('the server mounts it after the sign-in gate, so a stranger still meets sign-in first', () => {
+  const src = fs.readFileSync(new URL('../src/bongos/serve-internal.js', import.meta.url), 'utf8');
+  const signIn = src.indexOf('return gdsAuth.requireBuilderPage(req, res, next);');
+  const mount = src.indexOf('app.use(foundingPageGate(');
+  assert.ok(signIn > 0 && mount > signIn, 'mounted, and after the sign-in gate');
+});

package/tests/front_door_guide_existing.mjs

@@ -222,6 +222,7 @@ test('the guide has no upload, fetch or link-reading path: these are all its rou
   assert.deepEqual([...routes(chatRouter), ...routes(planRouter)].sort(), [
     'GET /front-door-guide/conversations/:id',
     'GET /front-door-guide/mine',
+    'GET /front-door-guide/mine/handoff.md',   // the plan as the hand-off file, a download (task 1005274): reads nothing of theirs
     'GET /front-door-guide/status',
     'POST /front-door-guide/conversations',
     'POST /front-door-guide/conversations/:id/attach',

package/tests/genesis_home.mjs

@@ -653,6 +653,8 @@ test('the stage reads as a checklist: done, open and locked, and a locked row of
   assert.match(row('302'), /class="genesis__task is-locked"/);
   assert.match(row('302'), /after Gather what already exists/, 'a locked row says what it waits on');
   assert.doesNotMatch(row('302'), /data-genesis-copy/, 'a locked row offers no prompt for work it cannot claim');
+  assert.doesNotMatch(row('301'), /sr-only/, 'an open row adds no hidden word its status pill could contradict');
+  assert.match(row('302'), /class="sr-only">Locked: /);
   assert.doesNotMatch(html, /is-finished|line-through/, 'nothing is drawn struck through');
   // The "done" row: the earlier stage is not the one on screen, so check the shape directly.
   const done = gh.shapeGenesis({ mode: { stage: 'scope', stage_number: 1, stage_count: 5, day: 1 }, plan: gh.parsePlan({}).plan,
@@ -774,3 +776,25 @@ test('task 1005121: the close route answers 202 with the whole body for an open
   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');
 });
+
+test('a stage that opens no room says what finishing it earns, never nothing (task 1005112)', async () => {
+  const genesis = gh.shapeGenesis({ mode: { stage: 'scope', stage_number: 1, stage_count: 5, day: 1 }, plan: gh.parsePlan({}).plan });
+  const by = Object.fromEntries(genesis.stages.map((s) => [s.key, s]));
+  assert.equal(by.scope.earns, null, 'a stage that wakes rooms names the rooms instead');
+  assert.equal(by.strategize.earns, null);
+  for (const k of ['charter', 'legalize', 'legislation']) {
+    assert.deepEqual(by[k].wakes, [], `${k} wakes no room`);
+    assert.ok(by[k].earns && by[k].earns.length > 10, `${k} says what it earns`);
+  }
+  assert.match(by.legislation.earns, /every room opens/, 'the last stage is the one that opens everything');
+  const b = bootCard({ founding: true, data: { genesis, viewer_id: '1' } });
+  await mountClickable(b);
+  assert.match(b.host.innerHTML, /Wakes Goals, Goal map/);
+  assert.match(b.host.innerHTML, /puts your government in force/);
+  assert.match(b.host.innerHTML, /settles how contributors are rewarded/);
+  // The district rises with the stages (task 1005112): each row also names what it raises.
+  assert.match(b.host.innerHTML, /Wakes Goals, Goal map · raises Planning/);
+  assert.match(b.host.innerHTML, /Raises Treasury · settles how contributors are rewarded/);
+  assert.match(b.host.innerHTML, /Raises Rules, Review, Disputes · brings the project to life/);
+  assert.deepEqual(by.legalize.raises, ['treasury']);
+});