@bongos/core 1.21.105 → 1.21.107

package/tests/projects_hub_dns_ready.mjs

@@ -7,7 +7,7 @@
 // carries `dns_resolves` (the server's sighting — modules/provisioning/dns-resolves.js)
 // or a verified up probe. The status alone, 'active' included, is never enough.
 //
-// EXECUTED by the vm-slice idiom: the done panel's renderProgress, the card's
+// EXECUTED by the vm-slice idiom: part 03's Its home facts (homeFacts, task 1004683), the card's
 // addressRow and the row's orbFor are sliced verbatim out of projects.html and run
 // under a narrow stub, and the markup they write is read back. Every slice boundary is
 // asserted, so a rename fails loudly instead of testing nothing. vm-born values are
@@ -36,27 +36,23 @@ function slice(from, to) {
   return HUB.slice(a, b);
 }
 
-const PROGRESS = slice('var PROG_FLOWS = {', 'function startProgress(');
+// part 03's Its home (task 1004683): the three facts read off the owner's instance read
+function wizFn(name) {
+  const m = HUB.match(new RegExp(`\\n {4}function ${name}\\([^)]*\\) \\{[\\s\\S]*?\\n {4}\\}`));
+  assert.ok(m, `function ${name}() must be findable in projects.html`);
+  return m[0];
+}
+const FACTS = ['hostOk', 'whenSaid', 'homeFacts'].map(wizFn).join('\n');
 const OVERLAY = slice('function verifiedAt(inst)', 'function chipMarkup(');
 const ADDRESS = slice('var ADDRESS_SETTING_UP', 'function publishRow(');
 const ORB = slice('function orbFor(', '/* ── progress strips');
