@bongos/core 1.25.19 → 1.25.20

package/modules/hall-ui/public/shell.js

@@ -696,29 +696,39 @@
   // ?denied=<permission>[&reason=unavailable]. Render the refusal — "you are
   // signed in; you lack X" — then strip the query so a refresh or a shared link
   // doesn't re-show a stale notice. Cosmetic only; the gate already ran.
+  function navItemById(id) {
+    var hit = null;
+    NAV.forEach(function (g) { g.items.forEach(function (it) { if (it.id === id) hit = it; }); });
+    return hit;
+  }
   function renderDeniedNotice() {
     // Hand-parsed (no URLSearchParams): shell.js is dependency-free by design,
     // and the hall unit tests boot it in a bare vm context.
     var search = (window.location && window.location.search) || '';
     var m = /[?&]denied=([^&]+)/.exec(search);
-    if (!m) return;
-    var denied = decodeURIComponent(m[1]);
-    if (!/^[a-z0-9_.-]{1,80}$/i.test(denied)) return;
+    // task 1005112: a founding project's sleeping room sends its page here, naming it.
+    var sl = /[?&]asleep=([a-z-]{1,40})(?:&opens=([a-z]{1,20}))?(?:&|$)/.exec(search);
+    if (!m && !sl) return;
+    var denied = m ? decodeURIComponent(m[1]) : '';
+    if (m && !/^[a-z0-9_.-]{1,80}$/i.test(denied)) return;
     var unavailable = /[?&]reason=unavailable(?:&|$)/.test(search);
+    var room = sl && navItemById(sl[1]);
     var topbar = document.getElementById('app-topbar');
     if (!topbar) return;
     var el = document.createElement('div');
     el.className = 'denied-notice';
     el.setAttribute('role', 'status');
     el.innerHTML =
-      '<span>' + (unavailable
+      '<span>' + (sl
+        ? esc(room ? room.label : 'That room') + ' isn’t open yet. It ' + esc(WAKE_TEXT[sl[2]] || 'opens later') + '. Finish that stage of founding here on Home.'
+        : unavailable
         ? 'You’re signed in, but access to that page couldn’t be verified just now (the permission system didn’t answer), so it stayed closed. Try again in a minute.'
         : 'You’re signed in, but that page needs the <code>' + esc(denied) + '</code> permission — your current role doesn’t hold it.') +
       '</span>' +
       '<button type="button" class="denied-notice__close" aria-label="Dismiss">×</button>';
     el.querySelector('.denied-notice__close').addEventListener('click', function () { el.remove(); });
     topbar.insertAdjacentElement('afterend', el);
-    var rest = search.replace(/[?&](?:denied|reason)=[^&]*/g, '').replace(/^&/, '?');
+    var rest = search.replace(/[?&](?:denied|reason|asleep|opens)=[^&]*/g, '').replace(/^&/, '?');
     history.replaceState(null, '', window.location.pathname + rest + window.location.hash);
   }
 
@@ -916,8 +926,10 @@
   // OFF is the default and the fallback, and OFF REMOVES rather than hides: the band
   // element and every asleep class and tag are taken out of the DOM, so a hall that
   // is not founding is byte-for-byte the hall it was (tests/founding_mode.mjs pins
-  // it). Cosmetic only — an asleep room still opens; nothing is enforced (ADR 0016).
-  // The asleep tag in words a person would say, never a raw stage slug.
+  // it). task 1005112: an asleep room is HIDDEN, not dimmed, and the server refuses its
+  // page (src/bongos/founding-page-gate.js, the same /me answer), so this only draws.
+  // A room that woke since this browser last looked arrives marked, once.
+  // The stage in words a person would say, never a raw stage slug (the refusal notice).
   var WAKE_TEXT = {
     scope: 'opens after scope', strategize: 'opens after strategy', charter: 'opens after the charter',
     legalize: 'opens after legal setup', legislation: 'opens after legislation', alive: 'opens when alive'
@@ -930,11 +942,9 @@
     // mode — returns before touching a single node. That is the strongest form of the
     // no-hijack condition: nothing is read, created, classed or removed.
     if (!on && root.dataset.founding !== 'on') return;
-    document.querySelectorAll('#app-sidebar .nav-item--asleep').forEach(function (el) {
+    document.querySelectorAll('#app-sidebar .nav-item--asleep, #app-sidebar .nav-item--arrived').forEach(function (el) {
       el.classList.remove('nav-item--asleep');
-      delete el.dataset.wakes;
-      var tag = el.querySelector('[data-wakes-tag]');
-      if (tag && tag.parentNode) tag.parentNode.removeChild(tag);
+      if (!on) el.classList.remove('nav-item--arrived'); // the mark lasts the page, not one pass
     });
     var band = document.getElementById('founding-band');
     if (!on) {
@@ -943,17 +953,19 @@
       return;
     }
     root.dataset.founding = 'on';
+    // One key per browser ORIGIN, which is one project: a project's hall is its own host.
+    var seen = null, KEY = 'hall-founding-asleep';
+    try { seen = JSON.parse(window.localStorage.getItem(KEY) || 'null'); } catch (_) { seen = null; }
+    if (seen && typeof seen === 'object') Object.keys(seen).forEach(function (id) {
+      var el = !(id in f.asleep) && document.getElementById('nav-' + id);
+      if (el) el.classList.add('nav-item--arrived');
+    });
+    try { window.localStorage.setItem(KEY, JSON.stringify(f.asleep)); } catch (_) { /* private mode */ }
     Object.keys(f.asleep).forEach(function (id) {
+      // Hidden whole (style.css), so it carries no "opens after" label: the stage that
+      // opens it is said on Home instead, and on the refusal notice below.
       var el = document.getElementById('nav-' + id);
-      if (!el) return;
-      var stage = String(f.asleep[id]);
-      el.classList.add('nav-item--asleep');
-      el.dataset.wakes = stage;
-      var tag = document.createElement('span');
-      tag.className = 'nav-item__wakes';
-      tag.setAttribute('data-wakes-tag', '');
-      tag.textContent = WAKE_TEXT[stage] || 'opens later';
-      el.appendChild(tag);
+      if (el) el.classList.add('nav-item--asleep');
     });
     if (!band) {
       var body = document.querySelector('.app-body');

package/modules/hall-ui/public/street.html

@@ -228,7 +228,7 @@
 <script src="/builders/shell-game.js?v=2026-11-11-view2"></script>
 <script src="/builders/shell-trail.js?v=2026-11-05-numbers"></script>
 <script src="/builders/craft-mode.js?v=2026-11-10-visor"></script>
-<script src="/builders/shell.js?v=2026-11-11-view2"></script>
+<script src="/builders/shell.js?v=2026-11-13-founding"></script>
 <script src="/builders/hall-dialog.js"></script>
 <script src="/builders/palette.js" defer></script>
 <script src="/builders/gov-living.js?v=2026-10-09-positions1"></script>

package/modules/hall-ui/public/studio.html

@@ -225,7 +225,7 @@
 <script src="/builders/shell-game.js?v=2026-11-11-view2"></script>
 <script src="/builders/shell-trail.js?v=2026-11-05-numbers"></script>
 <script src="/builders/craft-mode.js?v=2026-11-10-visor"></script>
-<script src="/builders/shell.js?v=2026-11-11-view2"></script>
+<script src="/builders/shell.js?v=2026-11-13-founding"></script>
 <script src="/builders/hall-dialog.js"></script>
 <script src="/builders/palette.js" defer></script>
 <!-- The kit, for its ONE renderer: the full-size ship-time visual figure

package/modules/hall-ui/public/style.css

@@ -1082,10 +1082,15 @@ html[data-theme="dark"] .gplate__light { display: none; }
   .genesis__grid { grid-template-columns: minmax(0, 1fr); }
   .genesis__life { grid-template-columns: repeat(3, minmax(0, 1fr)); }
 }
-.nav-item--asleep { opacity: 0.55; }
-.nav-item__wakes { display: none; margin-left: auto; font-size: 10px; letter-spacing: 0.08em; text-transform: uppercase; color: var(--ink-faint); }
-.app-sidebar:hover .nav-item__wakes,
-.app-sidebar:focus-within .nav-item__wakes { display: inline; }
+/* task 1005112: a room a founding project has not opened is not in the sidebar at all
+   (the server refuses its page too, src/bongos/founding-page-gate.js), and a group whose
+   every room sleeps hides its head with it. A room that woke since this browser last
+   looked arrives with a mark, once: the stage's reward, not a silent re-render. */
+.nav-item--asleep { display: none; }
+html[data-founding="on"] .nav-group:not(:has(.nav-item:not(.nav-item--asleep):not([hidden]))) { display: none; }
+.nav-item--arrived { position: relative; color: var(--ink); background: color-mix(in srgb, var(--accent) 14%, transparent); animation: nav-arrive 1.6s var(--ds-ease, ease) 2; }
+.nav-item--arrived::after { content: ""; position: absolute; top: 8px; right: 8px; width: 6px; height: 6px; border-radius: var(--ds-radius-pill); background: var(--accent); }
+@keyframes nav-arrive { 50% { background: color-mix(in srgb, var(--accent) 32%, transparent); } }
 
 /* task 1003737: the nav count badge — the hall's only badge mechanism, built
    once and generically (shell.js `count:` names a need id; see the NAV model).

package/modules/hall-ui/public/task.html

@@ -60,7 +60,7 @@
 <script src="/builders/shell-game.js?v=2026-11-11-view2"></script>
 <script src="/builders/shell-trail.js?v=2026-11-05-numbers"></script>
 <script src="/builders/craft-mode.js?v=2026-11-10-visor"></script>
-<script src="/builders/shell.js?v=2026-11-11-view2"></script>
+<script src="/builders/shell.js?v=2026-11-13-founding"></script>
 <script src="/builders/hall-dialog.js"></script>
 <!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
 <script src="/builders/palette.js" defer></script>

package/modules/hall-ui/public/thinking.html

@@ -143,7 +143,7 @@
 <script src="/builders/shell-game.js?v=2026-11-11-view2"></script>
 <script src="/builders/shell-trail.js?v=2026-11-05-numbers"></script>
 <script src="/builders/craft-mode.js?v=2026-11-10-visor"></script>
-<script src="/builders/shell.js?v=2026-11-11-view2"></script>
+<script src="/builders/shell.js?v=2026-11-13-founding"></script>
 <script src="/builders/hall-dialog.js"></script>
 <!-- task 1005148: the visor (glass over the scene, game mode only; ADR 0399), after the shell and hall-dialog.js -->
 <script src="/builders/visor.js?v=2026-11-11-helm3"></script>

package/modules/hall-ui/public/tweak-editor.html

@@ -146,7 +146,7 @@
 <script src="/builders/shell-game.js?v=2026-11-11-view2"></script>
 <script src="/builders/shell-trail.js?v=2026-11-05-numbers"></script>
 <script src="/builders/craft-mode.js?v=2026-11-10-visor"></script>
-<script src="/builders/shell.js?v=2026-11-11-view2"></script>
+<script src="/builders/shell.js?v=2026-11-13-founding"></script>
 <script src="/builders/hall-dialog.js"></script>
 <script src="/builders/palette.js" defer></script>
 <script src="/builders/brand-holes.js?v=2026-09-29-aqfix"></script>

package/modules/hall-ui/public/watch.html

@@ -272,7 +272,7 @@
 <script src="/builders/shell-game.js?v=2026-11-11-view2"></script>
 <script src="/builders/shell-trail.js?v=2026-11-05-numbers"></script>
 <script src="/builders/craft-mode.js?v=2026-11-10-visor"></script>
-<script src="/builders/shell.js?v=2026-11-11-view2"></script>
+<script src="/builders/shell.js?v=2026-11-13-founding"></script>
 <script src="/builders/hall-dialog.js"></script>
 <!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
 <script src="/builders/palette.js" defer></script>

package/modules/hall-ui/public/work.html

@@ -175,7 +175,7 @@
 <script src="/builders/shell-game.js?v=2026-11-11-view2"></script>
 <script src="/builders/shell-trail.js?v=2026-11-05-numbers"></script>
 <script src="/builders/craft-mode.js?v=2026-11-10-visor"></script>
-<script src="/builders/shell.js?v=2026-11-11-view2"></script>
+<script src="/builders/shell.js?v=2026-11-13-founding"></script>
 <script src="/builders/hall-dialog.js"></script>
 <!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
 <script src="/builders/palette.js" defer></script>

package/modules/lifecycle/home-city.js

@@ -370,14 +370,28 @@ function shapeCity(raw, viewer) {
   };
 }
 
+// readFoundingDistrict() — while the project is founding, which government-district
+// buildings are not raised yet (task 1005112): the onboarding port's own answer, the one
+// /me carries. null when not founding, the module is off, or the read fails, which
+// draws the district whole, exactly as before.
+async function readFoundingDistrict(resolve = api.resolveOptional) {
+  try {
+    const onboarding = resolve('onboarding');
+    const f = onboarding && typeof onboarding.foundingModeFor === 'function' ? await onboarding.foundingModeFor() : null;
+    return f && f.active === true && f.unbuilt && typeof f.unbuilt === 'object' ? { stage: f.stage, unbuilt: f.unbuilt } : null;
+  } catch (_) {
+    return null;
+  }
+}
+
 // The GET /home/city handler, injectable so a test drives it with no express.
-function homeCityHandler({ log, read = readCity } = {}) {
+function homeCityHandler({ log, read = readCity, founding = readFoundingDistrict } = {}) {
   return async function homeCityRoute(req, res) {
     try {
       const viewer = req.builder ? { id: req.builder.id, rank: req.builder.rank } : null;
-      const raw = await read({ weeks: req.query && req.query.weeks, viewer });
+      const [raw, district] = await Promise.all([read({ weeks: req.query && req.query.weeks, viewer }), founding()]);
       res.set('Cache-Control', 'private, max-age=60');
-      res.json(shapeCity(raw, viewer));
+      res.json({ ...shapeCity(raw, viewer), founding: district });
     } catch (err) {
       if (log) log.error('GET /home/city', err);
       res.fail('home_city_failed', { status: 500, message: 'internal error' });

package/modules/onboarding/founding-mode.js

@@ -50,6 +50,48 @@ const WAKES = Object.freeze({
 });
 const WAKES_WHEN_ALIVE = Object.freeze(['collab', 'roster']);
 
+// THE GOVERNMENT DISTRICT RISES WITH GENESIS (task 1005112; V3 spec, task-cleanup
+// answer 1: "Genesis is the founding of the government district"). Home's city draws
+// the district as nine civic buildings (city-draw.js CIVIC_SLOTS, keyed as below). While
+// a project is founding, a building stands only once the stage that raises it is behind;
+// until then its plot is a marked-out foundation. Same rule and same shape as WAKES, so
+// the server decides and every presentation (the city, the genesis card) reads it.
+// Every stage raises something, so no stage ends the sense of progress; automation, the
+// project running itself, rises when the project comes alive.
+const BUILDS = Object.freeze({
+  scope: Object.freeze(['planning']),
+  strategize: Object.freeze(['release']),
+  charter: Object.freeze(['charter', 'people']),
+  legalize: Object.freeze(['treasury']),
+  legislation: Object.freeze(['rules', 'review', 'disputes']),
+});
+const BUILDS_WHEN_ALIVE = Object.freeze(['automation']);
+
+// unbuiltBuildings(stage) — PURE. { buildingKey: raisingStage } for every district
+// building not yet raised at this stage (the asleepRooms rule), or null for no stage.
+function unbuiltBuildings(stage) {
+  const at = STAGES.indexOf(stage);
+  if (at < 0) return null;
+  const out = {};
+  for (const [raising, keys] of Object.entries(BUILDS)) {
+    if (STAGES.indexOf(raising) >= at) for (const k of keys) out[k] = raising;
+  }
+  for (const k of BUILDS_WHEN_ALIVE) out[k] = 'alive';
+  return out;
+}
+
+// What finishing a stage that opens no room gives the founder, in a sentence (task
+// 1005112). Three stages wake no sidebar room since tasks 1005046 and 1005199, and a
+// founder must never be told nothing happens: this is said on the stage's row instead.
+// Each line is true today: the charter puts the government in force, legalize settles
+// how contributors are rewarded, and legislation's pass is what brings the project to
+// life, which opens every room. A stage that wakes rooms says those instead.
+const EARNS = Object.freeze({
+  charter: 'Puts your government in force',
+  legalize: 'Settles how contributors are rewarded',
+  legislation: 'Brings the project to life: every room opens',
+});
+
 // The project_settings keys. Namespaced 'founding.' like 'mingle.' and 'attention.'.
 const KEYS = Object.freeze({
   ACTIVE: 'founding.active',
@@ -118,6 +160,8 @@ function shapeFoundingMode(rows, now = new Date()) {
     stage_count: STAGES.length - 1,
     day: dayOf(rows.startedAt, now),
     asleep,
+    // The government district's buildings not yet raised (task 1005112), keyed like CIVIC_SLOTS.
+    unbuilt: unbuiltBuildings(stage),
     // Who closing the current stage is waiting on (spec D7) — display names, at most
     // five, from the government module's genesis-stage sitting (task 1004429). null
     // when the stage is not sitting, nobody is left to vote, or the read is missing.
@@ -226,5 +270,5 @@ async function setFoundingMode({ active, stage } = {}, builderId = null, deps =
 module.exports = {
   STAGES, WAKES, WAKES_WHEN_ALIVE, KEYS, stageAtKey,
   dayOf, shapeFoundingMode, waitingOnFromGovernment,
-  foundingModeFor, setFoundingMode,
+  foundingModeFor, setFoundingMode, EARNS, BUILDS, BUILDS_WHEN_ALIVE,
 };

package/modules/onboarding/genesis-home.js

@@ -194,6 +194,8 @@ function shapeGenesis({ mode, plan, tasks = {}, board = {}, stageAt = {}, boardR
       plate: info.plate,
       done_when: info.done_when,
       wakes: fm.WAKES[key] || [],
+      earns: (fm.WAKES[key] || []).length ? null : (fm.EARNS[key] || null), // task 1005112
+      raises: fm.BUILDS[key] || [], // task 1005112: the district buildings this stage raises
       days,
       minutes,
       due,

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,13 +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((req) => work.readDocument(stage(req), deps)));
+  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