@bongos/core 1.20.49 → 1.20.50

package/tests/wizard_front_door.mjs

@@ -0,0 +1,271 @@
+// tests/wizard_front_door.mjs — the create wizard's front door (task 1004417, BV2.PS05;
+// goal 1000121, docs/design/project-startup-direction.md "Front door").
+//
+// Two screens now stand in front of the wizard's numbered steps:
+//   1 · terms — "anything you want to make": one tick, recorded on the project against
+//       the terms version the SERVER stamps (tests/provisioning_terms_ack.mjs holds that half);
+//   2 · fork  — "you are now creating a digital planet": the world's door pill, two equal
+//       doors, try the demo / begin planet creation. The demo is its own task (BV2.PS09), so
+//       its door says the demo is not open yet rather than leading anywhere.
+// Sign-in stays where it was: the gate (step 0) comes first.
+//
+// Most of this RUNS the page's own script, the vm-slice idiom of tests/wizard_draft_resume.mjs:
+// validateStep(), the front door's wiring, and show()'s class toggles are sliced out of the
+// inline script and executed under a minimal DOM stub. Every slice boundary is asserted, so a
+// rename fails loudly instead of leaving this file quietly testing nothing.
+//
+// projects.html is CRLF on a Windows checkout; this file normalises at read time.
+//
+// Run:  node --test tests/wizard_front_door.mjs
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const LANDING = path.join(ROOT, 'modules', 'public-landing', 'public');
+const HUB = fs.readFileSync(path.join(LANDING, 'projects.html'), 'utf8').replace(/\r\n/g, '\n');
+const SCRIPT = HUB.slice(HUB.lastIndexOf('<script>'), HUB.lastIndexOf('</script>'));
+const STYLE = HUB.slice(HUB.indexOf('<style>'), HUB.indexOf('</style>'));
+
+const panel = (id) => (HUB.match(new RegExp(`<section class="panel[^"]*" id="${id}"[\\s\\S]*?\\n {10}</section>`)) || [''])[0];
+const TERMS = panel('panel-terms');
+const FORK = panel('panel-fork');
+const MAP = {};
+for (const m of ((SCRIPT.match(/var panels = \{([^}]*)\}/) || [, ''])[1]).matchAll(/(\d+):\s*'([a-z-]+)'/g)) MAP[m[2]] = Number(m[1]);
+
+// ── the order ───────────────────────────────────────────────────────────────────
+test('the front door stands between sign-in and the name step: gate 0, terms 1, fork 2, name 3', () => {
+  assert.equal(MAP['panel-gate'], 0, 'sign-in stays where it is today, first');
+  assert.equal(MAP['panel-terms'], 1);
+  assert.equal(MAP['panel-fork'], 2);
+  assert.equal(MAP['panel-name'], 3, 'and today\'s wizard continues unchanged after it');
+  assert.ok(HUB.indexOf('id="panel-gate"') < HUB.indexOf('id="panel-terms"')
+    && HUB.indexOf('id="panel-terms"') < HUB.indexOf('id="panel-fork"')
+    && HUB.indexOf('id="panel-fork"') < HUB.indexOf('id="panel-name"'), 'the markup reads in the same order');
+  assert.match(TERMS, /<form data-next="2">/, 'the terms go on to the fork');
+  assert.match(FORK, /<form data-next="3">/, 'the fork\'s primary door goes on to the name step');
+  assert.match(FORK, /data-back="1"/, 'and the way back is the terms');
+});
+
+test('the rail is the numbered steps\' — it steps aside on both front-door screens, statically too', () => {
+  const beats = [...HUB.matchAll(/<li[^>]*data-step="(\d+)"/g)].map((m) => Number(m[1]));
+  assert.deepEqual(beats, [3, 4, 5, 6, 7, 8, 9, 10], 'the rail numbers name…create, never the front door');
+  assert.match(HUB, /<div class="card wizFront">/, 'a no-script visitor on the static first screen sees no rail');
+  assert.match(STYLE, /#view-new \.card\.wizFront \.steps\{display:none;\}/);
+});
+
+// ── screen 1 · the terms ────────────────────────────────────────────────────────
+test('screen 1 is the canvas\'s "anything you want to make": two ledes, one tick, a read-the-terms link, one door', () => {
+  assert.ok(TERMS, '#panel-terms ships as real markup (C7)');
+  assert.match(TERMS, /^<section class="panel on" id="panel-terms"/, 'it carries the static `on` — step 1 for a no-script visitor');
+  assert.match(TERMS, /<h1 id="terms-h">Anything you want to make<\/h1>/);
+  assert.equal((TERMS.match(/<p class="lede">/g) || []).length, 2, 'two lede paragraphs');
+  assert.match(TERMS, /<input type="checkbox" id="termsAck" aria-describedby="h-terms">/, 'one checkbox, named by its hint');
+  assert.match(TERMS, /<label class="termsAck">\s*<input[^>]*>\s*<span>I can sign legally, or can get a signature, for the use of this platform, and I acknowledge the terms and conditions\.<\/span>/,
+    'the whole row is its label, so the target is the sentence, not a 20px box');
+  assert.match(TERMS, /<a class="termsRead" href="\/terms" target="_blank" rel="noopener">Read the terms<\/a>/,
+    'the platform\'s own /terms, in a new tab so the draft is not left behind');
+  assert.equal((TERMS.match(/type="submit"/g) || []).length, 1, 'one primary door');
+  assert.match(TERMS, /<span data-brand-product-inline>Cloud Bongos<\/span>/, 'the product name is the pack\'s, re-branded on a child');
+});
+
+test('the page never names a terms version — the server stamps which text was acknowledged', () => {
+  // A version baked here would be a second copy of TERMS_VERSION that drifts, and worse, a
+  // value a caller could send. The create request carries only the tick.
+  assert.doesNotMatch(HUB, /terms_version|termsVersion|terms_ack_version/, 'no version travels from the page');
+  assert.doesNotMatch(TERMS, /\b20\d\d-\d\d-\d\d\b/, 'and none is printed on the screen');
+});
+
+test('the resume offer moved with step 1 — it lives on the terms screen, once', () => {
+  assert.equal((HUB.match(/id="wizResume"/g) || []).length, 1);
+  assert.ok(TERMS.includes('id="wizResume"'), 'a deliberate "New project" lands here, so the offer does too');
+});
+
+// ── the validator, executed ────────────────────────────────────────────────────
+const VALIDATE_RE = /function validateStep\(step\) \{[\s\S]*?\n {4}\}/;
+const validateSlice = (SCRIPT.match(VALIDATE_RE) || [null])[0];
+
+function runValidate(step, termsAck) {
+  const els = {};
+  const $ = (id) => (els[id] = els[id] || { textContent: '', className: '', classList: { add() {} }, focus() {} });
+  const sandbox = { $, state: { termsAck, name: 'Mercury', projType: 'game' }, validateRender: () => true, repoAccess: true };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(`${validateSlice}\nvar ok = validateStep(${step});`, sandbox);
+  return { ok: sandbox.ok, hint: els['h-terms'] };
+}
+
+test('validateStep is still findable, with the terms clause inside it', () => {
+  assert.ok(validateSlice, 'validateStep() was not found in projects.html');
+  assert.match(validateSlice, /if \(step === 1\) \{\s*if \(!state\.termsAck\)/, 'the clause is part of the slice');
+});
+
+test('Proceed is refused until the box is ticked, and the refusal says why in the hint', () => {
+  const refused = runValidate(1, false);
+  assert.equal(refused.ok, false, 'no tick, no fork');
+  assert.equal(refused.hint.className, 'hint err');
+  assert.match(refused.hint.textContent, /Tick the box to go on/);
+  const given = runValidate(1, true);
+  assert.equal(given.ok, true, 'a tick goes on');
+});
+
+test('the fork has no clause of its own — its doors are the answer', () => {
+  assert.equal(runValidate(2, false).ok, true, 'the fork asks nothing a validator could refuse');
+  assert.ok(!validateSlice.includes('if (step === 2) {'), 'and no clause for step 2 exists');
+});
+
+// ── the wiring, executed ───────────────────────────────────────────────────────
+const WIRE_START = "    $('termsAck').checked = !!state.termsAck;";
+const WIRE_END = '    /* ── field wiring ── */';
+const wireSlice = SCRIPT.includes(WIRE_START) ? SCRIPT.slice(SCRIPT.indexOf(WIRE_START), SCRIPT.indexOf(WIRE_END)) : null;
+
+function runWiring(initialAck) {
+  const handlers = {};
+  const mk = (id) => ({
+    id, checked: false, hidden: id === 'demoSoon', textContent: '', className: '', attrs: {},
+    addEventListener(type, fn) { handlers[id + ':' + type] = fn; },
+    setAttribute(k, v) { this.attrs[k] = v; },
+  });
+  const els = { termsAck: mk('termsAck'), wizDemo: mk('wizDemo'), demoSoon: mk('demoSoon'), 'h-terms': mk('h-terms') };
+  let saves = 0;
+  const sandbox = { $: (id) => els[id], state: { termsAck: initialAck }, saveDraft: () => { saves += 1; } };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(wireSlice, sandbox);
+  return { els, handlers, sandbox, saves: () => saves };
+}
+
+test('the front door\'s wiring is still findable', () => {
+  assert.ok(wireSlice && wireSlice.length > 100, 'the wiring block was not found in projects.html');
+  assert.match(wireSlice, /\$\('wizDemo'\)\.addEventListener\('click'/, 'the demo door is part of the slice');
+});
+
+test('the tick mirrors into the draft both ways, and a resumed draft paints its own answer', () => {
+  const { els, handlers, sandbox, saves } = runWiring(true);
+  assert.equal(els.termsAck.checked, true, 'a draft that ticked comes back ticked (the GitHub round-trip keeps it)');
+  els.termsAck.checked = false; handlers['termsAck:change'].call(els.termsAck);
+  assert.equal(sandbox.state.termsAck, false, 'unticking is an answer too');
+  els['h-terms'].className = 'hint err';
+  els.termsAck.checked = true; handlers['termsAck:change'].call(els.termsAck);
+  assert.equal(sandbox.state.termsAck, true);
+  assert.equal(els['h-terms'].className, 'hint', 'ticking clears the refusal');
+  assert.equal(saves(), 2, 'each change is saved');
+});
+
+test('the demo door opens a line saying the demo is not open yet, and says so to a screen reader', () => {
+  const { els, handlers } = runWiring(false);
+  assert.equal(els.demoSoon.hidden, true, 'hidden at rest');
+  handlers['wizDemo:click'].call(els.wizDemo);
+  assert.equal(els.demoSoon.hidden, false, 'the placeholder opens');
+  assert.equal(els.wizDemo.attrs['aria-expanded'], 'true');
+  handlers['wizDemo:click'].call(els.wizDemo);
+  assert.equal(els.demoSoon.hidden, true, 'and closes again');
+  assert.equal(els.wizDemo.attrs['aria-expanded'], 'false');
+  assert.match(FORK, /id="wizDemo" aria-controls="demoSoon" aria-expanded="false"/, 'the door names what it opens');
+  assert.match(FORK, /<p class="demoSoon" id="demoSoon" hidden>The demo isn’t open yet\./, 'baked markup, never built by script');
+});
+
+// ── screen 2 · the fork ─────────────────────────────────────────────────────────
+test('screen 2 is the door pill: two equal doors in one object, the accent only on the one that goes on', () => {
+  assert.match(FORK, /<h1 id="fork-h">You are now creating a digital planet<\/h1>/);
+  const pill = (FORK.match(/<div class="doorPill" role="group" aria-label="How to begin">[\s\S]*?<\/div>/) || [''])[0];
+  assert.ok(pill, 'one grouped pill');
+  const doors = [...pill.matchAll(/<button type="(button|submit)" class="([^"]+)"[^>]*>([^<]+)<\/button>/g)];
+  assert.equal(doors.length, 2, 'exactly two doors');
+  assert.deepEqual(doors.map((d) => d[3]), ['Try the demo', 'Begin planet creation']);
+  assert.equal(doors[0][2], 'btn big ghost', 'the demo door is the secondary: transparent at rest');
+  assert.equal(doors[1][2], 'btn big', 'begin carries the accent');
+  assert.equal(doors[1][1], 'submit', 'and is the form\'s one submit, so Enter goes on');
+  assert.match(STYLE, /\.doorPill\{display:inline-grid;grid-template-columns:1fr 1fr;/, 'two EQUAL tracks — the two routes are equal ways in');
+  assert.match(STYLE, /\.doorPill\{[^}]*border-radius:999px;/, 'pill or nothing');
+  assert.match(STYLE, /@media \(max-width:520px\)\{\s*\.doorPill\{display:grid;grid-template-columns:1fr;/, 'at a phone width the two stack, still one object');
+});
+
+test('the seed stands on the world\'s own field plate — nothing drawn but hairlines', () => {
+  assert.match(FORK, /<div class="forkStage" aria-hidden="true">/, 'decorative, so hidden from a screen reader');
+  assert.match(FORK, /<img class="forkSeed" src="\/assets\/world\/r2-chrome-blob-one-cut\.webp" alt="">/, 'a real plate, root-absolute so it is stamped');
+  assert.ok(fs.existsSync(path.join(LANDING, 'assets', 'world', 'r2-chrome-blob-one-cut.webp')), 'and it exists on disk');
+  assert.match(STYLE, /\.forkStage\{[^}]*background:var\(--sky-bg\) var\(--field-plate\) center\/cover no-repeat;/, 'the field is the plate token, not a new image');
+  assert.match(STYLE, /\.forkOrbit\{[^}]*border:1px solid var\(--rule\);border-radius:50%;/, 'the orbits are hairline circles');
+  const at = STYLE.indexOf('the front door (task 1004417');
+  const block = STYLE.slice(at, STYLE.indexOf('/* a field:', at));
+  assert.ok(at > -1 && block.includes('.forkStage{'), 'the front door\'s CSS block is findable');
+  assert.doesNotMatch(block, /#[0-9a-f]{3,8}\b|box-shadow:(?!none)|linear-gradient/i, 'every colour a token, no shadow, no gradient');
+});
+
+test('the two routes are described honestly for today: the demo says coming soon, creation promises no questions that do not exist yet', () => {
+  const routes = (FORK.match(/<div class="forkRoutes">[\s\S]*$/) || [''])[0];
+  assert.match(routes, /Route 1 · demo · coming soon/);
+  assert.match(routes, /Route 2 · planet creation/);
+  assert.doesNotMatch(routes, /seven questions/i, 'the seven planet questions are PS07\'s — the copy must not promise them before they ship');
+  assert.doesNotMatch(FORK, /\bBongos\b(?! pair)/, 'no product name baked where a child instance would ship it');
+});
+
+// ── show(): the class toggles, executed ────────────────────────────────────────
+const SHOW_RE = /function show\(step, moveFocus\) \{[\s\S]*?\n {4}\}/;
+const showSlice = (SCRIPT.match(SHOW_RE) || [null])[0];
+
+function runShow(step) {
+  const cls = (name) => { const set = new Set(); return { name, set, toggle(c, on) { if (on) set.add(c); else set.delete(c); } }; };
+  const card = cls('card'), split = cls('split');
+  const panels = {};
+  const $ = (id) => (panels[id] = panels[id] || { classList: cls(id), querySelector: () => null });
+  const sandbox = {
+    $, state: {}, panels: Object.fromEntries(Object.entries(MAP).map(([id, n]) => [n, id])),
+    root: { querySelector: (sel) => (sel === '.card' ? { classList: card } : { classList: split }) },
+    paintRail() {}, saveDraft() {}, authKnown: false, repoAccess: null,
+    renderModules() {}, syncHome() {}, ensureRepoAccess() {}, checkSlugAvailable() {}, renderAddrPanel() {},
+    syncAppStep() {}, syncRenderSetup() {}, renderReview() {},
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(`${showSlice}\nshow(${step}, false);`, sandbox);
+  return { card: card.set, split: split.set, on: Object.keys(panels).filter((id) => panels[id].classList.set.has('on')) };
+}
+
+test('show() takes the rail away on the two front-door screens only, and gives the fork the whole card', () => {
+  assert.ok(showSlice, 'show() was not found in projects.html');
+  const terms = runShow(1), fork = runShow(2), name = runShow(3), done = runShow(MAP['panel-done']);
+  assert.deepEqual(terms.on, ['panel-terms']);
+  assert.ok(terms.card.has('wizFront') && !terms.split.has('wizFork'), 'terms: no rail, the bongo pair stays');
+  assert.ok(fork.card.has('wizFront') && fork.split.has('wizFork'), 'fork: no rail, and the seed takes the pair\'s place');
+  assert.ok(!name.card.has('wizFront') && !name.split.has('wizFork'), 'the name step has its rail back');
+  assert.ok(done.split.has('wizDone') && !done.card.has('wizFront'), 'the done panel is untouched by the front door');
+});
+
+// ── the create ──────────────────────────────────────────────────────────────────
+test('the create carries the tick, and is never filed without it', () => {
+  const create = SCRIPT.slice(SCRIPT.indexOf("$('doCreate').addEventListener('click'"));
+  assert.match(create, /terms_acknowledged: state\.termsAck \? true : undefined,/,
+    'a real boolean when ticked, absent otherwise — the route refuses anything but a boolean');
+  const guard = create.indexOf('if (!state.termsAck) { show(1, true); validateStep(1); return; }');
+  assert.ok(guard > -1, 'an unticked draft is sent back to the terms');
+  assert.ok(guard < create.indexOf('ensureFreshRepo()'), 'BEFORE anything is created — the repo included');
+});
+
+test('the tick is part of the draft and of the reset, and the draft key moved with the renumbering', () => {
+  assert.match(SCRIPT, /var state = \{ step: 0,[^}]*termsAck: false \};/, 'the initial state declares it');
+  assert.match(SCRIPT, /state = \{ step: 1,[^}]*termsAck: false \};/, 'and "start another project" clears it — each project records its own');
+  assert.match(SCRIPT, /var DRAFT_KEY = 'cb-create-draft-v6';/, 'a draft saved under the old numbering is ignored, not replayed onto the wrong screen');
+});
+
+// ── the look-before-you-ship kit walks it ─────────────────────────────────────
+test('the kit has a state for each front-door screen, and every walk past it ticks and chooses first', () => {
+  const states = JSON.parse(fs.readFileSync(path.join(LANDING, 'projects.states.json'), 'utf8')).states;
+  for (const s of ['in-new', 'in-new-terms-refused', 'in-new-fork', 'in-new-fork-demo', 'in-new-name']) assert.ok(states[s], `the ${s} state exists`);
+  assert.deepEqual(states['in-new'].expect.visible, ['#panel-terms', '#termsAck'], 'arriving at ?view=new pictures the terms');
+  const FRONT = ['#termsAck', '#panel-terms button[type=submit]', '#panel-fork button[type=submit]'];
+  const probes = JSON.parse(fs.readFileSync(path.join(LANDING, 'projects.probes.json'), 'utf8')).probes;
+  const walks = [...Object.entries(states).map(([k, v]) => [k, v.actions || []]), ...probes.map((p) => [p.name, p.steps])]
+    .filter(([, steps]) => steps.some((st) => st[1] === '#newName'));
+  assert.ok(walks.length >= 12, `every wizard walk is found (${walks.length})`);
+  for (const [name, steps] of walks) {
+    const clicks = steps.filter((st) => st[0] === 'click').map((st) => st[1]);
+    assert.deepEqual(clicks.slice(0, 3), FRONT, `${name}: the front door comes first`);
+  }
+  assert.ok(probes.some((p) => /the front door \(task 1004417\)/.test(p.name)), 'a probe drives the refusal, the demo door and the way on');
+});

package/tests/wizard_intent_resume.mjs

@@ -15,12 +15,13 @@
 // ruled out the task's other option (drop the record at a terminal state).
 //
 // The reset fires only when there is a SECOND DRAFT to lose, and the draft's own step is
-// what says so. A landed create clears DRAFT_KEY — but show(9) then persists the done
+// what says so. A landed create clears DRAFT_KEY — but show(11) then persists the done
 // panel's position straight back into it, so a plain "is there a draft?" test is always
 // yes and would skip the reset forever, leaving the finished project's name sitting in
 // the fresh form. (That is exactly what the first cut of this change shipped into a
 // render: "still watching Mercury" above a name field still reading "Mercury".) Only
-// steps 1-8 are wizard steps; anything else is the done panel's own bookkeeping.
+// steps 1-10 are wizard steps (1-8 before task 1004417's front door took 1 and 2);
+// anything else is the done panel's own bookkeeping.
 //
 // Harness: there is no jsdom in this repo, so this follows tests/wizard_draft_resume.mjs
 // and tests/project_door_ui.mjs — slice the real region out of the page's INLINE script
@@ -57,8 +58,8 @@ test('both slices are still findable (a rename must fail loudly, not silently pa
   assert.ok(offerSlice, 'paintResumeOffer() was not found in projects.html');
   assert.match(enterSlice, /if \(focus && !resumeIntent\) \{/, 'the intent branch is part of the slice');
   assert.match(enterSlice, /startProgress\(created\.id\);/, 'so is the resume branch it guards');
-  assert.match(enterSlice, /draft\.step >= 1 && draft\.step <= 8/,
-    'the STORED draft\'s step decides, not state.step — state.step is 9 for the whole life of a finished standup');
+  assert.match(enterSlice, /draft\.step >= 1 && draft\.step <= 10/,
+    'the STORED draft\'s step decides, not state.step — state.step is 11 for the whole life of a finished standup');
   assert.match(SCRIPT, /if \(created && created\.id\) \{ enterCreated\(created, !!focus\); return; \}/,
     'enter() still hands the created record straight to it');
 });
@@ -72,7 +73,7 @@ function runEnter({ focus, resumeIntent = false, draft = null, record }) {
   const calls = { show: [], resets: 0, offer: [], done: 0, progress: [], polls: 0, focused: 0 };
   // state.step is the DONE step for the whole life of a finished standup — the value
   // a draft-blind reading would have trusted
-  const state = { step: draft ? draft.step : 9, name: 'Mercury', slug: 'mercury', domain: '', mode: 'greenfield', noAddress: false, modules: null };
+  const state = { step: draft ? draft.step : 11, name: 'Mercury', slug: 'mercury', domain: '', mode: 'greenfield', noAddress: false, modules: null };
   const sandbox = {
     record, focus, resumeIntent, state,
     DRAFT_KEY: 'draft',
@@ -98,7 +99,7 @@ const REC = { id: 'inst-1', name: 'Acme', slug: 'acme', domain: 'acme.example',
 
 test('a reload / Back / identity settle (focus false) still resumes the done panel, watch and all', () => {
   const { calls, state } = runEnter({ focus: false, record: REC });
-  assert.deepEqual(calls.show, [[9, false]], 'the done panel, and no focus steal on a non-deliberate arrival');
+  assert.deepEqual(calls.show, [[11, false]], 'the done panel, and no focus steal on a non-deliberate arrival');
   assert.equal(calls.resets, 0, 'nothing is reset — this is the same standup continuing');
   assert.equal(calls.done, 1, 'the checklist is re-rendered');
   assert.deepEqual(calls.progress, ['inst-1'], 'the progress watch is restarted from the record');
@@ -113,7 +114,7 @@ test('a deliberate "New project" click after a finished standup opens a FRESH st
   assert.equal(calls.progress.length, 0, 'and its watch is not restarted');
   assert.equal(calls.resets, 1, 'with no second draft to lose, the wizard forgets the finished project');
   assert.deepEqual(calls.show, [[1, false]], 'step 1, and step 1 does not take the heading focus');
-  assert.equal(calls.focused, 1, 'the name field does — the deliberate-nav rule enter() already applies');
+  assert.equal(calls.focused, 1, 'its one control, the terms tick, does — the deliberate-nav rule enter() already applies');
   assert.equal(state.name, '', 'the old name is gone from the form');
 });
 
@@ -126,7 +127,7 @@ test('…and the standup stays one click away, named, on the resume link', () =>
 
 test('the resume link gets the done panel back — the record was never cleared', () => {
   const { calls, sandbox } = runEnter({ focus: true, resumeIntent: true, record: REC });
-  assert.deepEqual(calls.show, [[9, true]], 'a deliberate resume moves focus to the done panel');
+  assert.deepEqual(calls.show, [[11, true]], 'a deliberate resume moves focus to the done panel');
   assert.deepEqual(calls.progress, ['inst-1'], 'the watch comes back with it');
   assert.equal(sandbox.resumeIntent, false, 'the flag is ONE-SHOT — the next plain nav click must mean "new" again');
   assert.deepEqual(calls.offer, [null], 'and the offer comes down behind it');
@@ -144,20 +145,20 @@ test('a second draft already under way is NOT wiped by navigating back to the wi
 });
 
 test('the done panel\'s own saved step is NOT a second draft — it must not block the reset', () => {
-  // Caught in a render, not in a unit test: show(9) calls saveDraft(), so DRAFT_KEY is
+  // Caught in a render, not in a unit test: show(11) calls saveDraft(), so DRAFT_KEY is
   // non-empty again the moment a create lands. Reading "is there a draft?" left the
   // finished project's name in the fresh form, under a line offering to resume it.
-  const { calls, state } = runEnter({ focus: true, record: REC, draft: { step: 9, name: 'Mercury' } });
+  const { calls, state } = runEnter({ focus: true, record: REC, draft: { step: 11, name: 'Mercury' } });
   assert.equal(calls.resets, 1, 'the done step is bookkeeping, not a project being typed');
-  assert.deepEqual(calls.show, [[1, false]], 'out-of-range steps land on the name step');
+  assert.deepEqual(calls.show, [[1, false]], 'out-of-range steps land on step 1, the front door');
   assert.equal(state.name, '', 'and the finished project\'s name does not survive into it');
   assert.equal(calls.done, 0, 'never back onto the done panel');
 });
 
 test('a draft on the app step or the review is live too — the last two numbered steps (task 1004351)', () => {
-  // The app step moved the review from 7 to 8. A guard left at 7 would reset a second
-  // project sitting on its review, silently wiping it.
-  for (const step of [7, 8]) {
+  // The app step moved the review from 7 to 8, and the front door (task 1004417) to 10. A
+  // guard left behind would reset a second project sitting on its review, silently wiping it.
+  for (const step of [9, 10]) {
     const { calls, state } = runEnter({ focus: true, record: REC, draft: { step } });
     assert.equal(calls.resets, 0, `step ${step} is a live draft`);
     assert.deepEqual(calls.show, [[step, true]]);
@@ -165,8 +166,16 @@ test('a draft on the app step or the review is live too — the last two numbere
   }
 });
 
-test('a draft whose step is missing or junk resets too — only 1-8 preserves anything', () => {
-  for (const draft of [{ step: 0 }, { step: 9 }, { name: 'half-typed' }]) {
+test('a draft on the front door is live too — a founder part-way through it keeps their place (task 1004417)', () => {
+  for (const step of [1, 2]) {
+    const { calls, state } = runEnter({ focus: true, record: REC, draft: { step } });
+    assert.equal(calls.resets, 0, `step ${step} is a live draft`);
+    assert.equal(state.step, step);
+  }
+});
+
+test('a draft whose step is missing or junk resets too — only 1-10 preserves anything', () => {
+  for (const draft of [{ step: 0 }, { step: 11 }, { name: 'half-typed' }]) {
     const { calls } = runEnter({ focus: true, record: REC, draft });
     assert.equal(calls.resets, 1, `step ${JSON.stringify(draft.step)} is not a wizard step`);
     assert.deepEqual(calls.show, [[1, false]]);
@@ -191,11 +200,14 @@ test('paintResumeOffer names the project by textContent and hides on null (no li
 });
 
 test('the offer ships as real markup inside step 1, hidden until there is something to resume', () => {
-  const panel = HUB.slice(HUB.indexOf('id="panel-name"'), HUB.indexOf('id="panel-type"'));
+  // step 1 is the front door's terms screen since task 1004417 — the offer moved with it
+  const panel = HUB.slice(HUB.indexOf('id="panel-terms"'), HUB.indexOf('id="panel-fork"'));
   assert.match(panel, /<p class="resumeOffer" id="wizResume" hidden>still watching <strong id="wizResumeName">your project<\/strong> — <a href="#" id="wizResumeGo">resume it<\/a><\/p>/,
     'baked into the panel (C7), carrying its own hidden state');
-  assert.ok(panel.indexOf('id="wizResume"') < panel.indexOf('<form id="newForm"'),
-    'it sits above the name form, where a visitor reads it before typing');
+  assert.ok(panel.indexOf('id="wizResume"') < panel.indexOf('<form data-next="2">'),
+    'it sits above the terms form, where a visitor reads it before anything else');
+  assert.doesNotMatch(HUB.slice(HUB.indexOf('id="panel-name"'), HUB.indexOf('id="panel-type"')), /id="wizResume"/,
+    'and only once — a second copy would be a duplicate id');
   assert.match(SCRIPT, /\$\('wizResumeGo'\)\.addEventListener\('click', function \(ev\) \{\n\s*ev\.preventDefault\(\);\n\s*resumeIntent = true;\n\s*enter\(true\);/,
     'the link raises the one-shot intent and re-enters, rather than href-navigating');
 });