@bongos/core 1.21.4 → 1.21.6

package/tests/projects_hub_module_picker.mjs

@@ -1,5 +1,8 @@
 // tests/projects_hub_module_picker.mjs — the create wizard's module picker,
 // EXECUTED (BV1.R20, task 1002339; goal 1000046 criterion `proj-module-select`).
+// Since task 1004504 the picker is the review's Extras row: its controls moved into the
+// row whole, "Looks right" / "Use this" confirm the set on screen, and there is no Skip —
+// Create waits for every row, this one included.
 //
 // tests/projects_hub.mjs pins this surface statically, on purpose (C7: "real
 // markup, not JS-built"). But the picker is the one part of the wizard whose
@@ -11,10 +14,12 @@
 // The precedent is tests/task_detail_ui.mjs (there is no jsdom in this repo).
 // The difference: task-detail.js is a whole file, while the picker lives inside
 // projects.html's one big inline <script> — so the block is sliced out by its
-// own comment sentinels and run with the five things it closes over ($, root,
-// esc, state, saveDraft/show) supplied by the harness. That slice is itself an
-// assertion: rename the sentinels and this file fails loudly rather than
-// quietly testing nothing.
+// 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
+// are assertions: rename an edge and this file fails loudly rather than quietly
+// testing nothing.
 //
 // Run:  node --test --test-reporter=tap tests/projects_hub_module_picker.mjs
 
@@ -41,12 +46,21 @@ const LANDING = path.join(ROOT, 'modules', 'public-landing', 'public');
 const HUB = fs.readFileSync(path.join(LANDING, 'projects.html'), 'utf8');
 
 const START = '/* ── the module picker (task 1002339, BV1.R20) ──';
-const END = "$('skipModules').addEventListener('click', function () { show(8, true); });";
+const END = '/* ── GitHub-integrated repo picker';
 const from = HUB.indexOf(START);
-const to = HUB.indexOf(END);
+const to = HUB.indexOf(END, from);
 assert.ok(from > -1, 'the picker block opens with its sentinel comment');
-assert.ok(to > from, 'the picker block closes with the skip wiring');
-const PICKER = HUB.slice(from, to + END.length).replace(/\r\n/g, '\n');
+assert.ok(to > from, 'the picker block closes where the repo picker begins');
+const PICKER = HUB.slice(from, to).replace(/\r\n/g, '\n');
+assert.ok(PICKER.includes('function extrasRow()'), 'and it carries the row text the review reads');
+assert.doesNotMatch(HUB, /id="skipModules"|id="panel-modules"/, 'the old panel and its Skip are gone (task 1004504)');
+// the review's rows: which apply, confirming one, and the delegated click
+const RSTART = '    var ROWS = [';
+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');
 
 // The payload GET /provisioning/starter-bundles serves (ADR 0237 + task 1002339).
 // Deliberately a FIXTURE and not a live require: this asserts the picker reads
@@ -128,9 +142,20 @@ function makeEl(id) {
     setAttribute(k, v) { attrs.set(k, String(v)); },
     getAttribute(k) { return attrs.has(k) ? attrs.get(k) : null; },
     addEventListener(type, fn) { this._handlers[type] = fn; },
+    focus() {},
   };
 }
 