-for (const [name, region] of [['renderProgress', PROGRESS], ['addressReady', OVERLAY], ['addressRow', ADDRESS], ['orbFor', ORB]]) {
+for (const [name, region] of [['homeFacts', FACTS], ['addressReady', OVERLAY], ['addressRow', ADDRESS], ['orbFor', ORB]]) {
   assert.ok(region.includes(`function ${name}(`), `the slice must carry ${name}`);
 }
 
 function boot() {
-  const liveProgress = { innerHTML: '' };
-  // the done panel's heading (task 1004504): "Setting up <name>" until the project answers
-  const doneH = { textContent: 'Setting up Lantern' };
-  // and the line under it (task 1004543): renderDone's "setting up" until the project answers
-  const SETTING_UP = 'We’re setting up <strong>Lantern</strong>: its server, database and address.';
-  const doneLede = { innerHTML: SETTING_UP };
-  // the invite step's gate (task 1004503): renderProgress opens it only on a verified answer
-  const gates = [];
   const sandbox = {
-    $: (id) => ({ liveProgress, 'done-h': doneH, doneLede })[id] || null,
-    state: { name: 'Lantern', slug: 'lantern' },
-    paintInviteGate: (live) => gates.push(live),
+    live: { readAt: Date.now() },
     esc: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => (
       { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
     projectPageLink: (label) => '<a href="?view=manage&id=1">' + label + '</a>',
@@ -66,54 +62,47 @@ function boot() {
     planetAttrs: () => '',
     FRESH_MS: 12 * 60 * 1000,
     LIVE_MOMENT_MS: 10 * 60 * 1000,
-    lastProgHtml: '',
   };
   vm.createContext(sandbox);
-  vm.runInContext(PROGRESS + '\n' + OVERLAY + '\n' + ADDRESS + '\n' + ORB, sandbox);
-  return { sandbox, progress: () => liveProgress.innerHTML, heading: () => doneH.textContent, lede: () => doneLede.innerHTML, SETTING_UP, gates };
+  vm.runInContext(OVERLAY + '\n' + ADDRESS + '\n' + ORB + '\n' + FACTS, sandbox);
+  // Its home as the founder sees it: each fact's state and every word it says
+  const home = (inst) => JSON.parse(JSON.stringify(sandbox.homeFacts(inst, Date.now())));
+  const words = (rows) => rows.map((r) => [r.title, [].concat(r.sub || []).map((p) => (typeof p === 'string' ? p : p.t)).join(''), r.right || ''].join(' ')).join('\n');
+  return { sandbox, home, words };
 }
 
 const NOW = () => new Date().toISOString();
-const base = { id: 1, slug: 'lantern', status: 'active', domain: 'lantern.cloudbongos.com', last_verified_at: null, last_verified_up: null, dns_note: null };
 const ADDRESS_LINK = /<a [^>]*href="https:\/\/lantern\.cloudbongos\.com/;
+const base = { id: 1, slug: 'lantern', status: 'active', domain: 'lantern.cloudbongos.com', created_at: NOW(), provisioned_at: NOW(), last_verified_at: null, last_verified_up: null, dns_note: null, open_intent: null };
 
-test('active but not yet resolved: the done panel holds the link, says so, and keeps watching', () => {
+test('active but not yet resolved: part 03 says the address is on its way, never names it, and keeps it a fact under way', () => {
   const h = boot();
-  const terminal = h.sandbox.renderProgress({ ...base, dns_resolves: false });
-  assert.equal(terminal, false, 'the panel keeps polling until the lookup answers');
-  assert.doesNotMatch(h.progress(), ADDRESS_LINK);
-  assert.doesNotMatch(h.progress(), /lantern\.cloudbongos\.com/, 'and does not even name it to be typed');
-  assert.match(h.progress(), /your address is being set up/);
+  const rows = h.home({ ...base, dns_resolves: false });
+  assert.deepEqual(rows.map((r) => r.state), ['done', 'done', 'now'], 'kept, running, not answering yet');
+  assert.equal(rows[2].sub, 'New addresses can take a few minutes to reach everyone.');
+  assert.doesNotMatch(h.words(rows), /lantern\.cloudbongos\.com/, 'a name typed before it resolves is cached as not found: not even named');
 });
 
-test('a down probe on a never-resolved address is still "being set up", never a link', () => {
+test('a down probe on a never-resolved address is still on its way, never named', () => {
   const h = boot();
-  h.sandbox.renderProgress({ ...base, dns_resolves: false, last_verified_up: false, last_verified_at: NOW() });
-  assert.doesNotMatch(h.progress(), ADDRESS_LINK);
-  assert.match(h.progress(), /being set up/);
+  const rows = h.home({ ...base, dns_resolves: false, last_verified_up: false, last_verified_at: NOW() });
+  assert.equal(rows[2].state, 'now');
+  assert.doesNotMatch(h.words(rows), /lantern\.cloudbongos\.com/);
 });
 
-test('once the lookup answers, the done panel links the address', () => {
+test('once the lookup answers, part 03 names the address; only a verified answer ticks "Address answers"', () => {
   const h = boot();
-  const terminal = h.sandbox.renderProgress({ ...base, dns_resolves: true });
-  assert.equal(terminal, false, 'resolving is not yet answering — the panel still waits for the probe');
-  assert.match(h.progress(), ADDRESS_LINK);
-  assert.equal(h.heading(), 'Setting up Lantern', 'and the heading claims nothing yet (task 1004504)');
-  assert.deepEqual(h.gates, [], 'and the invite box stays shut: the hall has not answered (task 1004503)');
-  assert.equal(h.lede(), h.SETTING_UP, 'and the line under it still says it is being set up (task 1004543)');
-  const live = boot();
-  assert.equal(live.sandbox.renderProgress({ ...base, dns_resolves: true, last_verified_up: true, last_verified_at: NOW() }), true);
-  assert.match(live.progress(), ADDRESS_LINK);
-  assert.equal(live.heading(), 'Lantern is alive.', 'the alive moment, only on a verified answer');
-  assert.deepEqual(live.gates, [true], 'and the invite box opens with it (task 1004503)');
-  assert.match(live.lede(), /^Its home is ready\. Watch the rest here, or any time on <a href="\?view=mine">your projects page<\/a>\.$/,
-    'and the line under it stops saying "setting up" (task 1004543)');
-  assert.doesNotMatch(live.lede(), /setting up/i);
-  const down = boot();
-  down.sandbox.renderProgress({ ...base, dns_resolves: true, last_verified_up: false, last_verified_at: NOW() });
-  assert.equal(down.heading(), 'Setting up Lantern', 'a down probe is never "alive"');
-  assert.deepEqual(down.gates, [], 'nor opens the invite box');
-  assert.equal(down.lede(), down.SETTING_UP, 'nor says its home is ready');
+  const resolved = h.home({ ...base, dns_resolves: true });
+  assert.equal(resolved[0].sub, 'lantern.cloudbongos.com', 'named once it resolves');
+  assert.equal(resolved[2].state, 'now', 'resolving is not yet answering');
+  assert.equal(resolved[2].sub, 'Checking that it answers.');
+  const up = h.home({ ...base, dns_resolves: true, last_verified_up: true, last_verified_at: NOW() });
+  assert.equal(up[2].state, 'done');
+  assert.match(up[2].right, /^checked \d+s ago$/, 'when the platform last saw it answer');
+  const down = h.home({ ...base, dns_resolves: true, last_verified_up: false, last_verified_at: NOW() });
+  assert.equal(down[2].state, 'now', 'a down probe is never "answers"');
+  // "is alive" and the Enter Genesis door ask the same two gates
+  assert.match(wizFn('paintAlive'), /var on = !!\(ready && inst && hostOk\(inst\.domain\) && addressReady\(inst\) && inst\.last_verified_up === true\);/);
 });
 
 test('the card and the manage page: no link and no name before the lookup answers, in every pre-live state', () => {
@@ -165,9 +154,11 @@ test('every door to the address on the page asks addressReady', () => {
   const SCRIPT = HUB;
   assert.match(SCRIPT, /inst\.status === 'active' && addressReady\(inst\)\) acts\.push\('<a class="btn small ghost" href="https:\/\/' \+ esc\(inst\.domain\) \+ '" target="_blank" rel="noopener">View<\/a>'\)/, 'the row\'s View');
   assert.match(SCRIPT, /inst\.status === 'active' && addressReady\(inst\)\) acts\.push\('<a class="btn small ghost" href="https:\/\/' \+ esc\(inst\.domain\) \+ '" target="_blank" rel="noopener">Open site →<\/a>'\)/, 'the manage page\'s Open site');
-  // task 1004649: "Builders can sign in" opens its door only on a resolving address
-  assert.match(SCRIPT, /var open = live\.instStatus === 'active' && live\.addrReady;\n\s*return '<li class="sdone" data-onboard-step="first-sign-in">/, 'the sign-in step\'s door waits for the address');
-  assert.match(SCRIPT, /live\.addrReady = addressReady\(inst\); renderSteps\(\);/, 'and unlock on the tick the lookup answers');
+  // part 03 (task 1004683): "Builders can sign in" names the address only once it resolves,
+  // and the Enter Genesis door opens only on a resolved, answering address
+  assert.match(SCRIPT, /signIn\.sub = dom && live\.addrReady \? 'Tested on ' \+ dom : '';/, 'the sign-in fact waits for the address');
+  assert.match(SCRIPT, /if \(inst\) \{ live\.instStatus = inst\.status; live\.addrReady = addressReady\(inst\); \}\n\s*paintFacts\(\);/, 'and the read redraws the facts on the tick the lookup answers');
+  assert.match(SCRIPT, /if \(on\) \$\('enterGenesis'\)\.setAttribute\('href', 'https:\/\/' \+ inst\.domain\);/, 'the Genesis door, behind paintAlive\'s gate');
   assert.equal((SCRIPT.match(/inst\.status !== 'active' \|\| !addressReady\(inst\)\) \{ (vis|join)Runs\(''\); return; \}/g) || []).length, 2,
     'the browser\'s own manifest reads wait for the name too');
   // the only raw address hrefs left are behind one of those gates

package/tests/projects_hub_pre_uat.mjs

@@ -169,52 +169,51 @@ test('"live" is ONE rule — chip, orb and address row all read freshUp()', () =
 });
 
 /* ── the queued strip is honest about which stage is current ── */
-test('a queued standup lights "Request filed", not "Standing it up" — on the card and on the done panel', () => {
+test('a queued standup lights "Request filed", not "Standing it up" on the card; part 03 says one fact is under way', () => {
   const strip = fn('stripFor');
   assert.match(strip, /if \(s === 'requested'\) \{[\s\S]*?stripMarkup\(revive \? 'revive' : 'standup', 0, 0,/, 'card: requested → stage 0 current');
   assert.match(strip, /if \(s === 'provisioning'\) \{[\s\S]*?stripMarkup\(revive \? 'revive' : 'standup', 1, 1,/, 'card: provisioning → stage 1 current');
-  assert.match(SCRIPT, /if \(s === 'requested'\) \{\n\s*setProgress\(progressMarkup\(0, 0,/, 'done panel: requested → stage 0 current');
+  // part 03 (task 1004683) has no stages: a filed, running or queued standup is one fact, starting
+  assert.match(fn('homeFacts'), /else if \(s === 'requested' \|\| s === 'provisioning' \|\| act === 'provision'\) server = \{ state: 'now', title: 'Server and database starting'/, 'part 03: one fact under way');
   assert.doesNotMatch(SCRIPT, /Waiting for a runner/, '"runner" is operator vocabulary');
   assert.doesNotMatch(SCRIPT, /a runner picks it up/, '"runner" is operator vocabulary (retry message)');
 });
 
 /* ── the done panel never lies at the end of its watch, and never opens a door early ── */
-test('the 33-minute hand-off keeps a snag honest and keeps its flow', () => {
-  assert.match(SCRIPT, /if \(ticks > 400\) \{[\s\S]*?if \(live\.instStatus !== 'error'\) \{[\s\S]*?Still working[\s\S]*?watchFlow\)/, 'no "still building" over an error; the strip keeps its vocabulary');
-  assert.doesNotMatch(SCRIPT, /Still building — this tab will stop watching now/);
-  assert.match(SCRIPT, /progressMarkup\(1, 1, m\.slice\(5\), 'isErr', watchFlow\)/, 'the session-expiry message keeps its flow too');
+test('part 03\'s watch never gives up on a timer, and a read that is gone is said once (task 1004683)', () => {
+  assert.doesNotMatch(SCRIPT, /ticks > 400|this tab will stop watching now/, 'no 33-minute hand-off: no timer stands in for a fact');
+  assert.match(SCRIPT, /if \(m\.indexOf\('gone:'\) === 0\) \{[\s\S]{0,120}live\.gone = m\.slice\(5\);\n\s*paintFacts\(\);\n\s*stopPolling\(\);/, 'signed out or gone: the sentence says it, and the watch stops');
+  assert.match(fn('setupSentence'), /if \(live\.gone === 'missing'\) return \[\{ t: 'This project can’t be seen any more\. It may have been switched off\.' \}\];/);
 });
 
-test('"Builders can sign in" ticks on verified sign-in, and its door opens only when the project answers (task 1004649)', () => {
-  // the one-page checklist (task 1004649): the step's tick is the server's 'done';
-  // the door to the project still waits for a resolving address (task 1004505)
-  const first = fn('renderStepFirstSignIn');
-  assert.match(first, /<b>Builders can sign in<\/b>/);
-  assert.match(first, /if \(live\.manifest !== 'done'\) \{\n\s*return '<li class="slocked"/, 'locked until the platform has seen sign-in work');
-  assert.match(first, /var open = live\.instStatus === 'active' && live\.addrReady;/, 'the door gates on status and a resolving address');
-  assert.match(first, /\(open \? '<a class="ghbtn" href="https:\/\/' \+ esc\(domain\)/, 'and only then links the address');
-  // the hall is the "is alive" block's way in; the step survives only for the local hall
-  const hall = fn('renderStepEnterHall');
-  assert.match(hall, /if \(domain\) return '';/);
-  assert.match(hall, /bongos dev/);
+test('"Builders can sign in" ticks on verified sign-in, and the door into the project opens only when it answers (tasks 1004649, 1004683)', () => {
+  // the fact's tick is the server's 'done'; the address is named, and the Enter Genesis door
+  // opened, only on a resolving address (task 1004505)
+  const gh = fn('ghFacts');
+  assert.match(gh, /var signIn = \{ key: 'sign_in', title: 'Builders can sign in' \};/);
+  assert.match(gh, /if \(live\.manifest === 'done' \|\| ghStep\('sign_in'\) === 'done'\) \{ signIn\.state = 'done'; signIn\.sub = dom && live\.addrReady \? 'Tested on ' \+ dom : ''; \}/, 'done only once the platform has seen sign-in work');
+  assert.match(fn('paintAlive'), /addressReady\(inst\) && inst\.last_verified_up === true/, 'the door gates on a resolving, answering address');
+  // the hall is entered through the Enter Genesis door; no local-hall one-liner is left on part 03
+  assert.doesNotMatch(SCRIPT, /bongos dev|Enter your builders hall/);
 });
 
-test('the domainless build is standing, not "Live"', () => {
-  assert.match(SCRIPT, /progressMarkup\(-1, 2,\n\s*'The build finished — your project is standing, but it has no address yet/, 'two stages done, third unlit');
-  assert.doesNotMatch(SCRIPT, /has no address yet, so sign-in can’t be wired up[^']*', 'isLive'/, 'no green skin on a project that answers nowhere');
+test('a domainless project is standing, never "alive": GitHub waits for an address (task 1004683)', () => {
+  assert.match(fn('setupSentence'), /if \(!hostOk\(inst\.domain\)\) return \[\{ t: 'It has no address yet, so GitHub has to wait\. Attach one any time from ' \}, \{ t: 'its own page', href: manageHref\(\) \}/);
+  assert.match(fn('homeFacts'), /if \(dom && s === 'active' && act !== 'teardown'\) \{/, '"Address answers" is never reached without an address');
 });
 
-test('the fallback checklist carries every human step the canonical plan has', () => {
-  assert.match(SCRIPT, /FALLBACK_HUMAN_KEYS = \['github-repo', 'oauth-app', 'device-flow', 'app-install', 'first-sign-in', 'enter-hall'\]/);
+test('part 03\'s facts name every GitHub step the canonical plan has (task 1004683)', () => {
+  assert.match(SCRIPT, /var FACT_PLAN_STEP = \{ approve: 'oauth-app', install: 'app-install', sign_in: 'first-sign-in', device_flow: 'device-flow' \};/);
+  assert.match(HUB, /data-onboard-step="github-repo"/);
+  assert.match(HUB, /data-onboard-step="enter-hall"/);
 });
 
 /* ── the manifest leg: acknowledges GitHub, offers a way out, survives a reload ── */
 test('the manifest step acknowledges code_received, offers a restart after a stall, and rides the CREATED record', () => {
   // 'converting' is the same stage — it used to fall through to "waiting for approval" (task 1004572)
-  assert.match(SCRIPT, /if \(live\.manifest === 'code_received' \|\| live\.manifest === 'converting'\)/, 'GitHub’s half is acknowledged');
-  assert.match(SCRIPT, /Approved on GitHub\. The platform is placing the app’s keys on your project/);
+  assert.match(SCRIPT, /else if \(live\.manifest === 'code_received' \|\| live\.manifest === 'converting'\) \{ approve\.state = 'now'; approve\.sub = 'Approved\. The platform is collecting the app’s keys\.'; \}/, 'GitHub’s half is acknowledged');
   // the way back is the SAME attempt, on show from the start — never a new link after 90s (task 1004652)
-  assert.match(SCRIPT, /data-action="reopen-github">No GitHub tab\? Reopen GitHub/, 'a waiting step can reopen GitHub');
+  assert.match(SCRIPT, /approve\.state = 'you'; approve\.act = 'reopen';/, 'a waiting fact can reopen GitHub');
   assert.doesNotMatch(SCRIPT, /manifestStale|> 90000/, 'no 90-second restart door left');
   assert.match(SCRIPT, /function rememberManifest\(stateToken, status, appSlug\)/);
   assert.match(SCRIPT, /rememberManifest\(d\.state, 'pending'\)/, 'the token is remembered when GitHub is opened');
@@ -231,7 +230,7 @@ test('the wizard’s 401 recoveries keep the repo scope they already granted', (
   const plain = (SCRIPT.match(/\/auth\/web\/start\?return=\/projects%3Fview%3Dnew'\)/g) || []).length;
   assert.equal(plain, 0, 'no wizard redirect drops the scope');
   assert.ok((SCRIPT.match(/\/auth\/web\/start\?return=\/projects%3Fview%3Dnew&repos=1'\); throw new Error\('signing in'\)/g) || []).length >= 2, 'create + manifest');
-  assert.match(SCRIPT, /projects%3Fview%3Dnew&amp;repos=1">sign in again<\/a> to keep watching/, 'the progress watch');
+  assert.match(SCRIPT, /\{ t: 'Sign in again', href: API \+ '\/auth\/web\/start\?return=\/projects%3Fview%3Dnew&repos=1' \}, \{ t: ' to keep watching\.' \}/, 'the progress watch');
   // every hub sign-in door asks for repo access since task 1004549, so signInAgain does too
   assert.match(fn('signInAgain'), /\(currentView === 'new' \? '\/projects%3Fview%3Dnew' : '\/projects'\) \+ '&amp;repos=1'/, 'signInAgain from the wizard');
 });
@@ -544,21 +543,23 @@ test('an unmapped create failure gets a plain sentence with the raw text folded
 });
 
 test('a manifest error says a plain sentence, folds the route text, and sends a domainless project to its address', () => {
-  const steps = fn('renderStepOauthApp');
-  assert.doesNotMatch(steps, /'GitHub setup hit a snag' \+ \(live\.manifestMsg \? ': ' \+ esc\(live\.manifestMsg\)/, 'the raw route text is no longer the headline');
-  assert.match(steps, /else if \(live\.manifestCode === 'domain_required'\) snag = 'This project needs an address first — attach one from ' \+ projectPageLink\('its own page'\)/,
+  const steps = fn('ghFacts');
+  assert.doesNotMatch(steps, /'GitHub setup hit a snag'/, 'the raw route text is no longer the headline');
+  assert.match(steps, /else if \(live\.manifestCode === 'domain_required'\) \{ approve\.sub = 'It needs an address first\. Attach one on its own page\.'; approve\.act = 'manage';/,
     'the address lives on the project’s own page since task 1003355 — the list would be a dead end');
-  assert.match(fn('projectPageLink'), /instanceId \? '\?view=manage&id=' \+ encodeURIComponent\(instanceId\) : '\?view=mine'/,
+  assert.match(fn('manageHref'), /return instanceId \? '\?view=manage&id=' \+ encodeURIComponent\(instanceId\) : '\?view=mine';/,
     'and it is named by id whenever the flow has one');
-  // every done-panel pointer that names a CONTROL goes the same way; the ones
-  // that only say "watch it there" still name the list, which does show it
-  assert.equal((SCRIPT.match(/projectPageLink\(/g) || []).length, 8,
-    'the helper and its seven callers: the locked step, the domain_required snag, the domainless standup, the snagged retry, the torn-down revive, the extras pointer (task 1002342), and the invite pointer (task 1002346)');
+  // every part 03 pointer that names a CONTROL goes the same way (task 1004683: drawn as
+  // nodes through manageHref); the invite pointer still rides projectPageLink's markup
+  assert.equal((SCRIPT.match(/projectPageLink\(/g) || []).length, 2, 'the helper and the invite pointer (task 1002346)');
+  assert.equal((SCRIPT.match(/manageHref\(\)/g) || []).length, 6,
+    'its definition, projectPageLink, the switched-off sentence, the no-address sentence, the extras pointer, and a fact\'s manage door (a stopped standup\'s retry, the domain_required snag)');
   for (const dead of ['Retry it \\(and see the technical details\\) from <a href="\\?view=mine">',
                       'Bring it back any time from <a href="\\?view=mine">']) {
     assert.doesNotMatch(SCRIPT, new RegExp(dead), 'a control the list no longer has must not be pointed at there');
   }
-  assert.match(steps, /\(raw \? '<details><summary>Technical details<\/summary><p>' \+ esc\(raw\) \+ '<\/p><\/details>' : ''\)/);
+  assert.match(steps, /approve\.sub = 'GitHub setup didn’t start\. Nothing was changed on GitHub\.'; approve\.tech = live\.manifestMsg \|\| '';/, 'the route text folds under Technical details');
+  assert.match(fn('factNode'), /det\.appendChild\(textNode\('summary', null, 'Technical details'\)\);\n\s*det\.appendChild\(textNode\('p', null, r\.tech\)\);/, 'as text, never markup');
   assert.match(SCRIPT, /e\.code = \(d\.error && d\.error\.code\) \|\| '';/, 'the route code travels with the error');
   assert.match(SCRIPT, /live\.manifestCode = String\(\(err && err\.code\) \|\| ''\);/);
   assert.equal((SCRIPT.match(/manifestMsg: '', manifestCode: '', manifestFailure: null, appSlug: null/g) || []).length, 2, 'both resets carry the code (and, since task 1004572, the failure stage)');
@@ -613,20 +614,15 @@ test('teardown copy is state-aware: a queued project is told nothing was built',
   assert.doesNotMatch(truth, /status === 'error'|status === 'provisioning'/, 'error and provisioning keep today’s text — a failed run may already have built things');
 });
 
-test('founder voice on the Device Flow step and the manual OAuth fallback', () => {
-  const df = fn('renderStepDeviceFlow');
-  // the mockup's words (task 1004649): one title, in every branch
-  assert.match(df, /var title = '<b>Command-line sign-in is on<\/b>';/, 'the outcome-first title');
-  assert.doesNotMatch(df, /<b>Enable Device Flow — one checkbox<\/b>/);
-  assert.match(df, /the <code style="font-family:var\(--font-mono\)">bongos setup<\/code> command builders run on their own machine/, 'the command is glossed, not bare-coded');
-  // GitHub has no manifest field and no API for device flow (task 1004649's spike), so the
-  // step is OPTIONAL by design and never holds the project back
-  assert.equal((df.match(/Optional — turn it on later\./g) || []).length, 2, 'the not-yet branches say it is optional');
-  assert.equal((df.match(/class="[^"]*soptional/g) || []).length, 3, 'every branch is marked optional, so "connected" never waits on it');
-  assert.equal((df.match(/<strong>Enable Device Flow<\/strong>/g) || []).length, 2, 'GitHub’s own checkbox label stays verbatim in the instructions');
-  const manual = fn('manualOauthDetails');
-  assert.match(manual, /The platform team places the generated credentials; this step ticks itself once they land\.<\/p><\/details>/);
-  assert.doesNotMatch(manual, /auth_configured|healthz/, 'no JSON health check for a founder to perform');
+test('founder voice on command-line sign-in, and no manual OAuth chore on the page (task 1004683)', () => {
+  const gh = fn('ghFacts');
+  // the mockup's words (setup-status.html): one title, marked optional
+  assert.match(gh, /var device = \{ key: 'device_flow', title: 'Command-line sign-in', opt: true \};/, 'the outcome-first title, optional by design');
+  assert.match(gh, /device\.sub = settings \? \['Turn it on later in ', \{ t: 'the app settings', href: settings \}, '\.'\] : 'Turn it on later in the app settings\.';/, 'one plain line, linking the app\'s own settings once GitHub has made it');
+  assert.match(fn('factRequired'), /return !r\.opt;/, 'the optional fact never holds "ready" back');
+  // the manual OAuth-app details live behind the platform docs now, not on this page
+  assert.doesNotMatch(SCRIPT, /function manualOauthDetails\(|Prefer to create an OAuth app by hand/);
+  assert.doesNotMatch(gh, /auth_configured|healthz/, 'no JSON health check for a founder to perform');
 });
 
 test('repo visibility: the public line stays one line, then the door or the reason — the mechanism lives in the fold', () => {
@@ -657,15 +653,13 @@ test('a failed manage read offers a retry; the no-address sentence offers a door
 });
 
 /* ── accessibility follow-ups (task 1003246) ── */
-test('the done panel’s progress region is stable, change-only, and says each stage’s state', () => {
-  assert.match(HUB, /<div id="liveProgress" role="status" aria-live="polite"><\/div>/, 'the live region is the static wrapper');
-  assert.doesNotMatch(fn('progressMarkup'), /aria-live/, 'the rebuilt strip carries no live-region attributes');
-  assert.match(fn('progressMarkup'), /\(c === 'now' \? ' aria-current="step"' : ''\)/, 'the current stage is marked');
-  assert.match(fn('progressMarkup'), /<span class="vh">, ' \+ word \+ '<\/span>/, 'each stage says its state to a screen reader');
-  assert.match(fn('setProgress'), /if \(!el \|\| html === lastProgHtml\) return;/, 'an identical tick performs no DOM write');
-  assert.doesNotMatch(SCRIPT, /\$\('liveProgress'\)\.innerHTML =/, 'every write goes through setProgress');
-  assert.doesNotMatch(fn('renderProgress'), /el\.innerHTML =/, 'renderProgress included');
-  assert.match(SCRIPT, /lastStepsHtml = '';\n\s*lastProgHtml = '';/, 'starting another project resets both guards');
+test('part 03 speaks through one stable live region, change-only, and each fact says its state (task 1004683)', () => {
+  assert.match(HUB, /<p class="setNow" id="setupNow" role="status" aria-live="polite"><\/p>/, 'the live region is the static sentence');
+  assert.match(fn('paintFacts'), /if \(key !== sentenceSaid\) \{/, 'an identical read performs no write to it');
+  assert.match(fn('factNode'), /t\.appendChild\(textNode\('span', 'vh', ', ' \+ FACT_SAID\[r\.state\]\)\);/, 'each fact says its state to a screen reader');
+  assert.match(fn('factNode'), /d\.setAttribute\('aria-hidden', 'true'\);/, 'the dot is for the eye only');
+  assert.doesNotMatch(HUB, /id="liveProgress"|id="hopStatus"/, 'the old strip and its echo are gone');
+  assert.match(SCRIPT, /factsDrawn = \{\}; sentenceSaid = '';/, 'starting another project resets both guards');
   assert.match(COSMOS, /\.vh\{position:absolute;width:1px;height:1px;overflow:hidden;clip-path:inset\(50%\);white-space:nowrap;\}/, 'the visually-hidden utility is in cosmos');
   assert.match(fn('stripMarkup'), /role="status" aria-live="polite"/, 'the mine-card strip is left alone this pass');
 });
@@ -747,25 +741,30 @@ test('the done panel re-learns the GitHub-App leg from the instance read, yieldi
   assert.match(sp, /var ga = data\.github_app;\n\s*if \(ga && ga\.status && !manifestPollTimer\) \{/, 'seeded from the same 5s read; a running manifest poll owns live.manifest');
   assert.match(sp, /var seeded = ga\.status === 'done' \? 'done' : ga\.status;/, 'the status route’s vocabulary, verbatim');
   assert.match(sp, /if \(ga\.app_slug\) live\.appSlug = ga\.app_slug;\n\s*live\.manifest = seeded;/);
-  assert.match(sp, /if \(seedChanged\) \{ rememberManifest\(undefined, live\.manifest, live\.appSlug \|\| undefined\); renderSteps\(\); \}/, 'change-only: an identical tick neither rewrites the bridge nor re-renders');
+  assert.match(sp, /if \(seedChanged\) rememberManifest\(undefined, live\.manifest, live\.appSlug \|\| undefined\);/, 'change-only: an identical tick never rewrites the bridge');
   const seedAt = sp.indexOf('var ga = data.github_app;');
-  const statusAt = sp.indexOf("if (inst && (inst.status !== live.instStatus || addressReady(inst) !== live.addrReady))");
-  assert.ok(seedAt > 0 && seedAt < statusAt, 'the manifest seed lands before the status re-render, so one renderSteps() paints both');
+  const paintAt = sp.indexOf('live.inst = inst || null; live.readAt = Date.now();');
+  assert.ok(seedAt > 0 && seedAt < paintAt, 'the manifest seed lands before the facts are redrawn, so one paintFacts() paints both');
   /* the bridge moved from enter() to enterCreated() when task 1003503 split the
      created-record branch out — same seed, same place in the same flow */
   assert.match(fn('enterCreated'), /if \(created\.manifest\) \{ live\.manifest = created\.manifest; live\.appSlug = created\.app_slug \|\| null; \}/, 'the sessionStorage bridge stays as the pre-first-tick seed');
 });
 
 /* ── a settings push is named on both surfaces, by state, with no duration promise (task 1003140) ── */
-test('a queued or running settings push is named on the card strip AND the done panel — by state, no "briefly"', () => {
-  assert.equal((SCRIPT.match(/settings: \{ names: \['Change saved', 'Restarting to apply it', 'Applied'\], cls: '' \}/g) || []).length, 2,
-    'FLOWS (card) and PROG_FLOWS (done panel) both carry the settings flow');
+test('a queued or running settings push is named on the card strip AND part 03 — by state, no "briefly"', () => {
+  assert.equal((SCRIPT.match(/settings: \{ names: \['Change saved', 'Restarting to apply it', 'Applied'\], cls: '' \}/g) || []).length, 1,
+    'FLOWS (card) carries the settings flow; part 03 has no stage strip (task 1004683)');
   const strip = fn('stripFor');
   assert.match(strip, /a === 'settings-apply'/, 'the card strip names the intent');
   assert.match(strip, /A settings change is queued — this card updates when it starts\./, 'pending: queued, not "restarting"');
   assert.match(strip, /Applying a settings change — the project restarts to pick it up\./, 'running: the restart is said plainly');
-  const prog = fn('renderProgress');
-  assert.match(prog, /oi\.action === 'settings-apply'/, 'the done panel has the same branch — a restarting project is not read as "isn’t answering"');
-  assert.match(prog, /A settings change is queued — this panel updates when it starts\./);
-  assert.doesNotMatch(strip + prog, /briefly|shortly|soon\b|minute|second/i, 'no wall-clock or duration promise (F16)');
+  const prog = fn('homeFacts');
+  assert.match(prog, /act === 'settings-apply'/, 'part 03 has the same branch — a restarting project is not read as "isn’t answering"');
+  assert.match(prog, /oi\.state === 'running'/, 'by state');
+  assert.match(prog, /'A settings change is queued\. It restarts to apply it\.'/);
+  // the settings branch only: part 03's "Usually a few minutes." for a fresh standup is the
+  // owner's approved mockup word (setup-status.html, 2026-10-09), not a settings promise
+  const settingsBranch = prog.slice(prog.indexOf("act === 'settings-apply'"), prog.indexOf("else if (s === 'active') server ="));
+  assert.ok(settingsBranch.length > 40, 'the settings branch is found');
+  assert.doesNotMatch(strip + settingsBranch, /briefly|shortly|soon\b|minute|second/i, 'no wall-clock or duration promise (F16)');
 });

package/tests/public_landing_projects.mjs

@@ -178,19 +178,14 @@ test('the empty state points a new owner at the wizard view — never at a hall'
   assert.doesNotMatch(body, /Enter the Hall/i);
 });
 
-test('the manual-repo step states placement and visibility — the owner never has to ask', async () => {
-  // QA walk F7 (task 1002702 → 1002721, owner firsthand): the "Create the empty
-  // GitHub repo" step never said WHERE the repo lands, and the owner had to ask
-  // "is there somewhere specific I should set it up?" mid-walk. The step must
-  // say the repo belongs at the exact prefilled owner/name (changing GitHub's
-  // Owner dropdown strands the build watching the wrong address) and must state
-  // the visibility choice up front, before GitHub's own radio is the first
-  // mention.
+test('part 03 never asks the founder to make the repo by hand: the platform makes it at Create (task 1004683)', async () => {
+  // QA walk F7 (task 1002702 → 1002721) once needed the "Create the empty GitHub repo" step
+  // to say where the repo lands. Since GitHub in one trip (task 1004649) the platform makes
+  // the empty repo at Create (ensureFreshRepo), so that step and its adopt / auto-create
+  // variants are gone from part 03 (the design of record setup-status.html).
   const { body } = await request('/projects', 'game.test.local');
-  assert.match(body, /Owner box/, 'the step must name GitHub’s Owner box and say to leave it as prefilled');
-  assert.match(body, /exact address|exactly[^<]*repoLabel|land at exactly/,
-    'the step must say the build watches the exact owner/name');
-  assert.match(body, /public or private/i, 'visibility must be stated in our copy, not first seen on GitHub');
+  assert.doesNotMatch(body, /Create the empty GitHub repo|function renderStepGithubRepo\(|Owner box/, 'the pre-one-trip repo step is gone');
+  assert.match(body, /<div id="ghFresh" class="wizField" data-onboard-step="github-repo" hidden>/, 'the new repo part 02 makes at Create is the plan\'s github-repo step');
 });
 
 test('teardown copy states what the runner actually does (F17)', async () => {
@@ -213,101 +208,47 @@ test('teardown copy states what the runner actually does (F17)', async () => {
   assert.doesNotMatch(body, /database (is|will be) (deleted|dropped|destroyed|removed)/i);
 });
 
-test('the done panel reads the open intent — a queued revive is never told to start another (F22)', async () => {
+// part 03's Its home (task 1004683): three facts read off the owner's instance read
+const homeFactsOf = (body) => (body.match(/function homeFacts\(inst, now\)\s*\{([\s\S]*?)\n    \}/) || [, ''])[1];
+
+test('Its home reads the open intent — a queued revive is starting, never told to start another (F22)', async () => {
   const { body } = await request('/projects', 'game.test.local');
-  const fn = (body.match(/function renderProgress\(inst\)\s*\{([\s\S]*?)\n    \}/) || [, ''])[1];
-  assert.ok(fn, 'renderProgress() must be extractable');
-  assert.match(fn, /open_intent/, 'the strip is chosen from the open intent, not status alone');
-  assert.match(fn, /revive/, 'a queued revive on a torn-down instance gets the revive vocabulary');
+  const fn = homeFactsOf(body);
+  assert.ok(fn, 'homeFacts() must be extractable');
+  assert.match(fn, /open_intent/, 'the server fact is chosen from the open intent, not status alone');
+  assert.match(fn, /act === 'provision'\) server = \{ state: 'now', title: 'Server and database starting'/, 'a queued standup or revive is starting');
   // a requested instance ALWAYS has its provision intent open — the status
   // branch must win there or it goes dead and diverges from the mine card
-  assert.match(fn, /!== 'requested'/, 'requested speaks its status, not its (always-present) intent');
+  assert.match(fn, /s !== 'requested'/, 'requested speaks its status, not its (always-present) intent');
   assert.match(body, /inst\.open_intent = data\.open_intent \|\| null/, 'the watch hands the intent through');
-  // teardown speaks its own stage names in the done panel, in its own palette
-  assert.match(fn, /'teardown'/, 'the teardown flow is used');
-  assert.match(body, /\.prog\.flowDown/, 'the .prog strip has the teardown palette (transcribed from .strip.flowDown)');
-});
-
-test('the done panel lights Live on a verified answer, never on status alone (task 1002895)', async () => {
-  const { body } = await request('/projects', 'game.test.local');
-  const fn = (body.match(/function renderProgress\(inst\)\s*\{([\s\S]*?)\n    \}/) || [, ''])[1];
-  assert.ok(fn, 'renderProgress() must be extractable');
-  assert.match(fn, /last_verified_up/, 'the strip reads the verification overlay, not status alone');
-  // the three honest rungs: verified, failed probe, and never-probed —
-  // null is deliberately distinct from false and must not read as a failure
-  assert.match(fn, /answering at/i, 'verified speaks the list view\'s language');
-  assert.match(fn, /isn’t answering right now/, 'a failed probe is spoken, never painted green');
-  assert.match(fn, /checking that/, 'the never-probed instance gets its own calm rung');
-  // gap row 8: domainless is never probed at all — it states its truth instead
-  // of promising the hall (sign-in stays locked without an address)
-  assert.match(fn, /no address yet/, 'the domainless path cannot fall into an unverified hole');
-  assert.doesNotMatch(fn, /Your project is up/, 'the status-alone headline is dead');
-});
-
-/* ── The done panel's GitHub step (task 1002855) ─────────────────────────────
-   'We created <repo> on GitHub for you' named a repo and handed the owner nothing
-   to click, while the manual-create branch right below it rendered a full button:
-   the one path where the PLATFORM did the work was the one that stranded them
-   (owner-reported during the task 1002697 walk). Adopt named a repo unlinked too. ── */
-
-test('the auto-created repo is linked in the done panel, not merely named', async () => {
-  const { body } = await request('/projects', 'game.test.local');
-  const fn = (body.match(/function renderStepGithubRepo\(\)\s*\{([\s\S]*?)\n    \}/) || [, ''])[1];
-  assert.ok(fn, 'renderStepGithubRepo() must be extractable');
-  const auto = (fn.match(/if \(state\.repoAutoCreated\) \{([\s\S]*?)\n      \}/) || [, ''])[1];
-  assert.ok(auto, 'the auto-created branch must be extractable');
-  assert.match(auto, /We created/, 'this is the copy the owner reported');
-  // BOTH copies — scaffold landed and not yet landed — carry the link
-  assert.equal((auto.match(/repoLink/g) || []).length, 2,
-    'the landed and pre-landed copies must both link the repo');
-  assert.doesNotMatch(auto, /repoLabel/,
-    'no auto-created copy may still name the repo without linking it');
-});
-
-test('the adopt branch links the repo it names', async () => {
-  const { body } = await request('/projects', 'game.test.local');
-  const fn = (body.match(/function renderStepGithubRepo\(\)\s*\{([\s\S]*?)\n    \}/) || [, ''])[1];
-  const adopt = (fn.match(/if \(state\.mode === 'adopt'\) \{([\s\S]*?)\n      \}/) || [, ''])[1];
-  assert.ok(adopt, 'the adopt branch must be extractable');
-  assert.equal((adopt.match(/repoLink/g) || []).length, 2,
-    'both adopt copies must link the repo the owner picked');
-  assert.doesNotMatch(adopt, /repoLabel/, 'adopt may not name a repo unlinked either');
+  // a teardown is a calm fact, never painted as a failure
+  assert.match(fn, /act === 'teardown' \|\| s === 'tearing_down'\) server = \{ state: 'todo', title: 'Server and database switching off'/);
+  assert.doesNotMatch(body, /or start another below/, 'never told to start another');
 });
 
-test('the auto-created link is a plain inline link, never the .ghbtn call to action', async () => {
+test('"Address answers" ticks on a verified answer, never on status alone (task 1002895)', async () => {
   const { body } = await request('/projects', 'game.test.local');
-  const fn = (body.match(/function renderStepGithubRepo\(\)\s*\{([\s\S]*?)\n    \}/) || [, ''])[1];
-  const decl = (fn.match(/var repoLink = [^\n]*/) || [''])[0];
-  assert.match(decl, /<a href="/, 'the link is built as an anchor');
-  assert.match(decl, /esc\(repoUrl\)/, 'the href goes through the page escaper');
-  assert.match(decl, /rel="noopener"/, 'a target=_blank link carries rel=noopener');
-  assert.doesNotMatch(decl, /ghbtn/, 'there is nothing to DO here — no button treatment');
-  // the manual-create branch keeps its real .ghbtn action, and an anchor nested
-  // inside that anchor would be malformed — so only the two done branches link
-  assert.match(fn, /class="ghbtn"/, 'the manual-create button survives untouched');
-  // and the plain link needs a style, or it falls back to the browser's blue
-  assert.match(body, /\.humanSteps p a\{/, 'the inline link is styled with the page palette');
-});
-
-test('a draft with no stored repo URL renders no link — never a guessed one', async () => {
+  const fn = homeFactsOf(body);
+  assert.match(fn, /else if \(inst\.last_verified_up === true\) \{ answers\.state = 'done';/, 'only a verified answer ticks it');
+  // the three honest rungs: verified, failed probe, and never-probed — null is
+  // deliberately distinct from false and must not read as a failure
+  assert.match(fn, /else if \(inst\.last_verified_up === false\) \{ answers\.state = 'now'; answers\.sub = 'Not answering yet\. We keep checking\.';/, 'a failed probe is spoken, never painted green');
+  assert.match(fn, /answers\.sub = 'Checking that it answers\.';/, 'the never-probed instance gets its own calm rung');
+  // gap row 8: domainless is never probed at all — the fact stays not reached
+  assert.match(fn, /if \(dom && s === 'active' && act !== 'teardown'\) \{/, 'no address: the fact is never under way');
+  assert.doesNotMatch(body, /Your project is up/, 'the status-alone headline is dead');
+});
+
+test('the repo is named as text from the server read, never a guessed link (tasks 1002855, 1004683)', async () => {
+  // Part 03 names the repo its app installs on in the Install fact: the owner read's
+  // github_setup.repo (github-setup.js targetRepo, strict), re-checked by seedSetup, or the
+  // page's own owner/repo. Never a link the page built: nothing on it is the founder's to do.
   const { body } = await request('/projects', 'game.test.local');
-  const src = (body.match(/(function repoLinkFor\(\)\s*\{[\s\S]*?\n    \})/) || [, ''])[1];
-  assert.ok(src, 'repoLinkFor() must be extractable');
-  const urlFor = (state) => new Function('state', `${src}\nreturn repoLinkFor();`)(state);
-
-  // the real auto-created path: GitHub's own html_url, kept on the draft
-  assert.equal(
-    urlFor({ mode: 'greenfield', owner: 'someone', repo: 'thing', repoAutoCreated: true, repoUrl: 'https://github.com/someone/thing' }),
-    'https://github.com/someone/thing');
-  // a draft written before task 1002855 has no stored URL — it degrades to none
-  assert.equal(
-    urlFor({ mode: 'greenfield', owner: 'someone', repo: 'thing', repoAutoCreated: true }), '');
-  // adopt has no server-supplied URL: the repo the owner picked IS the address
-  assert.equal(urlFor({ mode: 'adopt', owner: 'someone', repo: 'thing' }), 'https://github.com/someone/thing');
-  // nothing named yet, and anything that isn't a github.com URL, link to nothing
-  assert.equal(urlFor({ mode: 'adopt', owner: '', repo: '' }), '');
-  assert.equal(urlFor({ mode: 'greenfield', owner: 'a', repo: 'b', repoUrl: 'javascript:alert(1)' }), '');
-  assert.equal(urlFor({ mode: 'greenfield', owner: 'a', repo: 'b', repoUrl: 'https://evil.example/x' }), '');
+  const fn = (body.match(/function repoName\(\)\s*\{([\s\S]*?)\n    \}/) || [, ''])[1];
+  assert.ok(fn, 'repoName() must be extractable');
+  assert.match(fn, /if \(live\.repo\) return live\.repo;/);
+  assert.match(body, /var repo = typeof more\.repo === 'string' && \/\^\[A-Za-z0-9\]\[A-Za-z0-9-\]\{0,38\}\\\/\[A-Za-z0-9\._-\]\{1,100\}\$\/\.test\(more\.repo\)/, 'the server\'s repo is re-checked before it is shown');
+  assert.doesNotMatch(body, /function repoLinkFor\(|class="ghbtn"/, 'no guessed repo link, no GitHub pill');
 });
 
 test('the create-repo response keeps the html_url it already returned', async () => {
@@ -448,10 +389,12 @@ test('the address row surfaces the manual-DNS note the runner recorded (F16)', a
   assert.match(body, /inst\.dns_note/, 'the card reads the dns_note the runner writes');
 });
 
-test('the watch give-up hands the owner their projects view — "the hall has it" is dead', async () => {
-  // the wizard (and its 33-minute watch cap) lives on /projects now
+test('the watch never gives up on a timer, and "the hall has it" is dead', async () => {
+  // the wizard lives on /projects; since task 1004683 its watch has no 33-minute cap — it
+  // stops when the facts say nothing more will change (setupSettled), never on a tick count
   const { body } = await request('/projects', 'game.test.local');
-  assert.match(body, /your projects page/, 'the give-up path must hand the owner the projects view');
+  assert.doesNotMatch(body, /this tab will stop watching now|ticks > 400/, 'no timer stands in for a fact');
+  assert.match(body, /var terminal = setupSettled\(\);/, 'the facts decide when the watch stops');
   assert.doesNotMatch(body, /the hall has it/, 'the false poll-stop copy must be gone');
 });