@bongos/core 1.25.18 → 1.25.20

package/modules/onboarding/guide-handoff.js

@@ -0,0 +1,109 @@
+'use strict';
+
+// modules/onboarding/guide-handoff.js — THE GUIDE'S ANSWERS, ARRIVED (task 1005274, goal
+// 1000106). The founder talked with the start-a-project guide before signing up; the hub
+// stamped what came out of it on the new project (modules/provisioning/guide-handoff.js),
+// and it reached this instance as one web.env line, mapped by src/branding.js onto the
+// server-only founding.guideHandoff (base64url JSON { scope, markdown }).
+//
+// Here it lands, once, in the two places a later reader already looks:
+//   * The Genesis scope interview: each carried answer is written as ORIGIN carried_over
+//     through genesis-work's own if-empty write, so it never replaces anything the founder
+//     already typed, and the interview shows it as carried over and editable (any edit by
+//     the founder makes it theirs). Only the questions the hub's explicit map answered are
+//     written; the rest stay empty.
+//   * The hand-off file: kept in project_settings (HANDOFF_KEY) and served at the top of
+//     GET /founding/context, the read `npx bongos genesis context` prints and the project
+//     context scaffold (docs/project-context.template.md) tells every session to run first.
+//     So the founder's own AI meets it in its first session without being told where.
+//
+// WHEN: lazily, on the first genesis read (routes/genesis-work.js), not at boot — the
+// founding-birth.js reasoning: by then the database is up and the founder is seated. NOT
+// tied to genesis being switched on: a paused project still keeps its founder's words.
+// ONCE: the hand-off file's presence is the done-mark, written LAST, so a run that fails
+// half-way is retried and the if-empty writes make the retry harmless. No marker (a project
+// whose founder never used the guide, or one made before this shipped): resolves without
+// touching the database.
+
+const HANDOFF_KEY = 'founding.guide_handoff';
+
+// handoffMarker(founding) — PURE. founding.guideHandoff → { scope, markdown } or null.
+function handoffMarker(founding) {
+  const raw = founding && typeof founding === 'object' ? founding.guideHandoff : null;
+  if (typeof raw !== 'string' || !raw.trim()) return null;
+  try {
+    const h = JSON.parse(Buffer.from(raw.trim(), 'base64url').toString('utf8'));
+    if (!h || typeof h.markdown !== 'string' || !h.markdown.trim()) return null;
+    const scope = h.scope && typeof h.scope === 'object' && !Array.isArray(h.scope) ? h.scope : {};
+    return { scope, markdown: h.markdown };
+  } catch (_) {
+    return null;
+  }
+}
+
+function markerFrom(deps) {
+  if (Object.prototype.hasOwnProperty.call(deps, 'marker')) return deps.marker;
+  try { return handoffMarker(require('../../src/module-api').branding().founding); } catch (_) { return null; }
+}
+
+const settingsOf = (deps) => ({
+  get: deps.getSetting || require('../../src/module-api').projectSettings.get,
+  set: deps.setSetting || require('../../src/module-api').projectSettings.set,
+});
+
+// carryOver(deps) → what it did: { ran:false, reason } or { ran:true, carried:[ids], kept:[ids] }.
+//   carried  questions now holding the guide's words
+//   kept     questions the founder had already answered, left alone
+async function carryOver(deps = {}) {
+  const marker = markerFrom(deps);
+  if (!marker) return { ran: false, reason: 'no_handoff' };
+  const { get, set } = settingsOf(deps);
+  const done = await get(HANDOFF_KEY);
+  if (done && done.value) return { ran: false, reason: 'already' };
+  const work = require('./genesis-work');
+  const carried = [];
+  const kept = [];
+  for (const [question, text] of Object.entries(marker.scope)) {
+    if (typeof text !== 'string' || !text.trim()) continue;
+    const r = await work.setAnswer('scope', question, { state: 'answered', text, origin: 'carried_over' }, null, deps, { ifEmpty: true });
+    if (r.ok === false) continue;   // a question this core no longer asks: skipped, never invented
+    (r.changed ? carried : kept).push(question);
+  }
+  await set(HANDOFF_KEY, marker.markdown, null);
+  return { ran: true, carried, kept };
+}
+
+// ensureHandoff(deps) — the once-per-process door the reads call. Never throws: a hand-off
+// hiccup must never fail the read that triggered it; a failed run is retried next read.
+let once = null;
+function ensureHandoff(deps = {}) {
+  if (deps.fresh) return carryOver(deps).catch(() => ({ ran: false, reason: 'error' }));
+  if (once) return once;
+  const p = carryOver(deps).then((r) => r, (err) => {
+    once = null;
+    try { require('../../src/module-api').logger('onboarding').error('[onboarding] guide hand-off failed', err); } catch (_) { /* no logger */ }
+    return { ran: false, reason: 'error' };
+  });
+  once = p;
+  return p;
+}
+
+// readHandoff(deps) → the hand-off file's markdown, or null. No marker, no read: a project
+// whose founder never used the guide never touches the database for it.
+async function readHandoff(deps = {}) {
+  if (!markerFrom(deps)) return null;
+  const row = await settingsOf(deps).get(HANDOFF_KEY);
+  return row && typeof row.value === 'string' && row.value.trim() ? row.value : null;
+}
+
+// withHandoff(context, markdown) — PURE. The planning read with the hand-off file first:
+// it is where the project started, and the founder's own answers below it are their
+// latest word.
+function withHandoff(context, markdown) {
+  if (!markdown) return { ...context, handoff: null };
+  const said = context.markdown ? `\n---\n\n${context.markdown}` : '';
+  return { ...context, handoff: markdown, markdown: `${markdown.trimEnd()}\n${said}` };
+}
+
+
+module.exports = { HANDOFF_KEY, handoffMarker, carryOver, ensureHandoff, readHandoff, withHandoff };

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