+// One review row, shaped like the markup: its hidden .opts, Looks right and Change.
+function makeRow(key) {
+  const row = makeEl('row-' + key);
+  row.setAttribute('data-row', key);
+  const parts = { '.opts': makeEl('opts-' + key), '[data-row-ok]': makeEl('ok-' + key), '[data-row-chg]': makeEl('chg-' + key) };
+  parts['.opts'].hidden = true;
+  row.querySelector = (sel) => parts[sel] || null;
+  return row;
+}
+
 // Parse the rows the picker WROTE, so a selector resolves only when the markup
 // is genuinely there — the point of the harness.
 function rowsOf(html) {
@@ -159,23 +184,28 @@ 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); };
-  const form = makeEl('panel-modules-form');
-  const state = { step: 7, projType: null, teamShape: null, modules: null, ...seed };
-  const shown = [];
+  // step 4 is the review, where the Extras row lives (task 1004504)
+  const state = { step: 4, projType: null, teamShape: null, modules: null, confirmed: {}, ...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;
   let fetches = 0;
   let reviews = 0;
 
   const sandbox = {
     $,
-    root: { querySelector: (sel) => (sel === '#panel-modules form' ? form : null) },
+    root: { querySelector: (sel) => (sel.indexOf('#reviewRows .setRow') === 0 ? rowFor(sel) : null) },
     esc: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
     state,
     saveDraft: () => { saves++; },
-    show: (step) => { shown.push(step); },
-    // the block repaints the review when the read lands on step 7 (a resumed
-    // draft can reach it having never opened the picker)
-    renderReview: () => { reviews++; },
+    // the block repaints the review's rows when the read lands on step 4 (a resumed
+    // draft can reach it having never opened the Extras row)
+    paintSetup: () => { reviews++; },
+    // the review's other rows close over checks this file does not drive
+    physSkips: () => false, appSkipped: () => false, physAnswered: () => true,
+    phys: () => ({ answers: { framing: 'managed' } }),
+    validateCode: () => true, validateAddress: () => true, validateRender: () => true,
+    checkSlugAvailable: () => {}, renderAddrPanel: () => {}, syncHome: () => {}, syncAppStep: () => {}, syncRenderSetup: () => {},
     API: '/api/bongos',
     fetch: () => { fetches++; return Promise.resolve(fetchOk
       ? { ok: true, json: () => Promise.resolve(payload) }
@@ -184,11 +214,17 @@ function boot({ state: seed = {}, fetchOk = true, payload = PAYLOAD } = {}) {
   };
   sandbox.globalThis = sandbox;
   vm.createContext(sandbox);
-  vm.runInContext(PICKER, sandbox, { filename: 'projects.html#module-picker' });
+  vm.runInContext(PICKER + '\n' + REVIEW, sandbox, { filename: 'projects.html#module-picker' });
 
   const band = $('modCards');
+  // a click inside the review, through its one delegated listener, as the browser sends it
+  const rowClick = (attr) => {
+    const row = rowFor('#reviewRows .setRow[data-row="extras"]');
+    const t = { hasAttribute: (a) => a === attr, closest: (sel) => (sel === '.setRow' ? row : null) };
+    $('reviewRows')._handlers.click({ target: { closest: () => t } });
+  };
   return {
-    state, shown, sandbox, form,
+    state, sandbox,
     saves: () => saves,
     fetches: () => fetches,
     reviews: () => reviews,
@@ -210,8 +246,12 @@ function boot({ state: seed = {}, fetchOk = true, payload = PAYLOAD } = {}) {
       };
       band._handlers.click({ target });
     },
-    next: () => form._handlers.submit({}),
-    skip: () => $('skipModules')._handlers.click(),
+    // "Looks right" on the Extras row, "Change" to open it, "Use this" inside it
+    looksRight: () => rowClick('data-row-ok'),
+    change: () => rowClick('data-row-chg'),
+    use: () => rowClick('data-row-use'),
+    confirmed: () => !!(state.confirmed && state.confirmed.extras),
+    unconfirmed: () => [...sandbox.unconfirmedRows()],
     forCreate: () => sandbox.modulesForCreate(),
     picked: () => sandbox.pickedModules(),
     // BV1.R21 (task 1002340) — the search box. type() is the real `input` event
@@ -302,41 +342,42 @@ 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('Skip walks past WITHOUT answering, so the server applies the bundle the panel showed', async () => {
+test('an unconfirmed row answers NOTHING, and Create waits for it (no Skip since task 1004504)', async () => {
   // Arrange
   const h = boot({ state: { projType: 'game' } });
   await h.open();
 
-  // Act
-  h.skip();
-
-  // Assert — skipping is the one path that must leave nothing said, because the
-  // preselect and the server's fallback are the same declaration (ADR 0237)
-  assert.deepEqual(h.shown, [8], 'it advances to the Home step (8 since task 1004418, 7 since 1004417)');
-  assert.equal(h.state.modules, null, 'and answers nothing');
-  assert.equal(h.forCreate(), undefined);
-  assert.deepEqual(h.picked(), ['npm-release', 'discord'], 'while the set they were shown is still the set they get');
+  // Assert — the row is shown prefilled, and until it is confirmed nothing is said:
+  // 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');
 });
 
-test('Skip does not erase a toggle already made', async () => {
-  // The About step's rule: a visitor who changed something and then pressed Skip
-  // meant "I'm done here", not "throw that away".
+test('Change, a toggle, then Use this: the toggle stands as the answer', async () => {
+  // A visitor who changed something and then confirmed meant "this", not "throw that away".
   const h = boot({ state: { projType: 'game' } });
   await h.open();
+  h.change();
+  assert.equal(h.sandbox.$('modCards').innerHTML.length > 0, true, 'opening the row paints the picker');
   h.click('agents');
-  h.skip();
+  h.use();
 
   assert.deepEqual(h.state.modules, ['agents', 'npm-release', 'discord']);
+  assert.equal(h.confirmed(), true, 'and the row is confirmed');
 });
 
-test('Next CONFIRMS the set on screen — looking at it and accepting it is not the same as never being asked', async () => {
+test('Looks right CONFIRMS the set on screen — looking at it and accepting it is not the same as never being asked', async () => {
   const h = boot({ state: { projType: 'game' } });
   await h.open();
 
-  h.next();
+  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');
 });
 
 test('changing the project type re-preselects while nothing has been said, and never after', async () => {
@@ -376,12 +417,18 @@ 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');
-  h.skip();
-  assert.deepEqual(h.shown, [8], 'and the wizard still walks on — the server applies the bundle');
+  // 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');
+  // (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"');
 });
 
 test('every rendered value goes through the page escaper', async () => {
-  // The rows are built with innerHTML (renderReview's existing idiom in this
+  // The rows are built with innerHTML (the old review ledger's idiom in this
   // file), so the escaping is the safety property and it is asserted, not assumed.
   const h = boot({ state: { projType: 'game' } });
   await h.open();
@@ -410,12 +457,12 @@ test('the catalog read is LAZY and asked once — /projects serves four views fr
   assert.equal(h.fetches(), 1, 'entering the step asks exactly once, however often it is entered');
 });
 
-test('the review names the set even when the picker was never opened (task 1002339)', async () => {
+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
   // and the module NAMES are not known. "None — just the core" would be a false
-  // promise on the last screen 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: 12 } });   // 12 = the review since task 1004418 (11 since 1004421, 10 since 1004417, 8 since 1004351)
+  // 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)
 
   // Arrange + Act — the review asks for the value before the read can answer
   const first = h.extrasRow();
@@ -425,27 +472,31 @@ test('the review names the set even when the picker was never opened (task 10023
   assert.equal(h.fetches(), 1, 'and asking for it is what starts the read');
 
   await h.settle();
-  assert.equal(h.reviews(), 1, 'the review repaints itself once the names are known');
+  assert.equal(h.reviews(), 1, 'the review repaints its rows once the names are known');
   assert.equal(h.extrasRow(), 'npm releases, Discord', 'and then it names them');
+  const elsewhere = boot({ state: { projType: 'game', step: 3 } });
+  elsewhere.extrasRow();
+  await elsewhere.settle();
+  assert.equal(elsewhere.reviews(), 0, 'off the review, a landing read repaints no rows');
 });
 
-test('the review reads an answered picker back, empty included', async () => {
-  const chosen = boot({ state: { projType: 'game', modules: ['agents'], step: 8 } });
+test('the Extras row reads an answered picker back, empty included', async () => {
+  const chosen = boot({ state: { projType: 'game', modules: ['agents'], step: 3 } });
   // before the catalog lands the row says the true thing without the names —
   // never the raw module keys, which are jargon on an owner-facing screen
   assert.equal(chosen.extrasRow(), 'The extras you picked');
   await chosen.settle();
   assert.equal(chosen.extrasRow(), 'Extra agents', 'and names them once it has');
 
-  const none = boot({ state: { projType: 'game', modules: [], step: 8 } });
+  const none = boot({ state: { projType: 'game', modules: [], step: 3 } });
   none.extrasRow();
   await none.settle();
   assert.equal(none.extrasRow(), 'None — just the core', 'a deliberate "none" is stated as one');
 });
 
 // ─────────────────────────────────────────────────────────────────────────────
-// BV1.R22 (task 1002341) — the About step's answer reaches the preselect, and
-// the panel says why. ADR 0243.
+// BV1.R22 (task 1002341) — the team shape (the About step's answer, the review's
+// Team size row since task 1004504) reaches the preselect, and the row says why. ADR 0243.
 // ─────────────────────────────────────────────────────────────────────────────
 
 test('the team shape adjusts the type bundle, and the panel says why in the owner\'s words', async () => {
@@ -487,9 +538,9 @@ test('an added module is preselected and explained', async () => {
   assert.deepEqual(h.why(), ['You said an open community is building this, so somewhere for it to gather is switched on.']);
 });
 
-test('answering the About step later re-preselects, with no second read', async () => {
-  // The two questions live on two earlier panels and are both changeable. The
-  // whole table arrived in one read precisely so going back costs nothing.
+test('changing the team shape later re-preselects, with no second read', async () => {
+  // The kind and the team are both changeable. The whole table arrived in one read
+  // precisely so a change costs nothing.
   const h = boot({ state: { projType: 'research' }, payload: TAILORED });
   await h.open();
   assert.deepEqual(h.rows().filter((r) => r.pressed).map((r) => r.key), ['agents'], 'unanswered: the raw bundle');
@@ -501,19 +552,18 @@ test('answering the About step later re-preselects, with no second read', async
   assert.equal(h.fetches(), 1, 'and the answer cost no round trip');
 });
 
-test('Skip after an answered About step still yields the set the panel showed', async () => {
+test('after a team answer the unconfirmed row still answers nothing, and confirming takes 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 skipping
-  // must still answer NOTHING and still land the tailored set.
+  // 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.
   const h = boot({ state: { projType: 'game', teamShape: 'solo' }, payload: TAILORED });
   await h.open();
 
-  h.skip();
-
-  assert.deepEqual(h.shown, [8]);
-  assert.equal(h.state.modules, null, 'skipping answers nothing, tailored or not');
-  assert.equal(h.forCreate(), undefined, 'so the create request still carries no modules key');
+  assert.equal(h.state.modules, null, 'unconfirmed 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 () => {
@@ -820,8 +870,8 @@ test('with nothing switched on the count says only what is shown', async () => {
   assert.equal(h.filterNote(), 'Showing 3 of 3.', 'no "0 extras are switched on" noise');
 });
 
-test('the review names the hidden picks too — a filter never reaches the create request', async () => {
-  const h = boot({ state: { projType: 'game', step: 12 } });   // 12 = the review since task 1004418 (11 since 1004421, 10 since 1004417, 8 since 1004351)
+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)
   await h.open();
   h.click('agents');
   assert.deepEqual(h.forCreate(), ['agents', 'npm-release', 'discord']);

package/tests/projects_hub_pre_uat.mjs

@@ -229,14 +229,21 @@ test('the wizard’s 401 recoveries keep the repo scope they already granted', (
   assert.match(fn('signInAgain'), /currentView === 'new' \? '\/projects%3Fview%3Dnew&repos=1'/, 'signInAgain from the wizard');
 });
 
-test('a resumed draft past Home still probes repo access before Create', () => {
+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 > ${STEP['panel-home']} && step < ${DONE} && authKnown && repoAccess === null) ensureRepoAccess();`),
-    'every step between Home and the done panel re-probes');
+    `else if (step > ${REVIEW} && step < ${DONE} && authKnown && repoAccess === null) ensureRepoAccess();`),
+    'every screen between the review and the done panel re-probes');
 });
 
-test('a half-typed custom domain says why Next is dead; a taken handle silences the format cheer', () => {
-  assert.match(SCRIPT, /That doesn’t look like a domain yet \(e\.g\. mercury\.example\.com\) — fix it, or clear the field to use the address above\./);
+test('a half-typed custom domain says why Use this is dead; a taken handle silences the format cheer', () => {
+  assert.match(SCRIPT, /That doesn’t look like a domain yet \(e\.g\. moonbase\.example\.com\) — fix it, or clear the field to use the address above\./);
   assert.match(SCRIPT, /if \(avail === 'taken' \|\| avail === 'yours' \|\| avail === 'reserved'\) \{ var hs = \$\('h-slug'\); hs\.innerHTML = '&nbsp;'; hs\.className = 'hint'; \}/);
 });
 
@@ -245,12 +252,14 @@ test('no wall-clock promises, no operator vocabulary on the stranger’s path',
   assert.doesNotMatch(HUB, /about five minutes/, 'the empty state');
   assert.doesNotMatch(HUB, /a runner does the real work/, 'the mine fine print');
   assert.doesNotMatch(SCRIPT, /pinned platform core/, 'the review Shape row');
-  /* Since ADR 0345 (task 1004351) the review names the HALL as hosted by us and gives the
-     APP its own row. The assertion still guards the same property this test is about:
-     owner vocabulary, and no wall-clock promise. */
-  assert.ok(SCRIPT.includes("['Builders\\' hall', 'Hosted by us, on the platform’s current release'],"), 'the review names the hall as hosted by us');
+  /* 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.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');
-  assert.match(HUB, /Sign-in switches on after the GitHub steps|switch sign-in on/, 'the address step does not promise sign-in "just works"');
+  assert.match(HUB, /[Ss]ign-in switches on after the GitHub steps|switch sign-in on/, 'the address step does not promise sign-in "just works"');
   assert.doesNotMatch(HUB, /Sign-in, sharing, everything just works/);
 });
 
@@ -465,10 +474,19 @@ test('decision 5 — the Type step says where the type can be changed (task 1003
   // for now", because no owner-facing route could change a declared type. Task 1003504
   // built that route and the manage page's "Its kind" picker on it, so the sentence is
   // earned back — and it now has to name WHERE, or it is a promise with no address.
-  const type = (HUB.match(/<section class="panel" id="panel-type"[\s\S]*?<\/section>/) || [''])[0];
-  assert.ok(type, '#panel-type exists');
-  assert.match(type, /<p class="lede">Pick the shape that fits best — it’s how the project is listed on the map, and you can change it later from the project’s own page\. Not sure is a fine answer\.<\/p>/);
-  assert.doesNotMatch(type, /stays as you pick it/, 'the narrowed promise must not survive beside the wider one');
+  // task 1004504 folded the Type step into "What are you making?" as its Kind field, in the
+  // 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');
+  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');
+  }
+  // and the address it would name is real: the manage page's "Its kind" picker
+  assert.match(HUB, /<h2>Its kind<\/h2>/, 'the project’s own page carries the kind picker');
 });
 
 test('decision 8 — a card carrying a red error paragraph never tallies under Live', () => {
@@ -542,23 +560,17 @@ test('a manifest error says a plain sentence, folds the route text, and sends a
   assert.equal((SCRIPT.match(/manifestMsg: '', manifestCode: '', appSlug: null/g) || []).length, 2, 'both resets carry the code');
 });
 
-test('the rail at the done panel keeps its marker on Create until the project answers', () => {
-  const rail = fn('paintRail');
-  assert.ok(rail.includes(`var landed = step === ${DONE} && !!(live && live.instStatus === 'active');`),
-    'the rail only finishes on the done panel');
-  assert.ok(rail.includes(`var cur = step === ${DONE} ? ${DONE - 1} : step;`),
-    'the done panel keeps the marker on the last numbered beat');
-  assert.match(rail, /li\.classList\.toggle\('done', landed \|\| n < cur\);/);
-  assert.match(rail, /if \(now\) li\.setAttribute\('aria-current', 'step'\); else li\.removeAttribute\('aria-current'\);/);
-  assert.match(fn('show'), /paintRail\(step\);/, 'show() paints through it');
-  assert.doesNotMatch(fn('show'), /classList\.toggle\('done'/, 'and no longer marks the rail on its own');
-  assert.ok(SCRIPT.includes(`if (state.step === ${DONE}) paintRail(${DONE});`),
-    'the done-panel poll repaints when the status moves');
-  // the first NUMBERED beat carries it — since task 1004417 the front door's two screens come
-  // before the rail, and the card statically wears wizFront so a no-script visitor sees no rail there
-  // (since task 1004418 that beat is planet physics, the first numbered step)
-  assert.match(HUB, new RegExp(`<li class="now" data-step="${STEP['panel-physics']}" aria-current="step"><span class="snum">1</span>`), 'the static rail starts with the same marker');
-  assert.match(HUB, /<section id="view-new" hidden>\s*<div class="wrap viewWrap">\s*<div class="card wizFront">/, 'and steps aside on the static first screen');
+test('the progress rail is gone (task 1004504): no painter, no repaint at the done panel, no static rail', () => {
+  // task 1003244 kept the rail's marker on Create until the project answered; task 1004504
+  // retired the rail outright, so nothing on the page may still paint or carry one
+  assert.doesNotMatch(SCRIPT, /function paintRail|paintRail\(/, 'no rail painter, and no caller');
+  assert.doesNotMatch(fn('show'), /paintRail|classList\.toggle\('done'/, 'show() marks no rail of any kind');
+  assert.doesNotMatch(HUB, /data-step="\d+"/, 'no static rail beat ships in the markup');
+  assert.doesNotMatch(HUB, /<ol class="steps"/, 'no rail list ships in the markup');
+  // the night room sits behind the card; the card opens on the eyebrow and the one Back, then the wizard
+  assert.match(HUB, /<section id="view-new" hidden>[\s\S]*?<\/div>\s*<div class="wrap viewWrap">\s*<div class="card[^"]*">\s*(?:<!--[\s\S]*?-->\s*)?<div class="wizTop">[\s\S]*?<\/div>\s*<div class="createSplit">/, 'the card opens on its top row, then straight on the wizard');
+  const head = HUB.slice(HUB.indexOf('<section id="view-new"'), HUB.indexOf('<div class="createSplit">'));
+  assert.doesNotMatch(head, /class="steps|data-step=/, 'no rail between the room and the wizard');
 });
 
 test('every action result announces, nothing under the pointer is deleted, and focus stays where it was', () => {
@@ -682,16 +694,11 @@ test('the hub has one main landmark, a heading for the map, a footer, and a skip
   assert.doesNotMatch(HUB, /<main class="card">/, 'the old inner main is a div');
 });
 
-test('completed rail steps are a way back, the repo picker is honest ARIA, the card inerts the page', () => {
-  assert.ok(fn('paintRail').includes(`if (step < ${DONE} && n < cur) {`),
-    'only answered steps become buttons, and none once the project is filed');
-  assert.ok(fn('paintRail').includes("li.setAttribute('data-goto', String(n));"),
-    'and an answered step carries the goto the delegated handler reads');
-  assert.match(SCRIPT, /railEl\.addEventListener\('click'/);
-  assert.match(SCRIPT, /railEl\.addEventListener\('keydown'/);
-  assert.match(SCRIPT, /show\(Number\(li\.getAttribute\('data-goto'\)\), true\)/, 'a deliberate step: focus moves');
-  assert.match(COSMOS, /\.steps li\[role=button\]\{cursor:pointer;\}/);
-  assert.match(COSMOS, /\.steps li\[role=button\]:focus-visible\{outline:2px solid var\(--accent\);/);
+test('the rail\'s way-back handlers left with it, the repo picker is honest ARIA, the card inerts the page', () => {
+  // task 1003246 made answered rail steps a way back; task 1004504 retired the rail, so its
+  // delegated handlers and their CSS must not linger as dead code
+  assert.doesNotMatch(SCRIPT, /railEl|data-goto/, 'no delegated rail handler is left');
+  assert.doesNotMatch(COSMOS, /\.steps li\[role=button\]/, 'and no rail-button CSS');
   assert.doesNotMatch(HUB, /role="listbox"/);
   assert.doesNotMatch(SCRIPT, /role="option"/);
   assert.match(HUB, /<div id="ghList" class="ghlist" role="group" aria-label="Your repositories"><\/div>/, 'the label survives the listbox role');

package/tests/provision.mjs

@@ -1074,6 +1074,84 @@ await ta('scaffoldStandaloneRepo: a REGISTRY-pinned consumer control plane PACKS
   }
 });
 
+// ── new projects start on the RELEASED core, not the hall's candidate (task 1004299) ──
+// ADR 0361: merges publish as candidates and the platform hall runs them, so the core
+// this hall runs is routinely AHEAD of the registry's `latest` label. A new project —
+// and the pin refresh that runs in the same provisioning pass — must get the release.
+t('projectCoreDecision: the hall ahead of the release → the release; level or unreadable → the running core', () => {
+  assert.deepEqual(
+    (({ version, source }) => ({ version, source }))(RP.projectCoreDecision({ running: '1.19.60', released: '1.19.50' })),
+    { version: '1.19.50', source: 'released' });
+  assert.equal(RP.projectCoreDecision({ running: '1.19.50', released: '1.19.50' }).source, 'running', 'level → byte-exact running core, no registry pack');
+  assert.equal(RP.projectCoreDecision({ running: '1.19.40', released: '1.19.50' }).version, '1.19.40', 'never moves a project PAST what the hall has run');
+  assert.equal(RP.projectCoreDecision({ running: '1.19.60', released: null }).version, '1.19.60', 'no label → fail-open to the running core');
+  assert.equal(RP.projectCoreDecision({ running: '1.19.60', released: '1.19.50-rc.1' }).source, 'running', 'a prerelease label is not a release');
+  assert.equal(RP.projectCoreDecision({ running: '1.19.60', released: '1.19.50;touch /tmp/x' }).source, 'running', 'a non-semver label never reaches a shell');
+});
+
+// A registry-installed control plane at 1.19.60 whose registry says `latest` = 1.19.50.
+function candidateHall({ latest }) {
+  const cp = mkdtempSync(join(tmpdir(), 'cpdir-cand-'));
+  mkdirSync(join(cp, 'node_modules', '@bongos', 'core'), { recursive: true });
+  writeFileSync(join(cp, 'node_modules', '@bongos', 'core', 'package.json'), JSON.stringify({ name: '@bongos/core', version: '1.19.60' }));
+  writeFileSync(join(cp, 'package.json'), JSON.stringify({ dependencies: { '@bongos/core': '1.19.60' } }));
+  const { deps, cmds } = recorder({ apply: true });
+  const exec = (cmd, o) => { cmds.push(cmd); return /^npm view @bongos\/core dist-tags\.latest$/.test(cmd) ? { ok: true, stdout: `${latest}\n` } : { ok: true, stdout: '' }; };
+  return { cp, cmds, deps: { ...deps, exec, instanceRoot: cp } };
+}
+
+await ta('scaffoldStandaloneRepo: a hall running an UNRELEASED candidate births the project on the released core (task 1004299)', async () => {
+  const { cp, cmds, deps } = candidateHall({ latest: '1.19.50' });
+  const base = mkdtempSync(join(tmpdir(), 'cpdir-standalone-'));
+  const origBase = P.CONFIG.standaloneBase;
+  P.CONFIG.standaloneBase = base;
+  try {
+    await P.scaffoldStandaloneRepo({ slug: 'demo', hosting_shape: 'cloud-host', target_ref: 'example-owner/demo' }, deps);
+    const joined = cmds.join('\n');
+    assert.match(joined, /npm pack @bongos\/core@1\.19\.50 --pack-destination /, 'packs the RELEASED version from the registry');
+    assert.match(joined, /--vendor-core \S*bongos-core-1\.19\.50\.tgz/, 'the child is pinned to the release');
+    assert.ok(!/1\.19\.60\.tgz|bongos-core-pack-1\.19\.60/.test(joined), 'the candidate the hall runs is never vended');
+    assert.match(joined, /on a pinned @bongos\/core 1\.19\.50 /, 'the scaffold commit names the version it really pinned');
+    assert.ok(joined.indexOf('rm -rf') > joined.indexOf('--vendor-core'), 'the temp pack dir is cleaned after init');
+  } finally {
+    P.CONFIG.standaloneBase = origBase;
+    [cp, base].forEach((d) => rmSync(d, { recursive: true, force: true }));
+  }
+});
+
+await ta('scaffoldStandaloneRepo: a hall running the release itself keeps the byte-exact running core (task 1004299)', async () => {
+  const { cp, cmds, deps } = candidateHall({ latest: '1.19.60' });
+  const base = mkdtempSync(join(tmpdir(), 'cpdir-standalone-'));
+  const origBase = P.CONFIG.standaloneBase;
+  P.CONFIG.standaloneBase = base;
+  try {
+    await P.scaffoldStandaloneRepo({ slug: 'demo', hosting_shape: 'cloud-host', target_ref: 'example-owner/demo' }, deps);
+    const joined = cmds.join('\n');
+    assert.ok(!/npm pack @bongos\/core@/.test(joined), 'no registry pack when nothing is unreleased');
+    assert.match(joined, /--vendor-core \S*bongos-core-1\.19\.60\.tgz/);
+  } finally {
+    P.CONFIG.standaloneBase = origBase;
+    [cp, base].forEach((d) => rmSync(d, { recursive: true, force: true }));
+  }
+});
+
+await ta('refreshStandaloneCorePin: a project pinned to the release is NOT bumped to the hall\'s candidate in the same run (task 1004299)', async () => {
+  const { cp, cmds, deps } = candidateHall({ latest: '1.19.50' });
+  const base = mkdtempSync(join(tmpdir(), 'cpdir-standalone-'));
+  const origBase = P.CONFIG.standaloneBase;
+  P.CONFIG.standaloneBase = base;
+  try {
+    mkdirSync(join(base, 'demo'));
+    writeFileSync(join(base, 'demo', 'package.json'), JSON.stringify({ dependencies: { '@bongos/core': 'file:vendor/bongos-core-1.19.50.tgz' } }));
+    const res = await P.refreshStandaloneCorePin({ slug: 'demo', hosting_shape: 'cloud-host', target_ref: 'example-owner/demo' }, deps);
+    assert.equal(res.action, 'current', 'the released pin is already the core this project is given');
+    assert.ok(!cmds.some((c) => /npm pack/.test(c)), 'nothing is packed or re-vendored');
+  } finally {
+    P.CONFIG.standaloneBase = origBase;
+    [cp, base].forEach((d) => rmSync(d, { recursive: true, force: true }));
+  }
+});
+
 // ── scaffold push via the owner OAuth token (task 1002317) ────────────────────────
 // Deploy keys are per-repo; a shared key can't write to a NEW project repo. Push with the
 // owner's token (which created the repo) instead — WITHOUT leaking it into a logged command.

package/tests/public_landing_projects.mjs

@@ -327,7 +327,8 @@ test('the create-repo response keeps the html_url it already returned', async ()
 
 test('the no-address opt-out is visible at the step, not folded under "a domain I own" (N8)', async () => {
   const { body } = await request('/projects', 'game.test.local');
-  const panel = (body.match(/<div class="addrConfirm" id="addrConfirm">([\s\S]*?)\n {14}<\/div>/) || [, ''])[1];
+  // since task 1004504 the address step is the review's Address row; the box moved in whole
+  const panel = (body.match(/<div class="addrConfirm" id="addrConfirm">([\s\S]*?)\n {22}<\/div>/) || [, ''])[1];
   assert.ok(panel, 'the address confirmation box must be extractable');
   const fold = (panel.match(/<details id="addrCustom">[\s\S]*?<\/details>/) || [''])[0];
   assert.ok(fold, 'the bring-your-own-domain disclosure still exists');
@@ -338,8 +339,10 @@ test('the no-address opt-out is visible at the step, not folded under "a domain
     'the opt-out sits after the disclosure, in the open');
   // all three choices legible at once: assigned address, own domain, no address
   assert.match(panel, /id="addrAssigned"/);
-  assert.match(fold, /Use a domain I own instead/);
-  assert.match(panel, /Start without an address/);
+  assert.match(fold, /<summary>A domain I own<\/summary>/);
+  assert.match(panel, /No address yet\. Sign-in can’t be switched on until it has one\./,
+    'the opt-out is offered in the open, and says what going without costs');
+  assert.match(body, /<div class="setRow" data-row="address">[\s\S]*?id="addrConfirm"/, 'and the box lives on the review\'s Address row');
 });
 
 test('the ownership promise is gated on the availability answer, never on format (N10)', async () => {
@@ -375,9 +378,12 @@ test('the availability check is debounced, generation-guarded, and fails to "unk
 
 test('only a DEFINITE negative blocks the step — unknown and checking never gate it (N10)', async () => {
   const { body } = await request('/projects', 'game.test.local');
-  const fn = (body.match(/function validateStep\(step\)\s*\{([\s\S]*?)\n    \}/) || [, ''])[1];
-  assert.ok(fn, 'validateStep() must be extractable');
-  const gate = (fn.match(/if \(!state\.domain && !state\.noAddress\) \{[\s\S]*?\n {8}\}/) || [''])[0];
+  // since task 1004504 the address step's Next check is validateAddress(), run when the
+  // review's Address row is confirmed
+  const fn = (body.match(/function validateAddress\(\)\s*\{([\s\S]*?)\n    \}/) || [, ''])[1];
+  assert.ok(fn, 'validateAddress() must be extractable');
+  assert.match(body, /if \(key === 'address'\) return validateAddress\(\);/, 'and the Address row cannot be confirmed past it');
+  const gate = (fn.match(/if \(!state\.domain && !state\.noAddress\) \{[\s\S]*?\r?\n {6}\}/) || [''])[0];
   assert.ok(gate, 'the availability gate must be extractable');
   assert.match(gate, /av === 'taken' \|\| av === 'yours' \|\| av === 'reserved'/,
     'exactly the three definite negatives block');