@bongos/core 1.25.19 → 1.25.21

package/tests/guide_handoff.mjs

@@ -0,0 +1,322 @@
+// tests/guide_handoff.mjs — the start-a-project guide's hand-off (task 1005274, goal 1000106)
+//
+// A founder who talked with the guide is never asked the same thing twice. Proven end to
+// end, piece by piece, with no AI call, no real repository and no real compute:
+//   1. the creation page fills in what the plan covers — and only what is still empty —
+//      RUN from projects.html's own script in a vm under a small DOM stub;
+//   2. the create route carries the CALLER's own plan onto the new project, and the
+//      companion line takes it to the instance (the provisioning test seams: stubbed
+//      createInstance / enqueueIntent / pool, as tests/wizard_ship_mode.mjs does);
+//   3. the instance writes the scope answers as carried over through the if-empty write,
+//      never over a founder's own answer, and serves the hand-off file at the top of the
+//      context every planning session reads (the real genesis routes, in-memory store);
+//   4. the hand-off file says what the project is, the plan, the modules and the first steps;
+//   5. a visitor who never used the guide: nothing is read, stamped or written.
+//
+// Run:  node tests/guide_handoff.mjs
+
+import { strict as assert } from 'node:assert';
+import { test, after } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import { memStore } from './genesis_work.mjs';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HUB = fs.readFileSync(path.join(ROOT, 'modules', 'public-landing', 'public', 'projects.html'), 'utf8').replace(/\r\n/g, '\n');
+
+const H = require('../modules/front-door-guide/handoff.js');
+const provHandoff = require('../modules/provisioning/guide-handoff.js');
+const instHandoff = require('../modules/onboarding/guide-handoff.js');
+const gw = require('../modules/onboarding/genesis-work.js');
+
+const PLAN = {
+  summary: 'A cooperative board game about running a lighthouse, for families who play on weekends.',
+  starting_point: 'fresh', what_you_have: [], project_type: 'game',
+  how_it_works: ['Players share one lighthouse and take turns', 'Storm cards raise the stakes each round'],
+  modules: [{ key: 'discord', label: 'Discord', summary: 'A chat home for your team.', why: 'Playtesters can talk between sessions.' }],
+  steps: [{ title: 'Write the one-page rules', detail: 'Enough to play a first round at the kitchen table.' }, { title: 'Run a first playtest', detail: 'Four people, one hour.' }],
+  needs: [{ item: 'Playtesters', detail: 'Four people for an hour.' }],
+  open_questions: ['How long should one game last?'],
+  cost_and_time: 'This plan does not estimate cost or time.',
+};
+
+// ── 4. the hand-off file and the explicit scope map ────────────────────────────
+
+test('the scope map answers only what the plan says, and leaves every other question empty', () => {
+  assert.deepEqual(H.scopeAnswers(PLAN), { what_creating: PLAN.summary });
+  const scopeIds = gw.QUESTIONS.scope.map((q) => q.id).sort();
+  assert.deepEqual(Object.keys(H.SCOPE_MAP).sort(), scopeIds, 'every scope question is mapped, explicitly');
+  assert.deepEqual(Object.entries(H.SCOPE_MAP).filter(([, f]) => f).map(([q]) => q), ['what_creating'], 'one question is carried; five stay empty');
+  assert.deepEqual(H.scopeAnswers(null), {});
+  assert.deepEqual(H.scopeAnswers({ ...PLAN, summary: '   ' }), {}, 'an empty summary carries nothing');
+});
+
+test('the hand-off file says what the project is, the plan, the modules, the first steps and the next one', () => {
+  const md = H.handoffMarkdown(PLAN, { name: 'Lamplight' });
+  assert.match(md, /^# Lamplight: where this project started/);
+  assert.match(md, /## What the project is\n\nA cooperative board game about running a lighthouse/);
+  assert.match(md, /\*\*Kind of project:\*\* A game/);
+  assert.match(md, /## The plan\n\n- Players share one lighthouse/);
+  assert.match(md, /## Recommended modules\n\n- \*\*Discord\*\* \(`discord`\): A chat home for your team\. Why: Playtesters/);
+  assert.match(md, /## First steps\n\n1\. \*\*Write the one-page rules\*\* Enough to play/);
+  assert.match(md, /2\. \*\*Run a first playtest\*\*/);
+  assert.match(md, /## Your next step\n\nStart with step 1, "Write the one-page rules"\./);
+  assert.match(md, /If you are an AI session working on this project: read this first/, 'it tells the founder\'s AI how to treat it');
+  assert.match(md, /never ask them again what is already written here/);
+  assert.doesNotMatch(md, /undefined|null|\[object/);
+  assert.equal(H.handoffMarkdown(null), '');
+  assert.equal(H.handoffFor({ ...PLAN, summary: '' }), null, 'no plan worth handing off, no file');
+  const huge = H.handoffMarkdown({ ...PLAN, how_it_works: Array.from({ length: 400 }, (_, i) => `step ${i} `.repeat(10)) });
+  assert.ok(huge.length <= H.MARKDOWN_MAX, 'bounded, since it rides an env line');
+});
+
+// ── 2. the hub: the create route and the companion line ────────────────────────
+
+const api = require('../src/module-api.js');
+const provisioning = require('../modules/provisioning/provisioning.js');
+const birth = require('../modules/provisioning/birth.js');
+provisioning.getInstanceBySlug = async () => null;
+provisioning.getInstanceByDomain = async () => null;
+birth.stampBirth = async () => {};
+provisioning.createInstance = async (_db, args) => ({
+  instance: { id: 41, owner_builder_id: 7, slug: args.slug, status: 'requested', hosting_shape: 'byo-host', detail: {} }, created: true,
+});
+provisioning.enqueueIntent = async (_db, _id, action) => ({ intent: { id: 9, action, state: 'pending' }, created: true });
+provisioning.getOpenIntent = async () => null;
+provisioning.recordEvent = async () => {};
+api.requireBuilder = (req, _res, next) => { req.builder = { id: 7, github_login: 'owner' }; next(); };
+const stamped = [];
+api.pool.query = async (sql, params) => {
+  if (/jsonb_build_object/.test(sql) && params[1] === provHandoff.KEY) stamped.push({ id: params[0], value: JSON.parse(params[2]) });
+  return { rows: [] };
+};
+const asked = [];
+let portAnswer = null;
+api.registerProvider('front-door-guide.handoff', async (builderId, opts) => { asked.push({ builderId, opts }); return portAnswer; });
+
+const express = require('express');
+const app = express();
+app.use(express.json());
+app.use((_req, res, next) => {
+  res.fail = (code, opts) => res.status(typeof opts === 'number' ? opts : (opts && opts.status) || 400).json({ error: { code } });
+  next();
+});
+app.use('/api/bongos', require('../modules/provisioning/routes/provisioning.js')());
+const server = app.listen(0);
+after(() => server.close());
+async function create(body) {
+  await new Promise((r) => (server.listening ? r() : server.once('listening', r)));
+  const res = await fetch(`http://127.0.0.1:${server.address().port}/api/bongos/provisioning/instances`, {
+    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body),
+  });
+  return { status: res.status, body: await res.json() };
+}
+
+test('from_guide: the create route stamps the CALLER\'s own plan on the row it made', async () => {
+  stamped.length = 0; asked.length = 0;
+  portAnswer = H.handoffFor(PLAN, { name: 'lamplight' });
+  const r = await create({ slug: 'lamplight', hosting_shape: 'byo-host', from_guide: true });
+  assert.equal(r.status, 201, JSON.stringify(r.body));
+  assert.deepEqual(asked, [{ builderId: 7, opts: { name: 'lamplight' } }], 'asked for the signed-in builder, never a plan the request names');
+  assert.equal(stamped.length, 1);
+  assert.equal(stamped[0].id, 41);
+  assert.deepEqual(stamped[0].value.scope, { what_creating: PLAN.summary });
+  assert.match(stamped[0].value.markdown, /## First steps/);
+  assert.equal((await create({ slug: 'x2', hosting_shape: 'byo-host', from_guide: 'yes' })).status, 400, 'a strict boolean');
+});
+
+test('the no-guide path: no flag, or a builder with no plan, stamps nothing', async () => {
+  stamped.length = 0; asked.length = 0;
+  portAnswer = H.handoffFor(PLAN);
+  assert.equal((await create({ slug: 'plain', hosting_shape: 'byo-host' })).status, 201);
+  assert.deepEqual(asked, [], 'without the flag the guide is not even asked');
+  portAnswer = null;
+  assert.equal((await create({ slug: 'noplan', hosting_shape: 'byo-host', from_guide: true })).status, 201, 'no plan never fails a create');
+  assert.deepEqual(stamped, []);
+  assert.equal(await provHandoff.stampGuideHandoff({ query: () => assert.fail('no write') }, 1, 7, { resolve: () => null }), false, 'no guide module: nothing');
+});
+
+test('the companion line carries the stamp to the instance, and is empty without one', () => {
+  const row = { settings: { [provHandoff.KEY]: H.handoffFor(PLAN) } };
+  const line = provisioning.SETTINGS_COMPANION_ENV.GUIDE_HANDOFF(row);
+  assert.match(line, /^[A-Za-z0-9_-]+$/, 'one env-safe line');
+  const back = instHandoff.handoffMarker({ guideHandoff: line });
+  assert.deepEqual(back.scope, { what_creating: PLAN.summary });
+  assert.equal(back.markdown, H.handoffFor(PLAN).markdown);
+  assert.equal(provisioning.SETTINGS_COMPANION_ENV.GUIDE_HANDOFF({ settings: {} }), '');
+  assert.equal(provisioning.SETTINGS_COMPANION_ENV.GUIDE_HANDOFF({ settings: { [provHandoff.KEY]: { markdown: '' } } }), '');
+  assert.equal(instHandoff.handoffMarker({ guideHandoff: 'not-json' }), null);
+  assert.equal(instHandoff.handoffMarker({}), null);
+});
+
+// ── 3. the instance: carried-over scope answers and the file in the context ────
+
+function settingsStore() {
+  const rows = new Map();
+  return {
+    rows,
+    getSetting: async (k) => (rows.has(k) ? { key: k, value: rows.get(k) } : null),
+    setSetting: async (k, v) => { rows.set(k, String(v)); return { key: k, value: String(v) }; },
+  };
+}
+const MARKER = instHandoff.handoffMarker({ guideHandoff: provisioning.SETTINGS_COMPANION_ENV.GUIDE_HANDOFF({ settings: { [provHandoff.KEY]: H.handoffFor(PLAN) } }) });
+
+test('Genesis scope opens with the guide\'s answer, carried over and editable; the rest stay empty', async () => {
+  const store = memStore();
+  const s = settingsStore();
+  const deps = { store, marker: MARKER, ...s };
+  const r = await instHandoff.carryOver(deps);
+  assert.deepEqual(r, { ran: true, carried: ['what_creating'], kept: [] });
+  const scope = (await gw.readStage('scope', deps)).work;
+  const q = scope.questions.find((x) => x.id === 'what_creating');
+  assert.equal(q.answer.text, PLAN.summary);
+  assert.equal(q.answer.origin, 'carried_over');
+  assert.equal(q.answer.carried_over, true, 'shown as carried over');
+  assert.equal(scope.counts.empty, 5, 'nothing invented for the other five');
+  // editable: the founder's edit makes it theirs
+  await gw.setAnswer('scope', 'what_creating', { text: 'A lighthouse game for my nieces.' }, 1, deps);
+  const mine = (await gw.readStage('scope', deps)).work.questions.find((x) => x.id === 'what_creating').answer;
+  assert.equal(mine.origin, 'founder');
+  assert.equal(mine.carried_over, false);
+  assert.deepEqual(await instHandoff.carryOver(deps), { ran: false, reason: 'already' }, 'once');
+});
+
+test('a founder\'s own answer is never overwritten by the carry-over', async () => {
+  const store = memStore();
+  const s = settingsStore();
+  const deps = { store, marker: MARKER, ...s };
+  await gw.setAnswer('scope', 'what_creating', { text: 'My own words, typed first.' }, 1, deps);
+  const historyBefore = store.history.length;
+  const r = await instHandoff.carryOver(deps);
+  assert.deepEqual(r, { ran: true, carried: [], kept: ['what_creating'] });
+  const a = (await gw.readStage('scope', deps)).work.questions.find((x) => x.id === 'what_creating').answer;
+  assert.equal(a.text, 'My own words, typed first.');
+  assert.equal(a.origin, 'founder');
+  assert.equal(store.history.length, historyBefore, 'no history row: nothing was written over it');
+  assert.equal(s.rows.get(instHandoff.HANDOFF_KEY), MARKER.markdown, 'the file still lands');
+});
+
+test('the hand-off file leads the context a planning session reads, over the real routes', async () => {
+  const store = memStore();
+  const s = settingsStore();
+  const mount = require('../modules/onboarding/routes/genesis-work.js');
+  const a = express();
+  a.use(express.json());
+  const router = express.Router();
+  api.requireBuilder = (req, _res, next) => { req.builder = { id: 1 }; next(); };
+  mount(router, { store, marker: MARKER, fresh: true, ...s });
+  a.use('/api/bongos', router);
+  const srv = a.listen(0);
+  try {
+    const base = `http://127.0.0.1:${srv.address().port}/api/bongos`;
+    const scope = await (await fetch(`${base}/founding/work/scope`)).json();
+    assert.equal(scope.work.questions.find((x) => x.id === 'what_creating').answer.origin, 'carried_over', 'opening the interview lands the hand-off');
+    const ctx = await (await fetch(`${base}/founding/context`)).json();
+    assert.equal(ctx.handoff, MARKER.markdown);
+    assert.ok(ctx.markdown.startsWith('# lamplight: where this project started') || ctx.markdown.startsWith('# '), 'the file first');
+    assert.ok(ctx.markdown.indexOf('## First steps') < ctx.markdown.indexOf('# What the founder has said'), 'then the founder\'s own answers');
+    assert.match(ctx.markdown, /carried over from before sign-up/);
+  } finally { srv.close(); }
+});
+
+test('the no-guide path on the instance: no marker, no database touched', async () => {
+  const deps = {
+    marker: null,
+    store: { loadAll: () => assert.fail('no read'), writeAnswer: () => assert.fail('no write') },
+    getSetting: () => assert.fail('no settings read'), setSetting: () => assert.fail('no settings write'),
+  };
+  assert.deepEqual(await instHandoff.carryOver(deps), { ran: false, reason: 'no_handoff' });
+  assert.equal(await instHandoff.readHandoff(deps), null);
+  assert.deepEqual(instHandoff.withHandoff({ markdown: 'x', stages: [] }, null), { markdown: 'x', stages: [], handoff: null });
+});
+
+// ── 1. the creation page's pre-fill, RUN from projects.html ───────────────────
+
+const START = '    /* ── the guide\'s answers (task 1005274) ──';
+const END = '\n    paintGuideFill();\n';
+function region() {
+  const a = HUB.indexOf(START);
+  const b = HUB.indexOf(END, a);
+  assert.ok(a > 0 && b > a, 'the pre-fill region is where this test slices it');
+  return HUB.slice(a, b + END.length);
+}
+
+function page({ chat, plan, enabled = true, signedIn = true, state: st }) {
+  const els = {
+    guideFill: { hidden: true }, guideFileLink: { href: '' }, 'f-desc': { value: (st && st.description) || '' },
+  };
+  const calls = [];
+  const store = new Map(chat ? [['cb-front-door-guide', JSON.stringify(chat)]] : []);
+  const painted = [];
+  const ctx = {
+    window: { __MODULES__: { enabled: { 'front-door-guide': enabled } } },
+    localStorage: { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, v), removeItem: (k) => store.delete(k) },
+    fetch: async (url, opts) => {
+      calls.push({ url, method: (opts && opts.method) || 'GET', body: opts && opts.body });
+      if (/\/attach$/.test(url)) return { ok: true, json: async () => ({ ok: true }) };
+      return { ok: true, json: async () => ({ ok: true, conversation: plan ? { plan } : null }) };
+    },
+    API: '/api/bongos',
+    me: signedIn ? { id: 7 } : null,
+    state: { name: 'Lamplight', projType: null, description: '', modules: null, ...st },
+    root: { querySelector: (sel) => (/data-type="(game|research|business|non-profit|not-sure)"/.test(sel) ? {} : null) },
+    $: (id) => els[id],
+    saveDraft: () => painted.push('draft'), paintType: () => painted.push('type'), renderModules: () => painted.push('modules'),
+    paintSetup: () => {}, paintCreate: () => {}, encodeURIComponent, JSON, Array, String,
+  };
+  vm.createContext(ctx);
+  vm.runInContext(`${region()}\nthis.guidePrefill = guidePrefill;`, ctx);
+  return { ctx, els, calls, store, painted };
+}
+const settle = () => new Promise((r) => setTimeout(r, 20));
+
+test('creation opens with the guide\'s answers filled in, and the chat moves onto the account', async () => {
+  const p = page({ chat: { id: '12', token: 'tok_abcdefghijklmnop' }, plan: PLAN });
+  p.ctx.guidePrefill();
+  await settle();
+  assert.deepEqual(p.calls.map((c) => `${c.method} ${c.url}`), ['POST /api/bongos/front-door-guide/conversations/12/attach', 'GET /api/bongos/front-door-guide/mine']);
+  assert.deepEqual(JSON.parse(p.calls[0].body), { token: 'tok_abcdefghijklmnop' });
+  assert.equal(p.ctx.state.projType, 'game');
+  assert.equal(p.ctx.state.description, PLAN.summary);
+  assert.equal(p.els['f-desc'].value, PLAN.summary, 'shown in the ordinary, editable field');
+  assert.deepEqual([...p.ctx.state.modules], ['discord']);
+  assert.equal(p.ctx.state.name, 'Lamplight', 'the name stays the founder\'s: the plan has none');
+  assert.equal(p.ctx.state.fromGuide, true, 'the create will say from_guide');
+  assert.equal(p.els.guideFill.hidden, false, 'the page says where the answers came from');
+  assert.equal(p.els.guideFileLink.href, '/api/bongos/front-door-guide/mine/handoff.md?name=Lamplight', 'and offers the hand-off file');
+  p.ctx.guidePrefill();
+  await settle();
+  assert.equal(p.calls.length, 2, 'asked once per page');
+});
+
+test('pre-fill never overwrites an answer the founder already gave', async () => {
+  const p = page({ chat: { id: '12', token: 'tok_abcdefghijklmnop' }, plan: PLAN, state: { projType: 'research', description: 'Mine.', modules: [] } });
+  p.ctx.guidePrefill();
+  await settle();
+  assert.equal(p.ctx.state.projType, 'research');
+  assert.equal(p.ctx.state.description, 'Mine.');
+  assert.deepEqual([...p.ctx.state.modules], [], '"none of them" is an answer too');
+});
+
+test('the no-guide path on the page: no chat in this browser, guide off, or signed out → nothing read, nothing changed', async () => {
+  for (const opts of [{ chat: null, plan: PLAN }, { chat: { id: '1', token: 'tok_abcdefghijklmnop' }, plan: PLAN, enabled: false }, { chat: { id: '1', token: 'tok_abcdefghijklmnop' }, plan: PLAN, signedIn: false }]) {
+    const p = page(opts);
+    const before = JSON.stringify(p.ctx.state);
+    p.ctx.guidePrefill();
+    await settle();
+    assert.deepEqual(p.calls, []);
+    assert.equal(JSON.stringify(p.ctx.state), before);
+    assert.equal(p.els.guideFill.hidden, true);
+  }
+});
+
+test('the create request carries from_guide only for a page that filled itself in, and a made project forgets the chat', () => {
+  assert.match(HUB, /from_guide: state\.fromGuide \? true : undefined,/);
+  assert.match(HUB, /if \(state\.fromGuide\) localStorage\.removeItem\(GUIDE_KEY\);/);
+  assert.match(HUB, /\n {6}guidePrefill\(\);\n {6}if \(currentView === 'new'\) enter\(false\);/, 'it runs once the sign-in settles');
+  assert.match(HUB, /<p class="fillOffer hint" id="guideFill" hidden>/);
+});

package/tests/home_city.mjs

@@ -628,4 +628,56 @@ await test('the ideator\'s ladder ranks ideas, votes and work; the builder\'s la
   Draw.ladderFor(m, i, FIXTURE.viewer.id).forEach((r) => assert.deepEqual(Object.keys(r.v), ['art', 'build', 'idea', 'gov']));
 });
 
+// task 1005112: Genesis is the founding of the government district (V3). While a
+// project is founding, a district building stands only once the stage raising it is done.
+await test('the city payload carries the unraised district buildings, from the onboarding port\'s answer', async () => {
+  const fm = require(path.join(ROOT, 'modules/onboarding/founding-mode.js'));
+  const h = city.homeCityHandler({ read: async () => raw(), founding: async () => ({ stage: 'charter', unbuilt: fm.shapeFoundingMode({ active: 'true', stage: 'charter' }).unbuilt }) });
+  const res = fakeRes();
+  await h({ builder: { id: '1' }, query: {} }, res);
+  assert.equal(res.body.founding.stage, 'charter');
+  assert.deepEqual(Object.keys(res.body.founding.unbuilt).sort(), ['automation', 'charter', 'disputes', 'people', 'review', 'rules', 'treasury']);
+  // The default reader asks the real port through the doorway; not founding is null.
+  const seams = require(path.join(ROOT, 'src/module-seams.js'));
+  seams._reset();
+  try {
+    const plain = fakeRes();
+    await city.homeCityHandler({ read: async () => raw() })({ builder: { id: '1' }, query: {} }, plain);
+    assert.equal(plain.body.founding, null, 'no onboarding module: the district is drawn whole');
+    seams.registerProvider('onboarding', { foundingModeFor: async () => fm.shapeFoundingMode({ active: 'true', stage: 'scope' }) });
+    const on = fakeRes();
+    await city.homeCityHandler({ read: async () => raw() })({ builder: { id: '1' }, query: {} }, on);
+    assert.equal(on.body.founding.unbuilt.planning, 'scope', 'at scope, Planning is still to rise');
+    seams._reset();
+    seams.registerProvider('onboarding', { foundingModeFor: async () => { throw new Error('x'); } });
+    const bad = fakeRes();
+    await city.homeCityHandler({ read: async () => raw() })({ builder: { id: '1' }, query: {} }, bad);
+    assert.equal(bad.body.founding, null, 'a failed read draws the district whole, never a broken city');
+  } finally { seams._reset(); }
+});
+
+await test('an unraised district building is a marked-out foundation, and the district says how many stand', () => {
+  const m = Draw.cityModel({ ...FIXTURE, founding: { stage: 'strategize', unbuilt: { release: 'strategize', charter: 'charter', automation: 'alive' } } });
+  const core = linksOf(all(Draw.citySvg(m, m.W - 1, { mode: 'dark', gov: Gov }).nodes)).find((n) => /\bhc-core\b/.test(n.attrs.class));
+  const found = all([core]).filter((n) => /hc-foundation/.test(n.attrs.class || '')).map((n) => n.attrs['data-building']).sort();
+  assert.deepEqual(found, ['automation', 'charter', 'release']);
+  assert.match(core.attrs['aria-label'], /6 of nine buildings raised so far/);
+  assert.match(core.attrs['data-tip-body'], /6 of nine buildings raised so far/, 'the hover caption says the same as the screen reader');
+  // The Charter's own faces are not drawn while it is a foundation.
+  const k = Gov.isoKit(50, 25, 0, 0, 0.82, Gov.isoTheme('dark'), true), charter = [];
+  Gov.isoInstitution(charter, k, 'charter', 0, 0, {});
+  const whole = linksOf(all(Draw.citySvg(Draw.cityModel(FIXTURE), m.W - 1, { mode: 'dark', gov: Gov }).nodes)).find((n) => /\bhc-core\b/.test(n.attrs.class));
+  assert.ok(all([core]).filter((n) => n.tag === 'path').length < all([whole]).filter((n) => n.tag === 'path').length);
+  assert.match(whole.attrs['aria-label'], /nine buildings, one for each part/, 'not founding: the district as before');
+});
+
+await test('every district building is raised by exactly one genesis stage, or by coming alive', () => {
+  const fm = require(path.join(ROOT, 'modules/onboarding/founding-mode.js'));
+  const raised = [...Object.values(fm.BUILDS).flat(), ...fm.BUILDS_WHEN_ALIVE];
+  assert.deepEqual([...raised].sort(), Gov.CIVIC_SLOTS.map((s) => s[0]).sort(), 'the nine slots, each once');
+  for (const stage of ['scope', 'strategize', 'charter', 'legalize', 'legislation']) assert.ok(fm.BUILDS[stage].length > 0, `${stage} raises something`);
+  assert.equal(Object.keys(fm.shapeFoundingMode({ active: 'true', stage: 'decide' }).unbuilt).length, 9, 'deciding: the plaza is bare');
+  assert.deepEqual(Object.keys(fm.shapeFoundingMode({ active: 'true', stage: 'legislation' }).unbuilt).sort(), ['automation', 'disputes', 'review', 'rules']);
+});
+
 summary();

package/tests/nav_permission_atoms.mjs

@@ -103,7 +103,7 @@ test('the hall-preview fixture carries every atom /me resolves', () => {
 // task 1005070: the remembered nav (the rail paints before /me).
 // task 1005088: the sidebar mark is drawn by reference to the one brand mark.
 // task 1005144: My agents, Project settings, Permissions and Modules left for the options menu.
-const SHELL_SHA = '89f6f166ed22a8ee';
+const SHELL_SHA = 'ccb3c6fe310ee6a2';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);

package/tests/project_catalog_routes.mjs

@@ -50,6 +50,8 @@ let published = [];
 let healed = [];
 
 provisioning.getInstanceById = async (_db, id) => (instance ? { ...instance, id } : null);
+// The gate also admits an owner-made grant (task 1004161, ADR 0407); nobody in this file holds one.
+require('../modules/provisioning/grants.js').liveGrant = async () => null;
 provisioning.getInstanceBySlug = async (_db, slug) => (instance && instance.slug === slug ? { ...instance } : null);
 provisioning.getInstanceByDomain = async () => null;
 provisioning.listInstancesForOwner = async () => [];   // the shape gate's count (task 1004412): no other hosted project

package/tests/provision_settings_apply.mjs

@@ -81,6 +81,7 @@ ${NEUTRAL_PREFIX}_DEMO_PEOPLE=
 ${NEUTRAL_PREFIX}_DEMO_HOURS=
 ${NEUTRAL_PREFIX}_SHIP_MODE=
 ${NEUTRAL_PREFIX}_TEST_PROJECT=
+${NEUTRAL_PREFIX}_GUIDE_HANDOFF=
 ${NEUTRAL_PREFIX}_HUB_UPGRADE_URL=
 `;
 
@@ -152,7 +153,7 @@ t('settingsEnvVarsFor: the runner pushes the SAME pair webEnvBody writes at stan
     // the birth marker and a demo's box (task 1004506), empty on an un-stamped row
     [`${NEUTRAL_PREFIX}_FOUNDING_BIRTH`]: '', [`${NEUTRAL_PREFIX}_FOUNDING_GENESIS`]: '', [`${NEUTRAL_PREFIX}_DEMO_PEOPLE`]: '', [`${NEUTRAL_PREFIX}_DEMO_HOURS`]: '',
     // the wizard's ship mode (task 1004629), empty when none was picked
-    [`${NEUTRAL_PREFIX}_SHIP_MODE`]: '', [`${NEUTRAL_PREFIX}_TEST_PROJECT`]: '',
+    [`${NEUTRAL_PREFIX}_SHIP_MODE`]: '', [`${NEUTRAL_PREFIX}_TEST_PROJECT`]: '', [`${NEUTRAL_PREFIX}_GUIDE_HANDOFF`]: '',
     // where the hall's Update button goes (task 1004608), empty when no hub origin resolves
     [`${NEUTRAL_PREFIX}_HUB_UPGRADE_URL`]: '',
   });

package/tests/provisioning_env_manifest.mjs

@@ -235,6 +235,10 @@ console.log('\nthe routes:');
 
 let instance = null;
 provisioning.getInstanceById = async (_db, id) => (instance ? { ...instance, id } : null);
+// The routes also admit an owner-made grant (task 1004161) and audit each change: nobody here
+// holds a grant, and the audit rows are not this file's subject.
+require('../modules/provisioning/grants.js').liveGrant = async () => null;
+provisioning.recordEvent = async () => {};
 
 const api = require('../src/module-api.js');
 let builder = { id: 7, rank: 'xenos', github_login: 'owner' };

package/tests/provisioning_env_manifest_edit_delete.mjs

@@ -32,6 +32,8 @@ const express = require('express');
 
 const api = require('../src/module-api.js');
 const provisioning = require('../modules/provisioning/provisioning.js');
+// The gate also admits an owner-made grant (task 1004161, ADR 0407); nobody in this file holds one.
+require('../modules/provisioning/grants.js').liveGrant = async () => null;
 const envManifest = require('../modules/provisioning/env-manifest.js');
 const { attachFail } = require('../src/bongos/middleware/error-envelope.js');