@bongos/core 1.21.4 → 1.21.6

package/tests/wizard_physics_more.mjs

@@ -1,14 +1,22 @@
-// tests/wizard_physics_more.mjs — planet physics, questions 5 to 7, the summary, the
-// voice split and the pre-filled technical steps (task 1004419 / BV2.PS11, goal 1000121).
+// tests/wizard_physics_more.mjs — planet physics, questions 5 to 7, the one plain voice and
+// the prefilled setup (task 1004419 / BV2.PS11, goal 1000121; the planet voice and the
+// question rail retired by task 1004504, PS16; the questions regrouped by the same task).
 //
-// Done-when: a new owner walks from question 1 to "create my planet" with the technical
-// steps pre-filled. So the walk below is RUN end to end — the page's own physics
-// controller sliced out of projects.html into a vm under a DOM stub (the
-// tests/wizard_physics.mjs idiom), its pre-create check answered by the REAL soft-limit
-// table (modules/provisioning/soft-limits.js), never a hand-written verdict. The rest
-// pins each rule on its own: rewards hidden when solo, the framing's suite and its
-// reasons, the voice chosen from the entity (spec D5), the summary's change links, what
-// the create sends, which technical step is skipped, and the forming planet.
+// Since task 1004504 the founder answers the "few quick checks" (country, builders'
+// geography, under-18s, who is behind it) on screen 3, and questions 5 to 7 are rows of the
+// review on screen 4 ("Check what we set up."): Team size, Rewards and We run, each
+// PREFILLED (one person, all managed) and confirmed or changed in place. The summary, the
+// forming planet and the pre-fill notes are gone; confirming a row is the answer.
+//
+// Done-when: a new owner walks from the quick checks to a review whose every row is
+// confirmed, with the setup prefilled. So the walk below is RUN end to end — the page's own
+// physics controller, its team pills, its app choice, the review's row machinery and
+// validateStep, sliced out of projects.html into a vm under a DOM stub built from the
+// screens' own markup (the tests/wizard_physics.mjs idiom), its pre-create check answered by
+// the REAL soft-limit table (modules/provisioning/soft-limits.js), never a hand-written
+// verdict. The rest pins each rule on its own: rewards hidden when solo, the framing's suite
+// and its reasons, the one voice every founder reads (spec D5), what the create sends, and
+// which rows are fixed.
 
 import { strict as assert } from 'node:assert';
 import { test } from 'node:test';
@@ -25,115 +33,176 @@ const HUB = fs.readFileSync(path.join(LANDING, 'projects.html'), 'utf8').replace
 const physics = require('../modules/provisioning/planet-physics.js');
 const { SOFT_LIMIT_RULES, softLimitsFor } = require('../modules/provisioning/soft-limits.js');
 
-const START = '/* ── planet physics, questions 1 to 7 (tasks 1004418 and 1004419, BV2.PS07 + PS11) ──';
-const SCRIPT = HUB.slice(HUB.indexOf(START), HUB.indexOf('    /* per-panel validation on Next */'));
-const PANEL = HUB.slice(HUB.indexOf('<section class="panel" id="panel-physics"'), HUB.indexOf('<!-- step 4 · name'));
+// Every region is cut at code that exists, and every edge is asserted, so a rename fails
+// loudly instead of testing nothing.
+function slice(start, end, what) {
+  const a = HUB.indexOf(start), b = HUB.indexOf(end, a);
+  assert.ok(a > -1, `${what}: the start is on the page`);
+  assert.ok(b > a, `${what}: the end follows it`);
+  return HUB.slice(a, b);
+}
+const SCRIPT = slice('/* ── planet physics (tasks 1004418 and 1004419, BV2.PS07 + PS11; regrouped by task 1004504) ──',
+  '    /* ── checks the old steps made on Next, now made by their rows ── */', 'the physics controller');
+const TEAM = slice('    function teamLabel(t) {', "    $('f-desc').value = state.description || '';", 'the team pills');
+const APP = slice('    function appPlatformChoice() {', '    var ROWS = [', 'the app choice');
+const REVIEW = slice('    var ROWS = [', '    function renderRecap() {', 'the review rows');
+const VALIDATE = slice('    /* per-screen validation on Continue */', "    root.querySelectorAll('.panel form')", 'validateStep');
+for (const [name, region] of [['checksAdvance', SCRIPT], ['paintChecks', SCRIPT], ['physDefaults', SCRIPT], ['confirmRow', REVIEW],
+  ['rowValid', REVIEW], ['rowFixed', REVIEW], ['paintSetup', REVIEW], ['validateStep', VALIDATE], ['paintTeam', TEAM]]) {
+  assert.ok(region.includes(`function ${name}(`), `the slice carries ${name}()`);
+}
+// the screens the controller paints: the quick checks and the review
+const PANEL = slice('<section class="panel" id="panel-checks"', '<!-- 5 · a look, then Create', 'the checks and review markup');
 const plain = (v) => JSON.parse(JSON.stringify(v)); // values born in the vm
 
-// ── a small DOM: the panel's own elements, matched by attribute ──────────────
+// ── a small DOM: the screens' own elements, as a tree, matched by selector ────
 class El {
   constructor(tag, attrs = {}) {
-    this.tagName = tag; this.attrs = { ...attrs }; this.hidden = 'hidden' in attrs; this.disabled = false;
+    this.tagName = tag; this.attrs = { ...attrs }; this.hidden = 'hidden' in attrs; this.disabled = 'disabled' in attrs;
     this.value = attrs.value || ''; this.textContent = ''; this.title = ''; this.className = attrs.class || '';
-    this.listeners = {}; this.children = []; this.options = [{}];
+    this.listeners = {}; this.children = []; this.options = [{}]; this.parent = null; this.checked = 'checked' in attrs;
     const self = this;
     this.classes = new Set(this.className.split(/\s+/).filter(Boolean));
-    this.classList = { toggle(c, on) { if (on) self.classes.add(c); else self.classes.delete(c); }, contains: (c) => self.classes.has(c), add: (c) => self.classes.add(c) };
+    this.classList = { toggle(c, on) { if (on) self.classes.add(c); else self.classes.delete(c); }, contains: (c) => self.classes.has(c),
+      add: (c) => self.classes.add(c), remove: (c) => self.classes.delete(c) };
   }
   setAttribute(k, v) { this.attrs[k] = String(v); }
   getAttribute(k) { return k in this.attrs ? this.attrs[k] : null; }
+  hasAttribute(k) { return k in this.attrs; }
   removeAttribute(k) { delete this.attrs[k]; }
   addEventListener(t, fn) { this.listeners[t] = fn; }
-  click() { this.listeners.click && this.listeners.click({ target: this }); }
-  appendChild(c) { this.children.push(c); if (this.tagName === 'select') this.options.push(c); return c; }
+  // a click runs the element's own listener, then bubbles to the delegated ones above it
+  click() { for (let n = this; n; n = n.parent) if (n.listeners.click) n.listeners.click({ target: this }); }
+  appendChild(c) { this.children.push(c); c.parent = this; if (this.tagName === 'select') this.options.push(c); return c; }
   removeChild(c) { const i = this.children.indexOf(c); if (i !== -1) this.children.splice(i, 1); if (this.tagName === 'select') this.options.pop(); }
   get firstChild() { return this.children[0] || null; }
   get lastChild() { return this.tagName === 'select' ? this.options[this.options.length - 1] : this.children[this.children.length - 1]; }
   focus() {}
-  text() { return this.textContent + this.children.map((c) => c.text()).join(''); }
+  descendants() { return this.children.flatMap((c) => [c, ...c.descendants()]); }
+  querySelectorAll(sel) { return this.descendants().filter((e) => matches(e, sel)); }
+  querySelector(sel) { return this.querySelectorAll(sel)[0] || null; }
+  closest(sel) { for (let n = this; n && n.tagName !== '#root'; n = n.parent) if (matches(n, sel)) return n; return null; }
 }
