@bongos/core 1.21.91 → 1.21.93

package/tests/projects_hub_module_picker.mjs

@@ -17,8 +17,8 @@
 // projects.html's one big inline <script> — so the block is sliced out by its
 // own comment sentinel (up to the repo picker that follows it) and run with the
 // things it closes over ($, root, esc, state, saveDraft, paintSetup) supplied by the
-// harness. The review's row machinery (ROWS … confirmRow and its delegated click) is
-// sliced out beside it, so confirming the row runs the page's own code. Both slices
+// harness. Part 02's row machinery (ROWS … openRow/closeRow and the delegated click) is
+// sliced out beside it, so opening and closing the row runs the page's own code. Both slices
 // are assertions: rename an edge and this file fails loudly rather than quietly
 // testing nothing.
 //
@@ -61,7 +61,8 @@ const REND = '    /* what each row says: its value';
 const rfrom = HUB.indexOf(RSTART), rto = HUB.indexOf(REND, rfrom);
 assert.ok(rfrom > -1 && rto > rfrom, 'the review rows are sliced by ROWS and rowText');
 const REVIEW = HUB.slice(rfrom, rto).replace(/\r\n/g, '\n');
-assert.ok(REVIEW.includes('function confirmRow(key)'), 'and they carry confirmRow');
+assert.ok(REVIEW.includes('function openRow(key)') && REVIEW.includes('function firstInvalidRow()'), 'and they carry the rows\' Change and Create\'s check');
+assert.doesNotMatch(REVIEW, /function confirmRow\(|function confirmAllRows\(/, 'and nothing that confirms a row (task 1004648)');
 
 // The payload GET /provisioning/starter-bundles serves (ADR 0237 + task 1002339).
 // Deliberately a FIXTURE and not a live require: this asserts the picker reads
@@ -185,8 +186,8 @@ function whyOf(html) {
 function boot({ state: seed = {}, fetchOk = true, payload = PAYLOAD } = {}) {
   const els = new Map();
   const $ = (id) => { if (!els.has(id)) els.set(id, makeEl(id)); return els.get(id); };
-  // step 4 is the review, where the Extras row lives (task 1004504)
-  const state = { step: 4, projType: null, teamShape: null, modules: null, confirmed: {}, ...seed };
+  // step 1 is the page, where part 02's Extras row lives (task 1004648)
+  const state = { step: 1, projType: null, teamShape: null, modules: null, ...seed };
   const rows = {};
   const rowFor = (sel) => { const m = /data-row="([a-z]+)"/.exec(sel); return m ? (rows[m[1]] = rows[m[1]] || makeRow(m[1])) : null; };
   let saves = 0;
@@ -207,6 +208,7 @@ function boot({ state: seed = {}, fetchOk = true, payload = PAYLOAD } = {}) {
     phys: () => ({ answers: { framing: 'managed' } }),
     validateCode: () => true, validateAddress: () => true, validateRender: () => true,
     checkSlugAvailable: () => {}, renderAddrPanel: () => {}, syncHome: () => {}, syncAppStep: () => {}, syncRenderSetup: () => {},
+    syncShipStep: () => {}, renderLook: () => {}, paintCreate: () => {},
     API: '/api/bongos',
     fetch: () => { fetches++; return Promise.resolve(fetchOk
       ? { ok: true, json: () => Promise.resolve(payload) }
@@ -247,13 +249,11 @@ function boot({ state: seed = {}, fetchOk = true, payload = PAYLOAD } = {}) {
       };
       band._handlers.click({ target });
     },
-    // the page's "Looks right, continue" (every row through its own check), Edit to
-    // open the Extras row, and Done — the same control, open — to confirm it
-    looksRight: () => sandbox.confirmAllRows(),
+    // Change opens the Extras row, and Done — the same control, open — closes it;
+    // Create's own check is firstInvalidRow (task 1004648)
     change: () => rowClick('data-row-chg'),
     use: () => rowClick('data-row-chg'),
-    confirmed: () => !!(state.confirmed && state.confirmed.extras),
-    unconfirmed: () => [...sandbox.unconfirmedRows()],
+    blocking: () => sandbox.firstInvalidRow(),
     forCreate: () => sandbox.modulesForCreate(),
     picked: () => sandbox.pickedModules(),
     // BV1.R21 (task 1002340) — the search box. type() is the real `input` event
@@ -344,21 +344,21 @@ test('switching every module off is a real answer, not a reset to the bundle', a
   assert.deepEqual(h.rows().filter((r) => r.pressed), [], 'and the panel shows it');
 });
 
-test('an unconfirmed row answers NOTHING, and Create waits for it (no Skip since task 1004504)', async () => {
+test('an untouched row answers NOTHING, and Create does not wait for it (task 1004648)', async () => {
   // Arrange
   const h = boot({ state: { projType: 'game' } });
   await h.open();
 
-  // Assert — the row is shown prefilled, and until it is confirmed nothing is said:
+  // Assert — the row is shown prefilled, and nothing is said on the owner's behalf:
   // the preselect and the server's fallback are the same declaration (ADR 0237)
   assert.equal(h.state.modules, null, 'nothing is answered on the owner\'s behalf');
   assert.equal(h.forCreate(), undefined, 'so a create now would carry no modules key');
   assert.deepEqual(h.picked(), ['npm-release', 'discord'], 'while the set they are shown is still the set they get');
-  assert.ok(h.unconfirmed().includes('extras'), 'and the review holds Continue until the row is confirmed');
+  assert.equal(h.blocking(), null, 'and no row needs confirming before Create: the summary wins');
 });
 
-test('Edit, a toggle, then Done: the toggle stands as the answer', async () => {
-  // A visitor who changed something and then confirmed meant "this", not "throw that away".
+test('Change, a toggle, then Done: the toggle stands as the answer', async () => {
+  // A visitor who changed something and then closed the row meant "this", not "throw that away".
   const h = boot({ state: { projType: 'game' } });
   await h.open();
   h.change();
@@ -367,19 +367,16 @@ test('Edit, a toggle, then Done: the toggle stands as the answer', async () => {
   h.use();
 
   assert.deepEqual(h.state.modules, ['agents', 'npm-release', 'discord']);
-  assert.equal(h.confirmed(), true, 'and the row is confirmed');
+  assert.deepEqual(h.forCreate(), ['agents', 'npm-release', 'discord'], 'and rides the create request');
 });
 
-test('Looks right, continue CONFIRMS the set on screen — looking at it and accepting it is not the same as never being asked', async () => {
+test('opening and closing the row without a toggle answers nothing: the suggestion stays the server\'s', async () => {
   const h = boot({ state: { projType: 'game' } });
   await h.open();
-
-  h.looksRight();
-
-  assert.deepEqual(h.state.modules, ['npm-release', 'discord'], 'the preselect becomes the answer');
-  assert.deepEqual(h.forCreate(), ['npm-release', 'discord'], 'and rides the create request');
-  assert.equal(h.confirmed(), true);
-  assert.ok(!h.unconfirmed().includes('extras'), 'and Create no longer waits on it');
+  h.change();
+  h.use();
+  assert.equal(h.state.modules, null, 'looking is not answering');
+  assert.equal(h.forCreate(), undefined, 'so the server applies the same bundle the row showed');
 });
 
 test('changing the project type re-preselects while nothing has been said, and never after', async () => {
@@ -419,14 +416,12 @@ test('a catalog that will not load degrades to a clause — it never blocks a pr
   assert.deepEqual(h.rows(), [], 'no rows are invented');
   assert.match(h.coreNote(), /couldn’t load/, 'the panel says so in the owner\'s words');
   assert.equal(h.state.modules, null, 'nothing is answered on their behalf');
-  // The row still has to be confirmable, or a failed read would block Create. But the row
-  // said "the suggested set", so confirming it must not file an EMPTY list — that would
-  // switch off the very bundle the server would otherwise apply.
-  h.looksRight();
-  assert.equal(h.confirmed(), true, 'the wizard still walks on');
+  // A failed read must never block Create, and the row said "the suggested set", so Create
+  // must not file an EMPTY list — that would switch off the very bundle the server applies.
+  assert.equal(h.blocking(), null, 'Create still goes on');
   // (through JSON: a vm-born array never strictly equals one born here, so a bare
   // notDeepEqual would pass whatever the page did)
-  assert.notEqual(JSON.stringify(h.forCreate()), '[]', 'and confirming "the suggested set" never files "none"');
+  assert.notEqual(JSON.stringify(h.forCreate()), '[]', 'and "the suggested set" never files "none"');
 });
 
 test('every rendered value goes through the page escaper', async () => {
@@ -460,11 +455,11 @@ test('the catalog read is LAZY and asked once — /projects serves four views fr
 });
 
 test('the Extras row names the set even when the picker was never opened (task 1002339)', async () => {
-  // A resumed draft lands straight on the review, so the catalog has not loaded
+  // A resumed draft lands straight on the page, so the catalog has not loaded
   // and the module NAMES are not known. "None — just the core" would be a false
   // promise before Create: the server is about to apply the type's bundle. The row
   // says that instead, then repaints when the read lands.
-  const h = boot({ state: { projType: 'game', step: 4 } });   // 4 = the review since task 1004504 (12 since 1004418)
+  const h = boot({ state: { projType: 'game', step: 1 } });   // 1 = the page since task 1004648 (4 = the review before it)
 
   // Arrange + Act — the review asks for the value before the read can answer
   const first = h.extrasRow();
@@ -554,18 +549,16 @@ test('changing the team shape later re-preselects, with no second read', async (
   assert.equal(h.fetches(), 1, 'and the answer cost no round trip');
 });
 
-test('after a team answer the unconfirmed row still answers nothing, and confirming takes the tailored set', async () => {
+test('after a team answer the untouched row still answers nothing, and shows the tailored set', async () => {
   // ADR 0240 §2's property, extended to the interview's answer (ADR 0243): the
-  // preselect and the server's fallback are the same declaration, so an unconfirmed
-  // row must still answer NOTHING, and confirming it must take the tailored set.
+  // preselect and the server's fallback are the same declaration, so an untouched
+  // row must still answer NOTHING, while showing the tailored set the server will apply.
   const h = boot({ state: { projType: 'game', teamShape: 'solo' }, payload: TAILORED });
   await h.open();
 
-  assert.equal(h.state.modules, null, 'unconfirmed answers nothing, tailored or not');
+  assert.equal(h.state.modules, null, 'untouched answers nothing, tailored or not');
   assert.equal(h.forCreate(), undefined, 'so the create request would carry no modules key');
   assert.deepEqual(h.picked(), ['discord'], 'while the set they were shown is still the set they get');
-  h.looksRight();
-  assert.deepEqual(h.forCreate(), ['discord'], 'and confirming files exactly that set');
 });
 
 test('once the owner has answered, the reasons go — the panel stops arguing', async () => {
@@ -873,7 +866,7 @@ test('with nothing switched on the count says only what is shown', async () => {
 });
 
 test('the Extras row names the hidden picks too — a filter never reaches the create request', async () => {
-  const h = boot({ state: { projType: 'game', step: 4 } });   // 4 = the review since task 1004504 (12 since 1004418)
+  const h = boot({ state: { projType: 'game', step: 1 } });   // 1 = the page since task 1004648 (4 = the review before it)
   await h.open();
   h.click('agents');
   assert.deepEqual(h.forCreate(), ['agents', 'npm-release', 'discord']);

package/tests/projects_hub_pre_uat.mjs

@@ -232,16 +232,13 @@ test('the wizard’s 401 recoveries keep the repo scope they already granted', (
 });
 
 test('a resumed draft past the code row still probes repo access before Create', () => {
-  // task 1004504: the Home step is the review's code row, so the review probes on entry —
-  // and a draft that resumes on the look screen (past the review, before done) must still
-  // probe, or Create files a repo it promised to make but never did (ensureFreshRepo skips
-  // the create whenever repoAccess is not true)
-  const REVIEW = STEP['panel-review'];
-  assert.match(SCRIPT, new RegExp(`if \\(step === ${REVIEW}\\) \\{[\\s\\S]*?if \\(authKnown\\) ensureRepoAccess\\(\\);`),
-    'the review screen probes on entry');
-  assert.ok(SCRIPT.includes(
-    `else if (step > ${REVIEW} && step < ${DONE} && authKnown && repoAccess === null) ensureRepoAccess();`),
-    'every screen between the review and the done panel re-probes');
+  // task 1004648: the Home step is part 02's Code row on the one page, so the page probes on
+  // entry — Create would otherwise file a repo it promised to make but never did
+  // (ensureFreshRepo skips the create whenever repoAccess is not true). There is no screen
+  // between the page and Create any more for a resumed draft to land past it on.
+  assert.match(SCRIPT, /if \(step === 1\) paintPage\(\);/, 'the page paints on entry');
+  assert.match(SCRIPT, /function paintPage\(\) \{[\s\S]*?if \(authKnown\) ensureRepoAccess\(\);/, 'and the page probes on entry');
+  assert.match(SCRIPT, /function onAuth\(\) \{[\s\S]*?if \(currentView === 'new'\) enter\(false\);/, 'and again once /me settles, so a pre-auth paint is caught up');
 });
 
 test('a half-typed custom domain says why Done refuses it; a taken handle silences the format cheer', () => {
@@ -257,7 +254,7 @@ test('no wall-clock promises, no operator vocabulary on the stranger’s path',
   /* Since ADR 0345 (task 1004351) the APP has its own row; since task 1004504 the review is
      the row-by-row confirm, and that row speaks the owner's words. The assertion still
      guards the same property this test is about: owner vocabulary, and no wall-clock promise. */
-  assert.match(HUB, /<div class="setRow" data-row="app">\s*<span class="k">App hosting<\/span>/, 'the review names the app\'s hosting in plain words');
+  assert.match(HUB, /<div class="setRow" data-row="app">\s*<span class="k">Hosting<\/span>/, 'part 02 names the app\'s hosting in plain words');
   assert.ok(SCRIPT.includes("return { v: appPlatformChoice() === 'render' ? 'Render' : 'Decide later', s: appRowDetail() };"), 'its value is a place or "Decide later", never a release name');
   assert.doesNotMatch(SCRIPT, /current release|release channel/, 'no release vocabulary on the stranger\'s path');
   assert.doesNotMatch(HUB, /\/new-project<\/code> assistant/, 'the done panel’s closing line');
@@ -480,9 +477,9 @@ test('decision 5 — the Type step says where the type can be changed (task 1003
   // design of record's words, which make no promise about changing it. What must hold: the
   // narrowed promise never comes back, and any change-later promise carries its address.
   assert.doesNotMatch(HUB, /id="panel-type"/, 'the Type step is gone');
-  const what = (HUB.match(/<section class="panel" id="panel-what"[\s\S]*?<\/section>/) || [''])[0];
-  assert.ok(what, '#panel-what exists');
-  assert.match(what, /<span id="typeLbl">Kind<\/span>/, 'the kind is asked on the What screen');
+  const what = (HUB.match(/<div class="part" id="part-project"[\s\S]*?\n {14}<\/div>\n/) || [''])[0];
+  assert.ok(what, 'part 01 exists (task 1004648)');
+  assert.match(what, /<span id="typeLbl">Kind<\/span>/, 'the kind is asked in part 01, Your project');
   assert.doesNotMatch(what, /stays as you pick it/, 'the narrowed promise must not survive');
   if (/change it later/.test(what)) {
     assert.match(what, /change it later from the project’s own page/, 'a change-later promise names WHERE — a promise with an address');

package/tests/ship_mode.mjs

@@ -114,7 +114,8 @@ test('GET /project-settings/ship-mode is open to any signed-in builder, not gate
     const names = route('get', '/project-settings/ship-mode').stack.map((l) => l.name);
     assert.equal(names.length, 2, 'requireBuilder + the handler, and no permission gate');
     const write = route('patch', '/project-settings/ship-mode').stack;
-    assert.equal(write.length, 3, 'the write carries requireBuilder + the settings permission + the handler');
+    assert.equal(write.length, 4, 'the write carries requireBuilder + the settings permission + Rules\' decision rule (task 1004657) + the handler');
+    assert.equal(write[2].handle.name, 'actAloneGate');
   } finally { restore(); }
 });
 

package/tests/wizard_demo.mjs

@@ -238,42 +238,46 @@ function bootHub() {
     const b = new El(`step-${k}${by}`); b.attrs['data-demo-step'] = k; b.attrs['data-by'] = by; return b;
   });
   const shown = [];
-  // the doors wait for the fork's tick (task 1004504), so the founder here has given it
-  const state = { step: 1, demo: null, description: '', teamShape: null, termsAck: true, confirmed: { team: true } };
-  const sandbox = { $, state, saveDraft() {}, show: (n) => shown.push(n), eyebrowFor: () => 'Demo', root: { querySelectorAll: () => steppers } };
+  // the demo is a small link under the heading (task 1004648): it waits for nothing
+  const state = { step: 1, demo: null, description: '', teamShape: null, termsAck: false };
+  const sandbox = { $, state, saveDraft() {}, show: (n) => shown.push(n), root: { querySelectorAll: () => steppers } };
   vm.createContext(sandbox);
   vm.runInContext(SLICE, sandbox);
   const click = (id) => $(id).listeners.click.call($(id));
   return { $, state, shown, steppers, click, sandbox };
 }
 
-test('the door opens ONE setup screen, the steppers stay in their limits, and the first read follows them', () => {
+test('the small link opens the demo in place, the steppers stay in their limits, and the first read follows them', () => {
   const h = bootHub();
-  h.state.termsAck = false;
+  h.$('demoSetup').hidden = true;
   h.click('wizDemo');
-  assert.equal(h.$('wizDemo').attrs['aria-expanded'], undefined, 'an unticked box opens nothing (task 1004504)');
-  assert.equal(h.$('forkIntro').hidden, false, 'the doors stay');
-  h.state.termsAck = true;
-  h.click('wizDemo');
-  assert.equal(h.$('forkIntro').hidden, true);
-  assert.equal(h.$('demoSetup').hidden, false);
+  assert.equal(h.$('demoSetup').hidden, false, 'the demo opens at the top of part 01');
   assert.equal(h.$('wizDemo').attrs['aria-expanded'], 'true');
-  assert.equal(h.$('wizBack').hidden, false, 'the one Back walks back to the doors');
   for (let i = 0; i < 20; i += 1) h.steppers[0].listeners.click.call(h.steppers[0]);
   assert.equal(h.$('demoPeople').textContent, '12', 'people stop at twelve');
   for (let i = 0; i < 20; i += 1) h.steppers[3].listeners.click.call(h.steppers[3]);
   assert.equal(h.$('demoHours').textContent, '1', 'hours stop at one');
   assert.equal(h.$('demoFitSum').textContent, '12 people × 1 hour = 12 builder-hours.');
   assert.equal(h.$('demoFitVerdict').textContent, demo.fitCheck(12, 1).sentence);
-  h.sandbox.demoShow('intro');
-  assert.equal(h.$('forkIntro').hidden, false, 'Back returns to the two doors');
+  h.click('wizDemo');
+  assert.equal(h.$('demoSetup').hidden, true, 'the same link closes it again');
   assert.equal(h.$('wizDemo').attrs['aria-expanded'], 'false');
-  assert.equal(h.$('wizBack').hidden, true);
-  assert.match(HUB, /if \(state\.step === 1 && !\$\('demoSetup'\)\.hidden\) \{ demoShow\('intro'\); \$\('wizDemo'\)\.focus\(\); return; \}/, 'which is what #wizBack does from the demo screen');
-  assert.doesNotMatch(HUB, /id="demoReady"|id="demoRing"|id="demoNext1"|id="demoBack1"|id="demoBack2"|id="demoStageCap"/, 'the second demo screen, its ring and its own Back buttons are gone');
+  assert.doesNotMatch(HUB, /id="demoReady"|id="demoRing"|id="demoNext1"|id="demoBack1"|id="demoBack2"|id="demoStageCap"|id="forkIntro"/, 'no second demo screen and no fork');
+  assert.match(HUB, /<p class="pageSub" id="pageSub">Three parts, one page\. Just looking\? <button type="button" class="linklike" id="wizDemo" aria-controls="demoSetup" aria-expanded="false">Try a small demo instead<\/button>\.<\/p>/,
+    'the demo is a small link under the heading, in the mockup\'s words');
+});
+
+test('"Make a real project instead" drops the demo and its answers, and the page stays where it is', () => {
+  const h = bootHub();
+  h.state.demo = { people: 3, hours_each: 4 };
+  h.click('wizDemo');
+  h.click('demoCancel');
+  assert.equal(h.state.demo, null, 'a walked-back demo does not ride the create');
+  assert.equal(h.$('demoSetup').hidden, true);
+  assert.deepEqual(h.shown, [1], 'the page repaints: the quick checks come back');
 });
 
-test('the demo screen\'s Continue carries the demo into the ordinary wizard: the idea, the team, the invites', () => {
+test('"Use these" marks the page a demo: the idea, the team, the invites — the rest of the page unchanged', () => {
   const h = bootHub();
   h.click('wizDemo');
   assert.equal(h.$('demoInvites').hidden, false, 'the invites sit on the same screen');
@@ -286,14 +290,15 @@ test('the demo screen\'s Continue carries the demo into the ordinary wizard: the
   assert.equal(h.state.description, 'A shared reading list.', 'the idea is the description');
   assert.equal(h.$('f-desc').value, 'A shared reading list.', 'and the sentence field shows it');
   assert.equal(h.state.teamShape, 'small-team');
-  assert.deepEqual(JSON.parse(JSON.stringify(h.state.confirmed)), {}, 'the demo\'s own rows are asked again on the review');
-  assert.deepEqual(h.shown, [2], 'on to "What are you making?" (task 1004504)');
-  assert.match(HUB, /<input type="text" id="demoIdea" maxlength="600"/, 'the idea is one line now');
-  assert.match(HUB, /<button type="button" class="btn" id="demoStart">Continue<\/button>/);
+  assert.equal(h.$('demoSetup').hidden, true, 'the demo closes once used');
+  assert.deepEqual(h.shown, [1], 'and the page repaints, marked demo (task 1004648)');
+  assert.match(HUB, /<input type="text" id="demoIdea" maxlength="600"/, 'the idea is one line');
+  assert.match(HUB, /<button type="button" class="btn small" id="demoStart">Use these<\/button>/);
 });
 
-test('a demo skips the quick checks and sends only its team shape', () => {
-  assert.match(HUB, /if \(next === 3 && state\.demo\) \{ physDefaults\(\); show\(4, true\); return; \}/, 'the What screen goes straight to the review for a demo');
+test('a demo\'s quick checks stand down and it sends only its team shape', () => {
+  assert.match(HUB, /\$\('checksMain'\)\.hidden = physStopped \|\| !!state\.demo;/, 'the checks stand down for a demo');
+  assert.match(HUB, /function physScreen\(\) \{\s*if \(state\.demo\) return Promise\.resolve\(true\);/, 'and there is nothing of its own to screen');
   const fn = (HUB.match(/function createDetail\(\) \{[\s\S]*?\n {4}\}/) || [null])[0];
   assert.ok(fn, 'createDetail() was found');
   const box = { physDetail: () => ({ framing: 'hybrid', reward_intents: ['cash'] }), state: {} };
@@ -308,7 +313,7 @@ test('a demo skips the quick checks and sends only its team shape', () => {
 
 test('the create sends the demo, the recap names it, and the project page asks the question', () => {
   assert.match(HUB, /demo: state\.demo \? \{ people: state\.demo\.people, hours_each: state\.demo\.hours_each \} : undefined,/);
-  assert.match(HUB, /if \(state\.demo\) bits\.push\('demo'\);/, 'the look screen\'s recap says it is a demo');
+  assert.match(HUB, /if \(state\.demo\) bits\.push\('demo'\);/, 'the recap beside Create says it is a demo');
   assert.match(HUB, /<p class="demoKeepH">Keep your planet\?<\/p>/);
   assert.match(HUB, /data-demo-settle="carried">Carry it over</);
   assert.match(HUB, /data-demo-settle="kept">Keep it as a demo</);

package/tests/wizard_draft_resume.mjs

@@ -39,7 +39,7 @@ const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const HUB = fs.readFileSync(path.join(ROOT, 'modules', 'public-landing', 'public', 'projects.html'), 'utf8');
 
 // ── slice 1 · the step-resolution block inside enter() ────────────────────────────
-const STEP_RE = /var step = authKnown &&[\s\S]*?show\(step, !!focus\);\r?\n\s*\}/;
+const STEP_RE = /var resumeStep = state\.step;[\s\S]*?if \(focus\) \$\('newName'\)\.focus\(\);/;
 const stepSlice = (HUB.match(STEP_RE) || [null])[0];
 
 test('the step-resolution slice is still findable (a rename must fail loudly, not silently pass)', () => {
@@ -69,35 +69,28 @@ function runStep({ authKnown, draftStep }) {
   return { rendered, persisted: JSON.parse(store.get('draft')), state };
 }
 
-test('pre-auth: the placeholder renders step 1 but the draft KEEPS the real step', () => {
-  // step 4 is the review since task 1004504 — where the code row's repo access is granted
-  const { rendered, persisted } = runStep({ authKnown: false, draftStep: 4 });
-  assert.deepEqual(rendered, [1], 'still renders step 1 (the fork, since task 1004504) before identity settles');
-  assert.equal(persisted.step, 4, 'the draft must not be overwritten with the placeholder');
+test('pre-auth: the placeholder renders the page but the draft KEEPS the real step', () => {
+  // step 2 is the created page since task 1004648 — its own branch above this slice takes it
+  // once /me answers, so the placeholder must not overwrite it
+  const { rendered, persisted } = runStep({ authKnown: false, draftStep: 2 });
+  assert.deepEqual(rendered, [1], 'renders the page (step 1) before identity settles');
+  assert.equal(persisted.step, 2, 'the draft must not be overwritten with the placeholder');
 });
 
 test('pre-auth: the in-memory step is restored too, so onAuth() can re-enter to it', () => {
   // onAuth() calls enter() again and reads state.step from MEMORY, not from storage — so
   // restoring only the stored copy would fix nothing.
-  for (const step of [2, 3, 4, 5]) {
+  for (const step of [0, 1, 2]) {
     const { state } = runStep({ authKnown: false, draftStep: step });
     assert.equal(state.step, step, `step ${step} comes back`);
   }
 });
 
-test('post-auth: the real step is rendered', () => {
-  const { rendered, persisted } = runStep({ authKnown: true, draftStep: 4 });
-  assert.deepEqual(rendered, [4]);
-  assert.equal(persisted.step, 4);
-});
-
-test('a draft already at step 1 is unchanged, and an out-of-range step is not resurrected', () => {
-  assert.equal(runStep({ authKnown: false, draftStep: 1 }).persisted.step, 1);
-  // 6 is the done panel since task 1004504 (12 before it, 11 before task 1004421's Look step, 9 before task
-  // 1004417's front door, 8 before task 1004351), reached by its own branch above this slice; 0 is the gate.
-  // Neither is a resumable wizard position, so the placeholder is allowed to stand.
-  for (const bad of [0, 6, 13, 99]) {
-    assert.equal(runStep({ authKnown: false, draftStep: bad }).persisted.step, 1, `step ${bad} is not resumed`);
+test('post-auth: the page is rendered, and the draft says so', () => {
+  for (const step of [0, 1, 2, 13]) {
+    const { rendered, persisted } = runStep({ authKnown: true, draftStep: step });
+    assert.deepEqual(rendered, [1], `from step ${step}: one page`);
+    assert.equal(persisted.step, 1);
   }
 });
 
@@ -216,6 +209,7 @@ test('the team pill is a plain pick on the Team size row — a second click keep
     paintTeam() {}, saveDraft() { saves += 1; }, paintSetup() { paints += 1; },
     unconfirm(keys) { unconfirmed.push(...keys); },
   };
+  // task 1004648: nothing is confirmed any more, so nothing is "asked again" — the row repaints
   sandbox.globalThis = sandbox;
   vm.createContext(sandbox);
   vm.runInContext(teamSlice, sandbox);
@@ -228,8 +222,8 @@ test('the team pill is a plain pick on the Team size row — a second click keep
   click('community');
   assert.equal(state.teamShape, 'community', 'a DIFFERENT pill replaces it');
   assert.equal(saves, 3, 'every pick is saved into the draft, so the GitHub round-trip keeps it');
-  assert.deepEqual([...new Set(unconfirmed)], ['extras'], 'the suggested extras follow the team, so the review asks about them again');
-  assert.equal(paints, 3, 'and the review repaints');
+  assert.deepEqual(unconfirmed, [], 'no row is un-confirmed: the summary wins (task 1004648)');
+  assert.equal(paints, 3, 'and the rows repaint, the suggested extras with them');
   assert.deepEqual([...HUB.matchAll(/data-team="([a-z-]+)"/g)].map((m) => m[1]), ['small-team', 'community'],
     'the row offers who can join a team; one person is the "One person" pill, not a team shape');
 });
@@ -268,17 +262,15 @@ function runEnter({ draftStep, focus = false, resumeIntent = false, created = {
 }
 
 test('back from GitHub mid-draft, with an earlier project stored: the draft step, not the old done panel', () => {
-  for (const step of [2, 3, 4, 5]) {
-    const log = runEnter({ draftStep: step });
-    assert.deepEqual(log.created, [], `step ${step}: the earlier project's panel is not entered`);
-    assert.deepEqual(log.shown, [step], `step ${step}: the draft keeps its place`);
-    assert.equal(log.offer && log.offer.id, 101, 'the earlier project stays one click away on the resume line');
-  }
+  const log = runEnter({ draftStep: 1 });
+  assert.deepEqual(log.created, [], 'the earlier project\'s part 03 is not entered');
+  assert.deepEqual(log.shown, [1], 'the draft keeps its place: the page');
+  assert.equal(log.offer && log.offer.id, 101, 'the earlier project stays one click away on the resume line');
 });
 
-test('the done panel still comes back when no second draft is in flight, or on a deliberate nav', () => {
-  assert.equal(runEnter({ draftStep: 6 }).created.length, 1, 'a reload on the done panel stays on it');
+test('the created page still comes back when no second draft is in flight, or on a deliberate nav', () => {
+  assert.equal(runEnter({ draftStep: 2 }).created.length, 1, 'a reload on the created page stays on it');
   assert.equal(runEnter({ draftStep: 0 }).created.length, 1, 'no draft position: the watched project');
-  assert.deepEqual(runEnter({ draftStep: 4, focus: true }).created, [{ id: 101, focus: true }], 'a deliberate New project nav is enterCreated\'s to decide');
-  assert.equal(runEnter({ draftStep: 4, resumeIntent: true }).created.length, 1, 'the resume link still resumes');
+  assert.deepEqual(runEnter({ draftStep: 1, focus: true }).created, [{ id: 101, focus: true }], 'a deliberate New project nav is enterCreated\'s to decide');
+  assert.equal(runEnter({ draftStep: 1, resumeIntent: true }).created.length, 1, 'the resume link still resumes');
 });