@@ -12,6 +12,7 @@
 
 const api = require('../../../src/module-api');
 const work = require('../genesis-work');
+const handoff = require('../guide-handoff');   // the start-a-project guide's answers, carried in once (task 1005274)
 
 const REFUSALS = {
   unknown_stage: 404, unknown_question: 404, bad_door: 400, bad_state: 400, bad_origin: 400,
@@ -37,10 +38,16 @@ module.exports = function mountGenesisWorkRoutes(router, deps = {}) {
   const stage = (req) => String(req.params.stage);
   const q = (req) => String(req.params.question);
 
-  // The read path for every door and for AI sessions planning a goal or task.
-  router.get('/founding/work', api.requireBuilder, handle(async () => ({ stages: await work.readAll(deps) })));
-  router.get('/founding/context', api.requireBuilder, handle(() => work.readContext(deps)));
-  router.get('/founding/work/:stage', api.requireBuilder, handle((req) => work.readStage(stage(req), deps)));
+  // The read path for every door and for AI sessions planning a goal or task. Each first
+  // lands the guide's hand-off if one is waiting (../guide-handoff.js), so the scope
+  // interview opens with the carried-over answers and the context leads with the file.
+  const arrived = (fn) => async (req) => { await handoff.ensureHandoff(deps); return fn(req); };
+  router.get('/founding/work', api.requireBuilder, handle(arrived(async () => ({ stages: await work.readAll(deps) }))));
+  router.get('/founding/context', api.requireBuilder, handle(arrived(async () => handoff.withHandoff(await work.readContext(deps), await handoff.readHandoff(deps)))));
+  router.get('/founding/work/:stage', api.requireBuilder, handle(arrived((req) => work.readStage(stage(req), deps))));
+  // The stage's document (task 1005115): its record read as one named page, editable
+  // through the writes below at any time, without reopening the stage.
+  router.get('/founding/work/:stage/document', api.requireBuilder, handle(arrived((req) => work.readDocument(stage(req), deps))));
   router.get('/founding/work/:stage/assist', api.requireBuilder, handle(async (req) => {
     const prompt = work.assistPrompt(stage(req));
     return prompt ? { prompt } : { ok: false, reason: 'unknown_stage' };

package/modules/provisioning/guide-handoff.js

@@ -0,0 +1,65 @@
+'use strict';
+
+// modules/provisioning/guide-handoff.js — THE GUIDE'S ANSWERS RIDE INTO THE NEW PROJECT
+// (task 1005274, goal 1000106). A founder who talked with the start-a-project guide
+// (modules/front-door-guide) should never be asked the same thing twice. The creation
+// page pre-fills itself from the plan; this file carries the rest across to the new
+// project, whose database this process cannot reach — the birth marker's path exactly
+// (birth.js, modules/onboarding/founding-birth.js):
+//
+//   1. The create request says `from_guide: true` (the page sends it only when it
+//      pre-filled from a plan). The route asks the guide, through the
+//      `front-door-guide.handoff` port, for the CALLER's own newest attached plan — never a
+//      plan named by the request, so nobody can carry someone else's words in.
+//   2. stampGuideHandoff writes the reserved write-once settings key `guide_handoff`
+//      ({ scope, markdown }) on the row this request JUST made.
+//   3. The companion GUIDE_HANDOFF carries it into the instance's web.env as one
+//      base64url line; src/branding.js maps it onto the server-only founding.guideHandoff,
+//      and modules/onboarding/guide-handoff.js writes it once: the scope answers as
+//      carried over (never over the founder's own) and the hand-off file.
+//
+// No guide, no flag, no port (an instance without the guide) or no plan: nothing is
+// stamped and the companion goes out empty, so a visitor who never used the guide sees
+// exactly what they saw before.
+
+const KEY = 'guide_handoff';
+const MAX_BYTES = 24000;   // the stored JSON; handoff.js already bounds the markdown
+
+const storedOf = (row) => (row && row.settings && typeof row.settings === 'object' && !Array.isArray(row.settings) ? row.settings : {});
+
+// cleanHandoff(h) — PURE. The port's answer reduced to exactly { scope, markdown }, or null.
+function cleanHandoff(h) {
+  if (!h || typeof h !== 'object' || typeof h.markdown !== 'string' || !h.markdown.trim()) return null;
+  const scope = {};
+  if (h.scope && typeof h.scope === 'object') {
+    for (const [k, v] of Object.entries(h.scope)) if (/^[a-z_]{1,40}$/.test(k) && typeof v === 'string' && v.trim()) scope[k] = v;
+  }
+  const out = { scope, markdown: h.markdown };
+  return Buffer.byteLength(JSON.stringify(out)) <= MAX_BYTES ? out : null;
+}
+
+// guideHandoffEnv(row) — PURE. The companion line's value: base64url JSON, or '' for none.
+function guideHandoffEnv(row) {
+  const h = cleanHandoff(storedOf(row)[KEY]);
+  return h ? Buffer.from(JSON.stringify(h), 'utf8').toString('base64url') : '';
+}
+
+// stampGuideHandoff(db, instanceId, builderId, { name, resolve }) — the create route's
+// call, on the row it just made. Returns true when a hand-off was stamped. Write-once.
+async function stampGuideHandoff(db, instanceId, builderId, { name = '', resolve } = {}) {
+  const port = (resolve || require('../../src/module-api').resolveOptional)('front-door-guide.handoff');
+  if (typeof port !== 'function') return false;
+  const h = cleanHandoff(await port(builderId, { name }));
+  if (!h) return false;
+  await db.query(
+    `UPDATE provisioning_instances
+        SET settings = COALESCE(settings, '{}'::jsonb) || jsonb_build_object($2::text, $3::jsonb)
+      WHERE id = $1 AND NOT (COALESCE(settings, '{}'::jsonb) ? $2::text)`,
+    [instanceId, KEY, JSON.stringify(h)],
+  );
+  return true;
+}
+
+const GUIDE_COMPANION_ENV = Object.freeze({ GUIDE_HANDOFF: guideHandoffEnv });
+
+module.exports = { KEY, GUIDE_COMPANION_ENV, stampGuideHandoff };

package/modules/provisioning/provisioning.js

@@ -25,7 +25,7 @@ const { normalizeModuleSelection, effectiveModules } = require('./starter-bundle
 const { PLANET_PHYSICS_QUESTIONS, canonicalAnswer } = require('./planet-physics');
 const { softLimitsFor } = require('./soft-limits'); const { demoView } = require('./demo'); const { isTestProject, TEST_COMPANION_ENV } = require('./test-project');   // the demo marker's owner view (task 1004420); the test mark (task 1005036)
 const { dnsResolves, recordDnsResolved, lookupAnswers } = require('./dns-resolves');   // has the platform's lookup seen the address answer (task 1004505)
-const { LOOK_SETTINGS_VOCAB, LOOK_DEFAULTS, LOOK_COMPANION_ENV } = require('./look'); const { BIRTH_COMPANION_ENV } = require('./birth'); // born into genesis (task 1004506)
+const { LOOK_SETTINGS_VOCAB, LOOK_DEFAULTS, LOOK_COMPANION_ENV } = require('./look'); const { BIRTH_COMPANION_ENV } = require('./birth'); const { GUIDE_COMPANION_ENV } = require('./guide-handoff'); // born into genesis (task 1004506); the guide's hand-off (task 1005274)
 
 // ---------------------------------------------------------------------------
 // Constants (mirror the CHECK constraints in provisioning_001_tables.sql)
@@ -513,7 +513,7 @@ function settingsEnvVars(row, prefix) {
 // cutoff and every unresolved review counts, which is the right answer for a
 // project that has been strict since it stood up.
 const SETTINGS_COMPANION_ENV = Object.freeze({
-  ARTIST_GATE_SINCE: (row) => artistGateStrictSince(row) || '', ...LOOK_COMPANION_ENV, ...BIRTH_COMPANION_ENV, ...TEST_COMPANION_ENV, // + accent, logo (look.js); birth, demo box (birth.js); test mark (test-project.js)
+  ARTIST_GATE_SINCE: (row) => artistGateStrictSince(row) || '', ...LOOK_COMPANION_ENV, ...BIRTH_COMPANION_ENV, ...TEST_COMPANION_ENV, ...GUIDE_COMPANION_ENV, // + accent, logo (look.js); birth, demo box (birth.js); test mark (test-project.js); the guide's hand-off (guide-handoff.js)
 });
 
 // The web.env block the runner writes at STANDUP (task 1003139): a comment that

package/modules/provisioning/routes/provisioning.js

@@ -65,7 +65,7 @@ const catalogBridge = require('../catalog-bridge');
 const capacity = require('../capacity');   // the box's slot ceiling (ADR 0285, task 1003927)
 const { callbackPage } = require('./callback-page'); const githubSetup = require('../github-setup');
 // the LOUD body validators (task 1003504) — lifted out when this file hit the size ratchet
-const { badProjectDetail, badModuleSelection, badProjectType, screenedOut } = require('./body-validators'); const demo = require('../demo'); const birth = require('../birth'); const testProject = require('../test-project');
+const { badProjectDetail, badModuleSelection, badProjectType, screenedOut } = require('./body-validators'); const demo = require('../demo'); const birth = require('../birth'); const testProject = require('../test-project'); const guideHandoff = require('../guide-handoff');
 const { failFrom } = require('../public-refusal');   // every catch: a declared refusal reaches the owner, anything else stays opaque (task 1004126)
 const { settingsPush, failPushConflict } = require('../settings-push');   // a settings save's push + receipt, shared with routes/look.js (task 1004421)
 const { requireProjectOwner, projectActor, isProjectOwner } = require('../route-helpers');   // the owner-or-archon gate (task 1004159, ADR 0328)
@@ -362,7 +362,7 @@ module.exports = function provisioningRoutes() {
       // exactly the set the panel preselected. An explicit [] is the different
       // answer "none of them". maxItems is a sanity ceiling well above a catalog
       // that is three modules wide today.
-      modules: { type: 'array', itemsType: 'string', maxItems: 50 }, terms_acknowledged: { type: 'boolean' }, demo: { type: 'object' }, ship_mode: { type: 'string', enum: ['auto', 'manual'] }, genesis: { type: 'boolean' }, test: { type: 'boolean' },   // the wizard's terms tick (task 1004417, ../terms-ack.js); the demo route's { people, hours_each } (task 1004420, ../demo.js)
+      modules: { type: 'array', itemsType: 'string', maxItems: 50 }, terms_acknowledged: { type: 'boolean' }, demo: { type: 'object' }, ship_mode: { type: 'string', enum: ['auto', 'manual'] }, genesis: { type: 'boolean' }, test: { type: 'boolean' }, from_guide: { type: 'boolean' },   // from_guide: the page pre-filled from the guide's plan (task 1005274, ../guide-handoff.js); the wizard's terms tick (task 1004417, ../terms-ack.js); the demo route's { people, hours_each } (task 1004420, ../demo.js)
     })) return;
     const body = req.body || {};
     const detailFault = badProjectDetail(body.detail);
@@ -485,6 +485,8 @@ module.exports = function provisioningRoutes() {
       if (created && testAsk.test) await testProject.stampTestProject(pool, instance.id).catch((err) => log.error('[provisioning] test mark not stamped', err));
       // The wizard's ship mode (task 1004629) rides beside it; a miss means the project asks at its first ship.
       if (created) await birth.stampShipMode(pool, instance.id, body.ship_mode).catch((err) => log.error('[provisioning] ship mode not stamped', err));
+      // The guide's answers (task 1005274): the CALLER's own attached plan, never one the request names; a miss means the project opens unprefilled.
+      if (created && body.from_guide === true) await guideHandoff.stampGuideHandoff(pool, instance.id, req.builder.id, { name: slug }).catch((err) => log.error('[provisioning] guide hand-off not stamped', err));
       const demoRow = created && demoAsk.demo ? await demo.startDemoProject(pool, provisioning, instance.id, demoAsk.demo) : null;
       // Enqueue the provision intent (idempotent: an already-open intent is returned)
       // — but ONLY when the instance actually needs standing up. Blindly enqueueing on

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.18",
+  "version": "1.25.20",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.25.18",
+      "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.18",
+  "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

@@ -11852,5 +11852,21 @@
       "id": "1004571",
       "text": "Inside a project's hall, the options menu now shows where the project's app runs (no platform yet, or Render and its progress and address), and gives the owner a one-click way to connect Render."
     }
+  ],
+  "1.25.19": [
+    {
+      "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/scripts/bongos/genesis.js

@@ -11,6 +11,7 @@
 //
 // Usage:
 //   npx bongos genesis show [stage]                       every stage, or one, with its answers
+//   npx bongos genesis document <stage>                   the stage's document (task 1005115): what it left behind, editable any time
 //   npx bongos genesis context                            what the founder said, as markdown (for planning sessions)
 //   npx bongos genesis assist <stage>                     the brief for the founder's AI session (the assisted door)
 //   npx bongos genesis answer <stage> <question> "<words>" [--origin founder|assisted]
@@ -28,7 +29,7 @@
 const fs = require('node:fs');
 const { apiCall, requireSession, errCode, cliExit } = require('./cli-lib');
 
-const USAGE = 'usage: npx bongos genesis show [stage] | context | assist <stage> | answer <stage> <question> "<words>" [--origin founder|assisted] | answer <stage> <question> --not-sure|--skip ["why"] | clear <stage> <question> | history <stage> <question> | door <stage> guided|open|assisted | page <stage> "<words>"|--file <path>|--remove | link <stage> <url>|--remove';
+const USAGE = 'usage: npx bongos genesis show [stage] | context | document <stage> | assist <stage> | answer <stage> <question> "<words>" [--origin founder|assisted] | answer <stage> <question> --not-sure|--skip ["why"] | clear <stage> <question> | history <stage> <question> | door <stage> guided|open|assisted | page <stage> "<words>"|--file <path>|--remove | link <stage> <url>|--remove';
 
 const STATE_LABEL = { answered: '', not_sure: '[not sure yet] ', skipped: '[skipped] ' };
 const ORIGIN_LABEL = { assisted: ' (with AI help)', carried_over: ' (carried over — confirm or edit)' };
@@ -130,6 +131,12 @@ async function main(argv) {
     return 0;
   }
   if (!stage) { console.error(USAGE); return 2; }
+  if (cmd === 'document') {
+    const d = await call('GET', `/founding/work/${enc(stage)}/document`, null, 'read the document');
+    if (!d) return 1;
+    console.log(d.document.markdown || `${d.document.title}: nothing written yet.`);
+    return 0;
+  }
   if (cmd === 'assist') {
     const d = await call('GET', `/founding/work/${enc(stage)}/assist`, null, 'build the brief');
     if (!d) return 1;

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.18'; // 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');