-
 function parseAttrs(s) {
   const out = {};
   for (const m of s.matchAll(/([a-zA-Z-]+)(?:="([^"]*)")?/g)) out[m[1]] = m[2] === undefined ? '' : m[2];
   return out;
 }
+function compound(c) {
+  const bare = c.replace(/\[[^\]]*\]/g, '');
+  return {
+    tag: (bare.match(/^[a-z][a-z0-9]*/i) || [null])[0],
+    id: (bare.match(/#([\w-]+)/) || [])[1],
+    classes: [...bare.matchAll(/\.([\w-]+)/g)].map((m) => m[1]),
+    attrs: [...c.matchAll(/\[([\w-]+)(?:="?([^"\]]*)"?)?\]/g)].map((m) => [m[1], m[2]]),
+  };
+}
+function fits(el, c) {
+  if (c === '#view-new') return true; // every element here lives inside the wizard's view
+  const p = compound(c);
+  if (p.tag && el.tagName !== p.tag) return false;
+  if (p.id && el.attrs.id !== p.id) return false;
+  if (p.classes.some((k) => !el.classes.has(k))) return false;
+  return p.attrs.every(([k, v]) => k in el.attrs && (v === undefined || el.attrs[k] === v));
+}
+function matches(el, sel) {
+  return sel.split(',').some((group) => {
+    const parts = group.trim().split(/\s+/);
+    if (!fits(el, parts[parts.length - 1])) return false;
+    let n = el.parent;
+    for (let i = parts.length - 2; i >= 0; i -= 1) {
+      if (parts[i] === '#view-new') continue;
+      while (n && !fits(n, parts[i])) n = n.parent;
+      if (!n) return false;
+      n = n.parent;
+    }
+    return true;
+  });
+}
+const VOID = new Set(['input', 'img', 'br', 'hr', 'path', 'source']);
 function buildDom() {
-  const all = [];
+  const top = new El('#root');
   const byId = {};
-  for (const m of PANEL.matchAll(/<(button|div|p|ul|fieldset|span|li|img|input|select|output|dd|legend|h1|ol|dl|form|label)\b([^>]*)>/g)) {
-    const el = new El(m[1], parseAttrs(m[2]));
-    all.push(el);
+  let cur = top;
+  const raw = new Map();
+  const src = PANEL.replace(/<!--[\s\S]*?-->/g, '');
+  for (const m of src.matchAll(/<(\/?)([a-zA-Z][a-zA-Z0-9]*)\b([^>]*?)(\/?)>|([^<]+)/g)) {
+    if (m[5] !== undefined) { raw.set(cur, (raw.get(cur) || '') + m[5]); continue; }
+    const tag = m[2].toLowerCase();
+    if (m[1]) {
+      for (let n = cur; n !== top; n = n.parent) {
+        if (n.tagName === tag) {
+          // a leaf's words are its text, as the browser would read them
+          if (!n.children.length) n.textContent = (raw.get(n) || '').replace(/&nbsp;/g, ' ').replace(/&amp;/g, '&').replace(/\s+/g, ' ').trim();
+          cur = n.parent; break;
+        }
+      }
+      continue;
+    }
+    const el = new El(tag, parseAttrs(m[3]));
+    el.parent = cur; cur.children.push(el);
     if (el.attrs.id) byId[el.attrs.id] = el;
+    if (!VOID.has(tag) && !m[4]) cur = el;
   }
-  // the stage's moons and ghosts are the children of their wrappers, in markup order
-  const kids = (id) => {
-    const at = PANEL.indexOf(`id="${id}"`);
-    const chunk = PANEL.slice(at, PANEL.indexOf('</span>', at));
-    const n = (chunk.match(/<img /g) || []).length;
-    return all.filter((e) => e.tagName === 'img' && e.attrs.src && e.attrs.src.includes('bead')).slice(id === 'physGhosts' ? 0 : 4, id === 'physGhosts' ? n : 4 + n);
-  };
-  const lists = { '#physMoons img': kids('physMoons'), '#physGhosts img': kids('physGhosts') };
-  lists['#physMoons img, #physGhosts img'] = [...lists['#physMoons img'], ...lists['#physGhosts img']];
-  const matches = (el, compound) => {
-    if (compound.startsWith('.')) return el.classes.has(compound.slice(1));
-    for (const m of compound.matchAll(/\[([a-z-]+)(?:="([^"]*)")?\]/g)) {
-      if (!(m[1] in el.attrs)) return false;
-      if (m[2] !== undefined && el.attrs[m[1]] !== m[2]) return false;
-    }
-    return /\[/.test(compound);
-  };
-  const root = {
-    querySelectorAll(sel) {
-      if (lists[sel]) return lists[sel];
-      if (sel === '#physRail li') return all.filter((e) => e.tagName === 'li' && 'data-q' in e.attrs);
-      if (sel === '#physStage .physBelt') return all.filter((e) => e.classes.has('physBelt'));
-      if (sel === '#panel-physics .physQ') return all.filter((e) => e.classes.has('physQ'));
-      const last = sel.trim().split(/\s+/).pop();
-      return all.filter((e) => matches(e, last));
-    },
-    querySelector(sel) { return this.querySelectorAll(sel)[0] || null; },
-  };
-  return { all, byId, root };
+  return { top, byId, root: top };
 }
 
-// the pre-create check, answered by the real table
-function boot({ check = (body) => ({ stop: false, soft_limits: softLimitsFor(body.detail) }), draft = {} } = {}) {
+// the pre-create check, answered by the real table; /provisioning/instances by `instances`
+function boot({ check = (body) => ({ stop: false, soft_limits: softLimitsFor(body.detail) }), draft = {}, instances = [], renderOk = true } = {}) {
   const dom = buildDom();
   const els = { ...dom.byId };
   const $ = (id) => (els[id] = els[id] || new El('div', { id }));
   const shown = [];
   const fetched = [];
-  const state = Object.assign({ description: '', teamShape: null, physics: null, projType: null, mode: 'greenfield', appPlatform: 'later', demo: null }, draft);
+  const state = Object.assign({ step: 4, name: 'Kestrel', description: '', teamShape: null, physics: null, projType: 'game', mode: 'greenfield',
+    appPlatform: 'later', demo: null, modules: null, confirmed: {}, termsAck: true }, draft);
   const sandbox = {
     $, state, API: '/api/bongos', root: dom.root, Intl,
     document: { createElement: (t) => new El(t) },
-    saveDraft() {}, show(n) { shown.push(n); },
+    saveDraft() {}, show(n) { shown.push(n); state.step = n; },
+    setMode(m) { state.mode = m; }, authKnown: true,
+    // the code, address and Render checks are their own files' to run (projects_hub_app_step,
+    // public_landing_projects); here they answer as told
+    validateCode: () => true, validateAddress: () => true, validateRender: () => renderOk,
+    checkSlugAvailable() {}, renderAddrPanel() {}, renderModules() {}, syncHome() {}, syncRenderSetup() {}, renderLater: () => false,
+    slugAvailState: () => 'free', looksLikeDomain: () => false, resolvedDomain: () => 'kestrel.example.com',
+    // the extras row's words are tests/projects_hub_module_picker.mjs's
+    starterBundles: { optional: [{ key: 'discord', label: 'Discord' }] }, pickedModules: () => ['discord'], extrasRow: () => '', typeLabel: () => 'Game',
     fetch: async (url, opts) => {
       const body = opts && opts.body ? JSON.parse(opts.body) : null;
       fetched.push({ url, body });
-      return { ok: true, json: async () => (url.includes('physics-check') ? check(body) : []) };
+      return { ok: true, json: async () => (url.includes('physics-check') ? check(body) : instances) };
     },
   };
   vm.createContext(sandbox);
-  vm.runInContext(SCRIPT, sandbox, { filename: 'projects.html#physics' });
+  vm.runInContext([TEAM, SCRIPT, APP, REVIEW, VALIDATE].join('\n'), sandbox, { filename: 'projects.html#physics' });
   const q = (sel) => dom.root.querySelectorAll(sel);
+  const row = (key) => q(`#reviewRows .setRow[data-row="${key}"]`)[0];
   return {
-    state, $, shown, fetched, q, dom,
+    state, $, shown, fetched, q, dom, row,
     run: (code) => vm.runInContext(code, sandbox),
     a: () => state.physics.answers,
     pick: (key, val) => q(`[data-phys="${key}"][data-val="${val}"]`)[0].click(),
-    next: async () => { sandbox.$('physNext'); vm.runInContext('physAdvance()', sandbox); await tick(); await tick(); },
+    rowSays: (key) => [row(key).querySelector('[data-row-v]').textContent, row(key).querySelector('[data-row-s]').textContent],
+    ok: (key) => row(key).querySelector('[data-row-ok]').click(),
+    change: (key) => row(key).querySelector('[data-row-chg]').click(),
+    use: (key) => row(key).querySelector('[data-row-use]').click(),
+    isOpen: (key) => !row(key).querySelector('.opts').hidden,
+    go: () => $('reviewGo'),
+    settle: async () => { for (let i = 0; i < 4; i += 1) await tick(); },
   };
 }
 const tick = () => new Promise((r) => setTimeout(r, 0));
-// questions 1 to 4, answered (the Kestrel sample of the canvas, a new planet)
-const FOUR = { project_state: 'new', home_country: 'US', home_region: 'US-CA', builder_geography: 'us-eu', minors_on_board: false, entity: 'intent-solo' };
-function at(q, answers = FOUR, opts = {}) {
+// the quick checks, answered (the Kestrel sample of the canvas)
+const CHECKS = { home_country: 'US', home_region: 'US-CA', builder_geography: 'us-eu', minors_on_board: false, entity: 'intent-solo' };
+// on the review, with the checks answered, the prefills written and the table asked
+async function onReview(answers = {}, opts = {}) {
   const w = boot(opts);
   w.run('phys()');
-  Object.assign(w.state.physics.answers, answers);
-  w.run(`physGo(${JSON.stringify(q)})`);
+  Object.assign(w.state.physics.answers, CHECKS, answers);
+  w.run('physDefaults()');
+  const res = await w.run('physCheck()');
+  w.run(`physLimits = ${JSON.stringify(res.soft_limits.limits)}; paintSetup();`);
   return w;
 }
 
@@ -141,24 +210,23 @@ function at(q, answers = FOUR, opts = {}) {
 test('the page carries the server\'s rewards, framings and services, in order, and says every one', () => {
   const box = {};
   vm.createContext(box);
-  vm.runInContext(SCRIPT.slice(0, SCRIPT.indexOf('    var PHYS_LAST')).replace(/\bvar /g, 'this.'), box);
+  vm.runInContext(SCRIPT.slice(0, SCRIPT.indexOf('    var physLimits = [];')).replace(/\bvar /g, 'this.'), box);
   const Q = physics.PLANET_PHYSICS_QUESTIONS;
   assert.deepEqual(plain(box.PHYS_REWARDS), [...Q.reward_intents.values]);
   assert.deepEqual(plain(box.PHYS_FRAMINGS), [...Q.framing.values]);
   assert.deepEqual(plain(box.PHYS_SERVICES), [...Q.services.values]);
-  assert.deepEqual(Object.keys(box.PHYS_ORBIT), [...Q.framing.values]);
   for (const key of ['project_state', 'builder_geography', 'entity', 'reward_intents', 'framing', 'services']) {
-    assert.deepEqual(Object.keys(box.PHYS_SAY[key]).sort(), [...Q[key].values].sort(), `the summary can say every ${key}`);
+    assert.deepEqual(Object.keys(box.PHYS_SAY[key]).sort(), [...Q[key].values].sort(), `the review can say every ${key}`);
   }
-  for (const org of box.PHYS_ORGS) assert.ok(physics.ENTITY_FORMS.includes(org), `${org} is a formed entity`);
+  assert.deepEqual(plain(box.PHYS_SAY.reward_intents), { 'non-monetary': 'Learning and fun', cash: 'Cash for work', equity: 'Equity', 'future-payouts': 'Future payouts' },
+    'the reward words are the review\'s pills (task 1004504)');
+  assert.equal(box.PHYS_ORGS, undefined, 'the organization list that picked the voice is gone (task 1004504)');
+  assert.equal(box.PHYS_ORBIT, undefined, 'the orbit per framing left with the forming planet');
+  assert.equal(box.PHYS_TYPE, undefined, 'the kind is the founder\'s own answer now, never pre-filled from the entity');
   for (const [f, list] of Object.entries(box.PHYS_SUITE_START)) {
     assert.ok(['hybrid', 'local'].includes(f));
     assert.notEqual(physics.canonicalAnswer(Q.services, plain(list)), undefined, `${f}'s starting suite is a services answer`);
   }
-  const TYPES = ['game', 'research', 'business', 'non-profit', 'not-sure'];
-  for (const [entity, type] of Object.entries(box.PHYS_TYPE)) {
-    assert.ok(Q.entity.values.includes(entity)); assert.ok(TYPES.includes(type), `${type} is a project type`);
-  }
 });
 
 test('the kit stub\'s physics hide rules are the table\'s own, word for word', () => {
@@ -174,50 +242,149 @@ test('the kit stub\'s physics hide rules are the table\'s own, word for word', (
   }
 });
 
-// ── question 5 ───────────────────────────────────────────────────────────────
-test('question 5: one or many, a start count, and a guessed growth the founder corrects', async () => {
-  const w = at(5);
-  await w.next();
-  assert.equal(w.state.physics.q, 5, 'unanswered: it stays');
-  assert.match(w.$('h-phys').textContent, /one or many/);
+// ── screen 3, the quick checks ───────────────────────────────────────────────
+test('the quick checks reveal what an answer opens: the age tiers, the legal forms, a state or province', () => {
+  const w = boot({ draft: { step: 3 } });
+  w.run('paintChecks()');
+  assert.equal(w.$('physAges').hidden, true, 'no tiers before a yes');
+  assert.equal(w.$('physForms').hidden, true, 'the plain intents first');
+  assert.equal(w.$('physIntent').hidden, false);
+  w.pick('minors_on_board', 'true');
+  assert.equal(w.a().minors_on_board, true);
+  assert.equal(w.$('physAges').hidden, false, 'a yes shows the tiers young builders work under');
+  assert.equal(w.q('[data-phys="minors_on_board"][data-val="true"]')[0].getAttribute('aria-pressed'), 'true');
+  w.pick('minors_on_board', 'true');
+  assert.equal(w.a().minors_on_board, null, 'a second click un-says it');
+  assert.equal(w.$('physAges').hidden, true);
+  w.$('physHaveEntity').click();
+  assert.equal(w.$('physForms').hidden, false, 'an existing entity opens the full legal list');
+  assert.equal(w.$('physIntent').hidden, true);
+  w.pick('entity', 'single-owner-llc');
+  assert.equal(w.a().entity, 'single-owner-llc');
+  w.$('physNoEntity').click();
+  assert.equal(w.$('physForms').hidden, true, 'and the way back closes it');
+  assert.equal(w.a().entity, null, 'taking the legal form with it');
+  w.$('physCountry').value = 'US';
+  w.$('physCountry').listeners.change();
+  assert.equal(w.$('physRegionField').hidden, false, 'a country with states asks for one');
+  assert.ok(w.$('physRegion').children.some((o) => o.value === 'US-CA'));
+  w.$('physCountry').value = 'NL';
+  w.$('physCountry').listeners.change();
+  assert.equal(w.$('physRegionField').hidden, true, 'and one without does not');
+});
+
+test('the quick checks fill in from the account\'s last project, never its state, and offer nothing without one', async () => {
+  const none = boot({ draft: { step: 3 } });
+  none.run('physLoadAccountOnce()');
+  await none.settle();
+  assert.equal(none.$('physFillOffer').hidden, true, 'no earlier answers: no offer');
+  const w = boot({ draft: { step: 3 }, instances: { instances: [
+    { created_at: '2026-01-01', detail: { home_country: 'GB', entity: 'intent-unsure' } },
+    { created_at: '2026-06-01', detail: { home_country: 'NL', builder_geography: 'global', minors_on_board: false, entity: 'for-profit', project_state: 'existing', framing: 'local' } },
+  ] } });
+  w.run('physLoadAccountOnce()');
+  await w.settle();
+  assert.equal(w.$('physFillOffer').hidden, false);
+  w.$('physFromAccount').click();
+  assert.deepEqual(plain(w.a()), { home_country: 'NL', builder_geography: 'global', minors_on_board: false, entity: 'for-profit' }, 'the newest project\'s four checks, and nothing of its own');
+  assert.equal(w.$('physCountry').value, 'NL', 'painted where the founder can see it');
+});
+
+test('Continue on the checks writes the review\'s prefills, asks the real table, and opens the review', async () => {
+  const w = boot({ draft: { step: 3, description: 'A field guide app for birdwatchers' } });
+  w.run('phys()');
+  Object.assign(w.a(), CHECKS);
+  assert.equal(w.run('checksAdvance()'), false, 'the screen never says yes itself');
+  await w.settle();
+  assert.deepEqual(w.shown, [4]);
+  const sent = w.fetched.find((f) => f.url.endsWith('/provisioning/physics-check')).body;
+  assert.equal(sent.description, 'A field guide app for birdwatchers');
+  assert.deepEqual({ s: sent.detail.project_state, f: sent.detail.framing, n: [sent.detail.builders_at_start, sent.detail.builders_expected] },
+    { s: 'new', f: 'managed', n: [1, 1] }, 'a new project, all managed, one person');
+  assert.equal(w.state.teamShape, 'solo');
+  assert.ok(w.run('physLimits').some((l) => l.option === 'reward_intents' && l.effect === 'hide'), 'the table\'s verdicts shape the review');
+});
+
+test('a stop from the server ends on the stop screen, before anything exists', async () => {
+  const w = boot({ draft: { step: 3, description: 'ransomware' }, check: () => ({ stop: true, message: 'We cannot host this.' }) });
+  w.run('phys()');
+  Object.assign(w.a(), CHECKS);
+  w.run('checksAdvance()');
+  await w.settle();
+  assert.deepEqual(w.shown, [], 'no review');
+  assert.equal(w.$('physStopMsg').textContent, 'We cannot host this.');
+  assert.equal(w.$('checksStop').hidden, false);
+  assert.equal(w.$('checksMain').hidden, true);
+});
+
+// ── the Team size row (question 5) ───────────────────────────────────────────
+test('Team size: one or many, a start count, and a guessed growth the founder corrects', async () => {
+  const w = await onReview();
+  assert.deepEqual(w.rowSays('team'), ['One person', 'Just you.'], 'prefilled: one person');
+  assert.equal(w.q('[data-phys-solo="one"]')[0].getAttribute('aria-pressed'), 'true');
+  assert.equal(w.$('physTeam').hidden, true);
+  w.change('team');
+  assert.equal(w.isOpen('team'), true);
   w.q('[data-phys-solo="many"]')[0].click();
   assert.equal(w.a().builders_at_start, 2);
   assert.equal(w.a().builders_expected, 5, 'the guess: about 2.6 times the start');
+  assert.equal(w.state.teamShape, 'small-team', 'a team invites its people by default');
   assert.equal(w.$('physTeam').hidden, false);
   w.q('[data-phys-count="1"]')[0].click();
   assert.equal(w.a().builders_at_start, 3);
   assert.equal(w.a().builders_expected, 8, 'the guess follows the start');
-  assert.deepEqual([w.$('physM1').textContent, w.$('physM2').textContent, w.$('physM3').textContent], ['3', '5', '8'], 'the canvas\'s three months');
-  assert.match(w.$('physGuessLine').textContent, /about 8 builders by month three/);
+  assert.equal(w.$('physStartN').textContent, '3');
+  assert.match(w.$('physGuessLine').textContent, /about 8 people by month three/);
   w.$('physExpected').value = '12';
   w.$('physExpected').listeners.input();
   assert.equal(w.a().builders_expected, 12, 'the founder corrects it');
   w.q('[data-phys-count="1"]')[0].click();
   assert.equal(w.a().builders_expected, 12, 'and once corrected the guess stays theirs');
-  assert.equal(w.q('[data-phys-solo="many"]')[0].getAttribute('aria-pressed'), 'true');
-  await w.next();
-  assert.equal(w.state.physics.q, 6, 'a team goes on to rewards');
+  assert.deepEqual(w.rowSays('team'), ['4 people now', 'About 12 by month three · people you invite.']);
+  w.state.teamShape = 'community'; w.run('paintSetup()');
+  assert.equal(w.rowSays('team')[1], 'About 12 by month three · anyone can apply.');
+  w.use('team');
+  assert.equal(w.state.confirmed.team, true);
+  assert.equal(w.isOpen('team'), false, 'Use this closes the row');
 });
 
-test('rewards are hidden when solo: the table says so, the walk skips question 6, the create sends none', async () => {
-  const w = at(5, { ...FOUR, reward_intents: ['cash'] });
+test('changing the team re-asks the rows it moves: rewards and extras', async () => {
+  const w = await onReview({ builders_at_start: 3, builders_expected: 8 });
+  w.state.confirmed = { rewards: true, extras: true, code: true };
   w.q('[data-phys-solo="one"]')[0].click();
-  assert.equal(w.a().builders_at_start, 1);
-  assert.equal(w.a().builders_expected, 1);
-  assert.equal(w.$('physTeam').hidden, true);
-  await w.next();
-  assert.equal(w.state.physics.q, 7, 'straight to framing');
-  assert.ok(w.fetched.at(-1).body.detail.builders_at_start === 1, 'the check was asked with the answer');
-  const rail6 = w.q('#physRail li').find((li) => li.attrs['data-q'] === '6');
-  assert.ok(rail6.classList.contains('skipped'), 'the rail strikes it');
-  assert.equal(w.run('createDetail()').reward_intents, undefined, 'nothing answered for a question never asked');
-  w.$('physBack').listeners.click();
-  assert.equal(w.state.physics.q, 5, 'Back steps over it too');
+  assert.deepEqual(Object.keys(w.state.confirmed), ['code'], 'rewards and extras come back to be confirmed; the repo does not');
+  assert.equal(w.state.teamShape, 'solo');
+});
+
+test('a team row with no count cannot be confirmed: it opens instead', async () => {
+  const w = await onReview();
+  w.state.physics.answers.builders_at_start = 4; w.state.physics.answers.builders_expected = 2;   // fewer later than now
+  assert.equal(w.run("confirmRow('team')"), false);
+  assert.equal(w.isOpen('team'), true, 'the row opens with its controls');
+  assert.equal(w.row('team').classList.contains('open'), true);
+  assert.equal(w.row('team').querySelector('[data-row-chg]').getAttribute('aria-expanded'), 'true');
+  assert.equal(w.state.confirmed.team, undefined);
+});
+
+// ── the Rewards row (question 6) ─────────────────────────────────────────────
+test('rewards are hidden for a solo founder: the real table hides the row, and the create sends none', async () => {
+  const w = await onReview({ reward_intents: ['cash'] });
+  assert.equal(w.run("rowApplies('rewards')"), false, 'the REAL softLimitsFor hides reward_intents for one-and-one');
+  assert.equal(w.row('rewards').hidden, true, 'and the row goes with it');
+  assert.ok(!w.run('unconfirmedRows()').includes('rewards'), 'nothing to confirm for a question never asked');
+  assert.equal(w.go().textContent, 'Confirm 6 more', 'six rows apply');
+  assert.equal(w.run('createDetail()').reward_intents, undefined);
+  w.change('team');
+  w.q('[data-phys-solo="many"]')[0].click();
+  await w.settle();
+  assert.equal(w.row('rewards').hidden, false, 'a team brings the question back, once the table is asked again');
+  assert.equal(w.go().textContent, 'Confirm 7 more');
 });
 
 test('rewards: a greyed option is disabled and leaves the list, and each reason is said once', async () => {
-  const w = at(6, { ...FOUR, minors_on_board: true, builders_at_start: 3, builders_expected: 8 });
-  await w.run('physCheck()').then((res) => { w.run(`physLimits = ${JSON.stringify(res.soft_limits.limits)}`); });
+  const w = await onReview({ minors_on_board: true, builders_at_start: 3, builders_expected: 8 });
+  assert.deepEqual(w.rowSays('rewards'), ['Not decided yet', 'Intent only. You set the real terms later.']);
+  w.change('rewards');
   w.pick('reward_intents', 'non-monetary');
   w.pick('reward_intents', 'future-payouts');
   assert.deepEqual(plain(w.a().reward_intents), ['non-monetary', 'future-payouts']);
@@ -227,23 +394,24 @@ test('rewards: a greyed option is disabled and leaves the list, and each reason
   const list = w.q('[data-why-list="reward_intents"]')[0];
   assert.equal(list.hidden, false);
   const lines = list.children.map((li) => li.textContent);
-  assert.ok(lines.some((l) => /^Equity or shares: Equity is off until you form a company/.test(l)), lines.join('\n'));
+  assert.ok(lines.some((l) => /^Equity: Equity is off until you form a company/.test(l)), lines.join('\n'));
   assert.equal(lines.filter((l) => /13 to 15/.test(l)).length, 1, 'the minors reason names its three options in one line');
-  assert.ok(lines.some((l) => /^Cash for work, Equity or shares, Future profits or payouts: Builders aged 13 to 15/.test(l)));
+  assert.ok(lines.some((l) => /^Cash for work, Equity, Future payouts: Builders aged 13 to 15/.test(l)));
   assert.ok(lines.some((l) => /^Cash for work: Cash payouts to builders in the EU/.test(l)), 'a note is said too');
+  assert.deepEqual(w.rowSays('rewards'), ['Learning and fun, Future payouts', 'Intent only. You set the real terms later.']);
   w.pick('reward_intents', 'future-payouts');
   assert.deepEqual(plain(w.a().reward_intents), ['non-monetary'], 'a second click takes one away');
-  await w.next();
-  assert.equal(w.state.physics.q, 7);
 });
 
-// ── question 7 ───────────────────────────────────────────────────────────────
-test('framing: hybrid and local open the suite pre-picked; managed and open source hide it with the table\'s reason', async () => {
-  const w = at(7, { ...FOUR, builders_at_start: 3, builders_expected: 8, reward_intents: ['non-monetary'] });
-  await w.next();
-  assert.equal(w.state.physics.q, 7, 'no framing: it stays');
+// ── the We run row (question 7) ──────────────────────────────────────────────
+test('We run: hybrid and local open the suite pre-picked; managed and open source hide it with the table\'s reason', async () => {
+  const w = await onReview({ builders_at_start: 3, builders_expected: 8, reward_intents: ['non-monetary'] });
+  assert.deepEqual(w.rowSays('run'), ['Everything, for you', 'Hosting, payouts and the starter kit, managed.'], 'prefilled: all managed');
+  w.state.confirmed.app = true;
+  w.change('run');
   w.pick('framing', 'hybrid');
-  await tick(); await tick();
+  await w.settle();
+  assert.equal(w.state.confirmed.app, undefined, 'a new framing re-asks the App hosting row');
   assert.deepEqual(plain(w.a().services), ['hosting', 'starter-kit', 'marketplace-buy', 'guild-access'], 'the canvas\'s hybrid suite');
   assert.equal(w.$('physSuite').hidden, false);
   assert.equal(w.$('physSuiteLbl').textContent, 'Your hybrid suite');
@@ -252,219 +420,202 @@ test('framing: hybrid and local open the suite pre-picked; managed and open sour
   assert.equal(w.q('[data-phys="services"][data-val="public-marketing"]')[0].disabled, true, 'on request');
   w.pick('services', 'marketplace-sell');
   assert.ok(w.a().services.includes('marketplace-sell'));
+  assert.deepEqual(w.rowSays('run'), ['Some of it', 'Hosting, Starting module kit, Module marketplace: buy, Module marketplace: sell, Builder guild access']);
   w.pick('framing', 'local');
-  await tick(); await tick();
+  await w.settle();
   assert.ok(w.a().services.includes('marketplace-sell'), 'a suite the founder touched is theirs: not re-seeded');
+  assert.equal(w.$('physSuiteLbl').textContent, 'Your local suite');
   w.pick('framing', 'managed');
-  await tick(); await tick();
+  await w.settle();
   assert.equal(w.$('physSuite').hidden, true);
   const why = w.q('[data-why="services"]')[0];
   assert.equal(why.hidden, false);
   assert.equal(why.textContent, SOFT_LIMIT_RULES.find((r) => r.id === 'managed-includes-every-service').reason);
   assert.equal(w.run('createDetail()').services, undefined, 'all managed sends no suite');
-  assert.equal(w.$('physStage').getAttribute('data-orbit'), 'near');
-  await w.next();
-  assert.equal(w.state.physics.q, 'sum');
+  w.pick('framing', 'managed');
+  assert.equal(w.a().framing, null, 'a second click un-says it');
+  assert.equal(w.run("rowValid('run')"), false, 'and a run row with no framing cannot be confirmed');
 });
 
 test('a company already formed hides company creation from the suite', async () => {
-  const w = at(7, { ...FOUR, entity: 'for-profit', builders_at_start: 3, builders_expected: 8, reward_intents: ['equity'] });
+  const w = await onReview({ entity: 'for-profit', builders_at_start: 3, builders_expected: 8, reward_intents: ['equity'] });
   w.pick('framing', 'hybrid');
-  await tick(); await tick();
+  await w.settle();
   assert.equal(w.q('[data-phys="services"][data-val="company-creation"]')[0].hidden, true);
 });
 
-// ── the voice (spec D5) ──────────────────────────────────────────────────────
-test('the voice is chosen from the entity: professional for an organization, the planet\'s for everyone else', () => {
-  for (const [entity, voice] of [['for-profit', 'professional'], ['nonprofit', 'professional'], ['research', 'professional'], ['corporate-division', 'professional'],
-    ['intent-company', 'planet'], ['intent-solo', 'planet'], ['social-group', 'planet'], ['university-project', 'planet'], ['private-individual', 'planet'], ['single-owner-llc', 'planet']]) {
-    const w = at(5, { ...FOUR, entity });
-    assert.equal(w.run('physVoice()'), voice, entity);
-    assert.equal(w.run('createDetail()').voice, voice, `${entity} stores the voice it reads`);
-    const pro = w.q('[data-voice="pro"]'), planet = w.q('[data-voice="planet"]');
-    assert.ok(pro.length >= 10 && planet.length === pro.length, 'both variants are baked, pair by pair');
-    assert.ok(pro.every((e) => e.hidden === (voice !== 'professional')), `${entity}: the professional copy shows only for an organization`);
-    assert.ok(planet.every((e) => e.hidden === (voice === 'professional')), `${entity}: the planet copy otherwise`);
+// ── fixed rows: the App hosting row on your own machines, and a demo's own answers ──
+test('a planet on its own machines fixes the App hosting row: it says so, confirms without the Render check, and never opens', async () => {
+  for (const [framing, fixed] of [['managed', false], ['hybrid', false], ['local', true], ['open-source', true]]) {
+    const w = await onReview({ framing }, { renderOk: false });
+    assert.equal(w.run("rowFixed('app')"), fixed, framing);
+    assert.equal(w.row('app').querySelector('[data-row-chg]').hidden, fixed, `${framing}: Change is ${fixed ? 'gone' : 'offered'}`);
+    assert.equal(w.run("confirmRow('app')"), fixed, `${framing}: ${fixed ? 'confirmed without' : 'held by'} the Render check`);
+    if (fixed) assert.equal(w.rowSays('app')[0], 'Runs on your own machines');
+    else assert.equal(w.isOpen('app'), true, 'a failed check opens the row with its reason');
   }
-  const pro = at(5, { ...FOUR, entity: 'for-profit', builders_at_start: 12, builders_expected: 30 });
-  assert.match(pro.$('physGuessLine').textContent, /we estimate 30 contributors by month three/);
-  assert.equal(pro.$('physCapLbl').textContent, 'project profile');
-  assert.match(pro.$('physCoords').textContent, /team 12 → 30/);
-  const planet = at(5, { ...FOUR, builders_at_start: 3, builders_expected: 8 });
-  assert.match(planet.$('physCallout').textContent, /moons · 3 builders now · the dashed orbit holds about 8/);
+  const demo = await onReview({ framing: 'local' }, { renderOk: false, draft: { demo: { people: 3, hours_each: 4 } } });
+  assert.equal(demo.run("rowFixed('app')"), false, 'a demo is all managed, whatever framing a walk left behind');
 });
 
-test('the voice variants are worded apart: the professional copy carries no planet words', () => {
-  const pro = [...PANEL.matchAll(/<span data-voice="pro" hidden>([^<]*)/g)].map((m) => m[1]);
-  assert.ok(pro.length >= 10);
-  for (const t of pro) assert.doesNotMatch(t, /planet|moon|orbit/i, t);
+test('a demo\'s team, rewards and run are the demo\'s own: fixed, said plainly, never opened', async () => {
+  const w = await onReview({}, { draft: { demo: { people: 3, hours_each: 4, idea: '', invites: [] } } });
+  for (const key of ['team', 'rewards', 'run']) {
+    assert.equal(w.run(`rowFixed('${key}')`), true, key);
+    assert.equal(w.row(key).querySelector('[data-row-chg]').hidden, true, `${key}: no Change`);
+    w.run(`openRow('${key}')`);
+    assert.equal(w.isOpen(key), false, `${key}: never opens`);
+  }
+  assert.deepEqual(w.rowSays('team'), ['3 people', '4 hours each. When the time box runs out, we ask if you want to keep it.']);
+  assert.deepEqual(w.rowSays('rewards'), ['None', 'It’s a demo, for learning.']);
+  assert.deepEqual(w.rowSays('run'), ['Everything, for you', 'A demo is all managed and private to your team.']);
 });
 
-// ── the summary ──────────────────────────────────────────────────────────────
-const SEVEN = { ...FOUR, builders_at_start: 3, builders_expected: 8, reward_intents: ['non-monetary', 'future-payouts'], framing: 'hybrid', services: ['hosting', 'starter-kit'] };
-test('the summary lists every answer with a change link back to its question', async () => {
-  const w = at('sum', SEVEN);
-  w.state.description = 'A field guide app for birdwatchers';
-  w.run('paintPhysics()');
-  const dl = w.$('physSummary');
-  const dts = dl.children.filter((c) => c.tagName === 'dt').map((c) => c.textContent);
-  assert.deepEqual(dts, ['State', 'Geography', 'Under 18', 'You are', 'Builders', 'Rewards', 'Framing']);
-  const dds = dl.children.filter((c) => c.tagName === 'dd');
-  const said = dds.map((dd) => dd.children[0].text());
-  assert.match(said[0], /^NewA field guide app for birdwatchers$/);
-  assert.match(said[1], /^United States \(California\)Builders in the US and EU$/);
-  assert.match(said[4], /^3 nowAbout 8 by month three$/);
-  assert.match(said[5], /^Non-monetary, Future profits or payoutsIntent only$/);
-  assert.match(said[6], /^HybridHosting, Starting module kit$/);
-  const gotos = dds.map((dd) => dd.children[1]);
-  assert.deepEqual(gotos.map((b) => b.getAttribute('data-phys-goto')), ['1', '2', '3', '4', '5', '6', '7']);
-  assert.ok(gotos.every((b) => b.textContent === 'change' && b.type === 'button'));
-  assert.equal(w.$('physNext').textContent, 'Create my planet →');
-  assert.ok(w.q('#physRail li').every((li) => li.classList.contains('done')), 'the rail reads complete');
-  gotos[4].listeners.click();
-  assert.equal(w.state.physics.q, 5, 'change goes back to that question');
-  await w.next();
-  assert.equal(w.state.physics.q, 'sum', 'and Continue returns to the summary, the rest already answered');
+// ── confirming, and the locked Continue ──────────────────────────────────────
+test('the review locks Continue until every row that applies is confirmed, and validateStep opens the first one left', async () => {
+  const w = await onReview({ builders_at_start: 3, builders_expected: 8 });
+  assert.equal(w.go().disabled, true);
+  assert.equal(w.go().textContent, 'Confirm 7 more');
+  assert.equal(w.run('validateStep(4)'), false);
+  assert.equal(w.isOpen('code'), true, 'the first unconfirmed row opens');
+  for (const [i, key] of ['code', 'address', 'app', 'extras', 'team', 'rewards'].entries()) {
+    w.ok(key);
+    assert.equal(w.state.confirmed[key], true, key);
+    assert.equal(w.row(key).querySelector('[data-row-ok]').textContent, 'Confirmed');
+    assert.equal(w.row(key).querySelector('[data-row-ok]').disabled, true);
+    assert.equal(w.go().textContent, `Confirm ${6 - i} more`);
+  }
+  assert.equal(w.state.modules && plain(w.state.modules).join(), 'discord', 'confirming the extras is the answer the create sends');
+  w.ok('run');
+  assert.equal(w.go().disabled, false);
+  assert.equal(w.go().textContent, 'Continue');
+  assert.equal(w.run('validateStep(4)'), true);
+  w.change('team');
+  assert.equal(w.state.confirmed.team, undefined, 'Change takes a row back');
+  assert.equal(w.isOpen('team'), true);
+  assert.equal(w.go().textContent, 'Confirm 1 more');
+  w.change('team');
+  assert.equal(w.isOpen('team'), false, 'a second Change closes it again');
 });
 
-test('the summary\'s Create my planet pre-fills the technical steps and moves on to the name', async () => {
-  const w = at('sum', { ...SEVEN, project_state: 'existing', existing_work: ['code'], main_work: 'code', entity: 'for-profit' });
-  w.run('paintPhysics()');
-  assert.equal(w.$('physNext').textContent, 'Continue to setup →', 'the professional voice');
-  assert.equal(w.run('physAdvance()'), false);
-  assert.deepEqual(w.shown, [4], 'on to the name step');
-  assert.equal(w.state.projType, 'business', 'a for-profit company is a business on the map');
-  assert.equal(w.state.mode, 'adopt', 'a planet that already has code adopts its repo');
-  assert.equal(w.state.teamShape, null, 'a team of three is not guessed into a shape');
-  w.run('physPaintPrefillNotes()');
-  assert.match(w.$('typePrefill').textContent, /Picked from your answer “For-profit company”/);
-  assert.match(w.$('homePrefill').textContent, /Adopt is picked because your project already has code/);
+test('the prefills never overwrite a founder\'s own answer', () => {
+  const w = boot();
+  w.run('phys()');
+  Object.assign(w.a(), CHECKS, { project_state: 'existing', existing_work: ['code'], main_work: 'code', framing: 'hybrid', builders_at_start: 3, builders_expected: 9 });
+  w.state.teamShape = 'community';
+  w.run('physDefaults()');
+  assert.deepEqual({ s: w.a().project_state, f: w.a().framing, n: [w.a().builders_at_start, w.a().builders_expected], t: w.state.teamShape },
+    { s: 'existing', f: 'hybrid', n: [3, 9], t: 'community' });
+  assert.equal(w.state.mode, 'adopt', 'a project that already has code adopts its repo');
+  w.state.mode = 'greenfield'; w.state.confirmed = { code: true };
+  w.run('physDefaults()');
+  assert.equal(w.state.mode, 'greenfield', 'but never over a Code row the founder confirmed');
+  for (const gone of ['physPrefill', 'typePrefill', 'homePrefill', 'physSummary', 'data-phys-goto', 'physStepSkipped', 'physPastSkips']) {
+    assert.ok(!HUB.includes(gone), `${gone} is gone: the review shows every prefill as a row instead`);
+  }
 });
 
-// ── pre-fill and skip, rule by rule ──────────────────────────────────────────
-test('a pre-fill never overwrites what the founder chose, and follows a changed answer', () => {
-  const w = at('sum', { ...SEVEN, builders_at_start: 1, builders_expected: 1, entity: 'nonprofit' });
-  w.run('physPrefill()');
-  assert.equal(w.state.projType, 'non-profit');
-  assert.equal(w.state.teamShape, 'solo', 'one builder says solo');
-  assert.equal(w.state.mode, 'greenfield');
-  w.state.projType = 'game';                 // the founder picks for themselves on the Type step
-  w.state.physics.answers.entity = 'research';
-  w.run('physPrefill()');
-  assert.equal(w.state.projType, 'game', 'their choice stands');
-  w.state.projType = 'non-profit';           // back to what we filled …
-  w.state.prefilled = { projType: 'non-profit' };
-  w.run('physPrefill()');
-  assert.equal(w.state.projType, 'research', '… and an untouched pre-fill follows the answer');
-  w.state.physics.answers.entity = 'intent-unsure';
-  w.run('physPrefill()');
-  assert.equal(w.state.projType, null, 'an answer that suggests nothing clears what we filled');
-  w.run('physPaintPrefillNotes()');
-  assert.equal(w.$('typePrefill').hidden, true);
+// ── the voice (spec D5; one plain voice since task 1004504) ──────────────────
+test('one plain voice for everyone: professional is stored for an organization and an individual alike', async () => {
+  assert.doesNotMatch(HUB, /data-voice=/, 'no voice variants are baked anywhere on the page');
+  assert.doesNotMatch(SCRIPT, /physVoice|physPaintVoice|PHYS_ORGS/, 'no voice switch is left in the controller');
+  for (const entity of ['for-profit', 'nonprofit', 'research', 'corporate-division',
+    'intent-company', 'intent-solo', 'social-group', 'university-project', 'private-individual', 'single-owner-llc']) {
+    const w = await onReview({ entity });
+    assert.equal(w.run('createDetail()').voice, 'professional', `${entity} stores the one voice`);
+  }
+  assert.doesNotMatch(HUB, /id="(physCoords|physCallout|physCapLbl)"/, 'the profile caption left with the forming planet');
 });
 
-test('a planet on its own machines skips the app step; Next and Back step over it, and a demo never does', () => {
-  for (const [framing, skipped] of [['managed', false], ['hybrid', false], ['local', true], ['open-source', true]]) {
-    const w = at('sum', { ...SEVEN, framing });
-    assert.equal(w.run('physStepSkipped(10)'), skipped, framing);
-    assert.equal(w.run('physPastSkips(10, 1)'), skipped ? 11 : 10);
-    assert.equal(w.run('physPastSkips(10, -1)'), skipped ? 9 : 10);
-    for (const n of [4, 5, 6, 7, 8, 9, 11, 12]) assert.equal(w.run(`physStepSkipped(${n})`), false, `step ${n} always applies`);
-  }
-  const w = at('sum', { ...SEVEN, framing: 'open-source' }, { draft: { appPlatform: 'render' } });
-  w.run('physPrefill()');
-  assert.equal(w.state.appPlatform, 'later', 'a skipped step keeps its default answer');
-  w.state.demo = { people: 3, hours_each: 4 };
-  assert.equal(w.run('physStepSkipped(10)'), false, 'a demo is all managed');
+test('the one voice carries no planet words on the checks and the review', () => {
+  const words = PANEL.replace(/<!--[\s\S]*?-->/g, '').replace(/<[^>]*>/g, ' ');
+  assert.doesNotMatch(words, /\bplanet|\bmoons?\b|\borbit/i, 'the plain copy names no planet, moon or orbit');
 });
 
 // ── what the create sends ────────────────────────────────────────────────────
+const SEVEN = { ...CHECKS, project_state: 'new', builders_at_start: 3, builders_expected: 8, reward_intents: ['non-monetary', 'future-payouts'], framing: 'hybrid', services: ['hosting', 'starter-kit'] };
 test('the create sends questions 5 to 7 and the voice as detail, in the vocabulary\'s order', () => {
-  const w = at('sum', { ...SEVEN, reward_intents: ['future-payouts', 'non-monetary'], services: ['starter-kit', 'hosting'] });
+  const w = boot();
+  w.run('phys()');
+  Object.assign(w.a(), SEVEN, { reward_intents: ['future-payouts', 'non-monetary'], services: ['starter-kit', 'hosting'] });
   w.state.teamShape = 'small-team';
   const d = plain(w.run('createDetail()'));
   assert.deepEqual(d, {
     project_state: 'new', home_country: 'US', home_region: 'US-CA', builder_geography: 'us-eu', minors_on_board: false, entity: 'intent-solo',
     builders_at_start: 3, builders_expected: 8, framing: 'hybrid',
-    reward_intents: ['non-monetary', 'future-payouts'], services: ['hosting', 'starter-kit'], voice: 'planet', team_shape: 'small-team',
+    reward_intents: ['non-monetary', 'future-payouts'], services: ['hosting', 'starter-kit'], voice: 'professional', team_shape: 'small-team',
   });
   const { badProjectDetail } = require('../modules/provisioning/routes/body-validators.js');
   assert.equal(badProjectDetail(d), null, 'every key and value is one the create route accepts');
 });
 
-// ── the planet ───────────────────────────────────────────────────────────────
-test('the planet gains moons, rings and its orbit around the platform\'s mark', () => {
-  const w = at(7, { ...SEVEN, entity: 'for-profit', builders_at_start: 4, builders_expected: 6, reward_intents: ['non-monetary', 'cash', 'future-payouts'], framing: 'local' });
-  const shown = (sel) => w.q(sel).filter((e) => !e.hidden).length;
-  assert.equal(shown('#physMoons img'), 4, 'a moon per builder now');
-  assert.equal(shown('#physGhosts img'), 2, 'faint ones for the expected growth');
-  assert.ok(w.q('#physMoons img').every((m) => m.getAttribute('src') === '/assets/world/r3-gold-bead-cut.webp'), 'beads of the core\'s material');
-  assert.equal(shown('#physStage .physBelt'), 3, 'a ring per reward being considered');
-  assert.equal(w.$('physStage').getAttribute('data-orbit'), 'far', 'local is a far orbit');
-  assert.equal(w.$('physSun').hidden, false);
-  assert.equal(w.$('physSun').getAttribute('src'), '/assets/world/r2-bongos-chrome-a-cut.webp', 'the platform\'s own mark');
-  w.state.physics.answers.framing = 'open-source';
-  w.run('physPaintStage()');
-  assert.equal(w.$('physStage').getAttribute('data-orbit'), 'own');
-  assert.equal(w.$('physSun').hidden, true, 'open source is a system of its own');
-  w.state.physics.answers.builders_at_start = 9; w.state.physics.answers.builders_expected = 40;
-  w.run('physPaintStage()');
-  assert.equal(shown('#physMoons img'), 6, 'six at most');
-  assert.equal(shown('#physGhosts img'), 4, 'four at most');
-  w.state.physics.q = 'sum';
-  w.run('physPaintStage()');
-  assert.equal(w.$('physPlanet').getAttribute('data-size'), '6', 'the full planet');
-  assert.equal(w.$('physCapN').textContent, 'complete');
-  for (const plate of ['r3-frost-bead-cut', 'r3-gold-bead-cut', 'r3-obsidian-bead-cut', 'r2-bongos-chrome-a-cut']) {
-    assert.ok(fs.existsSync(path.join(LANDING, 'assets', 'world', `${plate}.webp`)), `${plate} is a world plate`);
-  }
-});
-
-test('the orbit and the moons move on CSS alone, and the reduced-motion switch stops them', () => {
-  const css = HUB.slice(HUB.indexOf('.physBelt{'), HUB.indexOf('/* under 520 the two doors'));
-  assert.match(css, /@media \(prefers-reduced-motion:no-preference\)\{\s*\.physMoons\{animation:physOrbit 160s/);
-  assert.doesNotMatch(css.replace(/@media \(prefers-reduced-motion:no-preference\)\{[\s\S]*?\n\}/, ''), /animation:/, 'no animation outside the no-preference block');
-  assert.doesNotMatch(css, /box-shadow/);
-  assert.doesNotMatch(SCRIPT, /\.animate\(|requestAnimationFrame|innerHTML/, 'no motion and no innerHTML in the controller');
+// ── the planet left; the room moves on CSS alone ─────────────────────────────
+test('the forming planet is gone, and the room behind the wizard moves on CSS alone, inside the reduced-motion switch', () => {
+  assert.doesNotMatch(HUB, /id="(physMoons|physGhosts|physSun|physStage|physPlanet)"/, 'no moons, rings, sun or stage');
+  assert.doesNotMatch(HUB, /physPaintStage|\.physBelt\{/);
+  const css = slice('#view-new .wizRoom{', '/* under 900 the window steps back', 'the room\'s rules');
+  assert.match(css, /@media \(prefers-reduced-motion:no-preference\)\{\s*#view-new \.rmSeed\{transition:transform 1\.2s ease;\}/);
+  assert.doesNotMatch(css.replace(/@media \(prefers-reduced-motion:no-preference\)\{[\s\S]*?\n\}/, ''), /animation:|transition:/, 'no motion outside the no-preference block');
+  assert.doesNotMatch(css, /box-shadow:[^;]*#[0-9a-f]{3,6}/i, 'no literal colour in a glow');
+  assert.doesNotMatch(SCRIPT + REVIEW, /\.animate\(|requestAnimationFrame|innerHTML/, 'no motion and no innerHTML in the controller or the review');
 });
 
 // ── the done-when, end to end ────────────────────────────────────────────────
-test('a new owner walks from question 1 to Create my planet, and the technical steps arrive pre-filled', async () => {
-  const w = boot();
-  await w.next();                                   // the start screen
-  assert.equal(w.state.physics.q, 1);
-  w.pick('project_state', 'existing');
-  w.state.physics.answers.existing_work = ['code']; w.state.physics.answers.main_work = 'code';
-  w.state.description = 'An inventory tool our team started last year.';
-  await w.next();
-  assert.equal(w.state.physics.q, 2);
-  Object.assign(w.state.physics.answers, { home_country: 'US', home_region: 'US-NY' });
+test('a new owner walks from the quick checks through a fully confirmed review, the setup prefilled', async () => {
+  const w = boot({ draft: { step: 3, description: 'An inventory tool our team started last year.' } });
+  w.run('paintChecks()');
+  w.$('physCountry').value = 'US'; w.$('physCountry').listeners.change();
+  w.$('physRegion').value = 'US-NY'; w.$('physRegion').listeners.change();
   w.pick('builder_geography', 'global');
-  await w.next();
   w.pick('minors_on_board', 'false');
-  await w.next();
-  w.pick('entity', 'for-profit');
-  await w.next();
-  assert.equal(w.state.physics.q, 5);
+  w.$('physHaveEntity').click();
+  w.pick('entity', 'for-profit');           // a company already formed, so equity is on the table
+  w.run('checksAdvance()');
+  await w.settle();
+  assert.deepEqual(w.shown, [4], 'the review');
+  w.run('paintSetup()');
+  assert.equal(w.row('rewards').hidden, true, 'one person: no rewards row');
+  w.ok('code'); w.ok('address'); w.ok('app'); w.ok('extras');
+  w.change('team');
   w.q('[data-phys-solo="many"]')[0].click();
-  await w.next();
-  assert.equal(w.state.physics.q, 6);
-  w.pick('reward_intents', 'equity');
+  w.use('team');
+  await w.settle();
+  assert.equal(w.state.confirmed.extras, undefined, 'the team moved the extras\' preselect, so that row is asked again');
+  w.ok('extras');
+  assert.equal(w.row('rewards').hidden, false);
+  w.change('rewards');
   w.pick('reward_intents', 'cash');
-  await w.next();
-  assert.equal(w.state.physics.q, 7);
+  w.pick('reward_intents', 'equity');
+  w.use('rewards');
+  w.change('run');
   w.pick('framing', 'open-source');
-  await tick(); await tick();
-  await w.next();
-  assert.equal(w.state.physics.q, 'sum');
-  assert.equal(w.$('physNext').textContent, 'Continue to setup →');
-  await w.next();
-  assert.deepEqual(w.shown, [4], 'the name step');
-  assert.deepEqual({ type: w.state.projType, mode: w.state.mode, app: w.state.appPlatform, skipApp: w.run('physStepSkipped(10)') },
-    { type: 'business', mode: 'adopt', app: 'later', skipApp: true });
+  await w.settle();
+  w.use('run');
+  assert.equal(w.state.confirmed.app, undefined, 'the framing moved the App hosting row');
+  assert.equal(w.rowSays('app')[0], 'Runs on your own machines');
+  w.ok('app');
+  assert.equal(w.go().textContent, 'Continue');
+  assert.equal(w.run('validateStep(4)'), true);
   const d = plain(w.run('createDetail()'));
-  assert.equal(d.voice, 'professional');
-  assert.equal(d.framing, 'open-source');
-  assert.equal(d.services, undefined);
-  assert.deepEqual(d.reward_intents, ['cash', 'equity']);
+  assert.deepEqual({ voice: d.voice, framing: d.framing, services: d.services, team: [d.builders_at_start, d.builders_expected], shape: d.team_shape, rewards: d.reward_intents },
+    { voice: 'professional', framing: 'open-source', services: undefined, team: [2, 5], shape: 'small-team', rewards: ['cash', 'equity'] });
+});
+
+// ── the address is the founder's own choice, on every path (task 1004507, BV2.PS19) ──
+test('no path reaches Look without the founder confirming the address: a prefill suggests it, never confirms it', async () => {
+  for (const draft of [{}, { demo: { people: 3, hours_each: 4, idea: '', invites: [] } }]) {
+    const label = draft.demo ? 'demo' : 'real project';
+    const w = await onReview({}, { draft });
+    assert.equal(w.state.confirmed.address, undefined, `${label}: the prefills leave the address unconfirmed`);
+    assert.equal(w.run("rowFixed('address')"), false, `${label}: the address is never a fixed row`);
+    assert.equal(w.row('address').querySelector('[data-row-chg]').hidden, false, `${label}: it can always be changed`);
+    for (const key of ['code', 'app', 'extras', 'team', 'rewards', 'run']) if (w.run(`rowApplies('${key}')`)) w.ok(key);
+    assert.deepEqual(plain(w.run('unconfirmedRows()')), ['address'], `${label}: every other row confirmed, the address still asked`);
+    assert.equal(w.go().disabled, true, `${label}: Continue stays locked`);
+    assert.equal(w.run('validateStep(4)'), false, `${label}: Continue refuses`);
+    assert.equal(w.isOpen('address'), true, `${label}: and opens the address row`);
+    w.use('address');
+    assert.equal(w.state.confirmed.address, true, `${label}: choosing it is the answer`);
+    assert.equal(w.run('validateStep(4)'), true, `${label}: then Continue goes on`);
+  }
 });