@bongos/core 1.21.45 → 1.21.47

package/tests/hall_street_desk.mjs

@@ -327,6 +327,7 @@ test('the page: the desk acts in place — the row clears, the floor lights with
   assert.deepEqual(p.sent, [{ method: 'PATCH', url: '/api/bongos/access-requests/11', body: { status: 'invited' } }], 'the card\'s own route, nothing else');
   assert.match(p.byId.get('streetToast').textContent, /Ana Ruiz is invited in/);
   assert.equal(p.byId.get('streetToast').hidden, false);
+  assert.match(p.byId.get('streetToast').className, /street-toast--desk/, "the desk's own toast, as on the board (task 1004562)");
   assert.equal(p.byId.get('streetTodayN').textContent, '1 decided');
   assert.equal(p.byId.get('streetTodayPips').children.filter((x) => x.className.includes('--on')).length, 1, 'one pip per decision');
   assert.equal(JSON.parse(p.store.get('gov-desk-today')).n, 1, 'the day keeps its count');
@@ -624,6 +625,12 @@ test('Release: the core update is checked first; take is offered only after a pa
   assert.equal(C.request(passed.card, 'take', {}), null, 'no version chip, no move');
   assert.deepEqual(coreRoute.coreDeskRows({ ...PREVIEW, open_intent: { state: 'running' } }), [], 'a run in progress offers nothing');
   assert.deepEqual(coreRoute.coreDeskRows({ ...PREVIEW, behind: false }), []);
+  // the stand-in keeps what it stands for: the core update needs you, so the
+  // desk says so in orange, as the floor's sign and the street's count do (task 1004562)
+  const desk = D.deskModel({ key: 'release', floor: 3, docket: moreDesks({ preflight: null }), goals: GOALS, now: NOW, viewerId: '95' });
+  assert.equal(desk.hot, true);
+  assert.match(desk.status, /^1 update/);
+  assert.deepEqual(D.breaks(desk), []);
 });
 
 test('Rules: the rot timer as day chips, work categories as a link, modules on in one tap and off with a yes', () => {
@@ -747,10 +754,11 @@ test('Ideas to ratify: a promise ratifies in one tap; a carried Full Idea become
   const dk = planningDocket();
   const rows = D.rowsFor('planning', 1, dk, { now: NOW, goals: GOALS });
   const promise = rows.find((r) => r.name === 'Calm mode promise');
-  assert.deepEqual(promise.actions.map((a) => a.label), ['ratify', 'open']);
+  assert.deepEqual(promise.actions.map((a) => a.label), ['ratify'], 'a row that acts here keeps its detail in place: no link out (task 1004562)');
+  assert.ok(promise.facts.length >= 1, 'its detail opens in place');
   assert.deepEqual(j(C.request(promise.card, 'ratify')), { method: 'POST', url: '/api/bongos/inbox/5/ratify', body: { notes_md: 'Ratified on the floor desk.' } });
   const full = rows.find((r) => r.name === 'Objection goes back');
-  assert.deepEqual(full.actions.map((a) => a.label), ['make goal', 'open']);
+  assert.deepEqual(full.actions.map((a) => a.label), ['make goal'], 'no link out beside an act');
   assert.deepEqual(full.choices.ratify_goal.options.map((o) => o.label), ['V2', 'V3'], 'the target version is a chip');
   assert.deepEqual(j(C.request(full.card, 'ratify_goal', full.choices.ratify_goal.options[1].input)), { method: 'POST', url: '/api/bongos/inbox/6/ratify-goal', body: { target_version: 'V3', notes_md: 'Ratified on the floor desk.' } });
   assert.ok(!rows.some((r) => r.name === 'Still sitting'), 'a Full Idea the board has not carried is not ratified from here');
@@ -832,3 +840,57 @@ test('the page: one tap on its option decides a blocker, its options standing op
   assert.deepEqual(p.sent, [{ method: 'POST', url: '/api/bongos/blockers/12/resolve', body: { resolution_note: 'Decided on the floor desk: Paddle.' } }]);
   assert.match(p.byId.get('streetToast').textContent, /Decided/);
 });
+
+// ── the live walkthrough's differences (task 1004562) ─────────────────────────
+function floorRow(key, count, line) {
+  return { key, building: key.split('.')[0], status: 'live', count, line, lines: [], hot: false, reason: null };
+}
+test('walkthrough: a quiet floor\'s tile says what its number counts, in two words that read as a label', () => {
+  const dk = docket([], { history: [], floors: [
+    floorRow('people.testers', '3', 'Lu, Bo and Ines'),
+    floorRow('people.council', '5', '5 seats · no term yet'),
+    floorRow('people.newcomers', '2', '2 newcomer tasks being built'),
+    floorRow('release.live_month', '1', '1 piece of work went live'),
+    floorRow('review.signed_off', '2', '2 signed off this month'),
+  ] });
+  const tile = (key, floor) => D.deskModel({ key, floor, docket: dk, now: NOW }).tiles.map((t) => t.v + ' ' + t.l);
+  assert.deepEqual(tile('people', 1), ['3 testers'], 'a line that is not a count names nothing: the floor does');
+  assert.deepEqual(tile('people', 0), ['5 seats'], 'the line\'s own noun when it follows the same number');
+  assert.deepEqual(tile('people', 3), ['2 newcomers'], 'a long line: the floor\'s name');
+  assert.deepEqual(tile('release', 4), ['1 went live'], 'a long line under a long name: its last two words');
+  assert.deepEqual(tile('review', 2), ['2 signed off']);
+});
+test('walkthrough: a cleared floor shows no count of the work just done, and says its own clear line', () => {
+  const m = matter({ id: 'removal_proposals:61', source: 'removal_proposals', building: 'disputes', state: 'needs', title: 'Old search page', ref: { id: 61 } });
+  const dk = docket([m], { history: [], floors: [floorRow('disputes.removals', '2', '1 needs you')] });
+  const desk = D.deskModel({ key: 'disputes', floor: 1, docket: dk, now: NOW, done: { 'removal_proposals:61': true }, cleared: true, today: 2 });
+  assert.equal(desk.cleared, true);
+  assert.deepEqual(desk.tiles, [], 'no "2 needs you" tile on a floor you just cleared');
+  assert.deepEqual([desk.status, desk.clearLine, desk.clearSub], ['floor clear', 'No removals asked', 'lit up · 2 decided today']);
+  assert.deepEqual(D.breaks(desk), []);
+  // with a tool left on the floor (the invite), the status does not repeat the stale count
+  const join = matter({ id: 'access_requests:7', source: 'access_requests', building: 'people', state: 'needs', proposer: { name: 'Builder 4' }, ref: { id: 7 } });
+  const invite = { key: 'people.invite', status: 'live', rows: [{ id: 'people.invite:new', desk: 'people.invite', building: 'people', name: 'Invite someone', fact: 'by their GitHub name', facts: [], needs: false, tool: true, ref: { type: 'invite', id: 'new' }, acts: [{ key: 'invite', field: 'login' }] }] };
+  const left = D.deskModel({ key: 'people', floor: 4, docket: docket([join], { history: [], desks: [invite], floors: [floorRow('people.join', '1', '1 needs you')] }), now: NOW, done: { 'access_requests:7': true } });
+  assert.deepEqual(left.rows.map((r) => r.name), ['Invite someone']);
+  assert.equal(left.status, 'nothing needs you');
+  assert.equal(left.hot, false);
+});
+test('walkthrough: a count agrees with its noun, in the status and on the tile', () => {
+  const votes = [1, 2].map((n) => matter({ id: 'board:' + n, source: 'board', building: 'charter', state: 'needs', title: 'Vote ' + n }));
+  const two = D.deskModel({ key: 'charter', floor: 0, docket: docket(votes, { history: [] }), now: NOW });
+  assert.match(two.status, /^2 open votes · oldest/);
+  assert.deepEqual(two.tiles.map((t) => t.v + ' ' + t.l), ['2 open votes']);
+  const one = D.deskModel({ key: 'charter', floor: 0, docket: docket(votes.slice(0, 1), { history: [] }), now: NOW });
+  assert.match(one.status, /^1 open vote · oldest/);
+});
+test('walkthrough: a record item keeps its age, and what you did keeps its "now"', () => {
+  const hist = [
+    { id: 'a', building: 'release', title: 'The new sign-up', outcome: 'live', at: '2026-10-01T12:00:00.000Z' },
+    { id: 'b', building: 'release', title: 'Mira holds the Treasurer seat', outcome: 'granted', at: '2026-09-12T12:00:00.000Z' },
+    { id: 'c', building: 'release', title: 'Today it went out', outcome: '', at: '2026-10-03T09:00:00.000Z' },
+  ];
+  const desk = D.deskModel({ key: 'release', floor: 2, docket: docket([], { history: hist }), now: NOW, mine: ['voted yes A returned idea carries it back'] });
+  assert.deepEqual(desk.record.map((x) => x.text), ['voted yes A returned id… · now', 'The new sign-up · live · 2d', 'Mira holds the Treasurer… · 3w', 'Today it went out · today']);
+  assert.ok(desk.record.every((x) => x.text.length <= D.LIMITS.recordLen));
+});

package/tests/projects_hub_pre_uat.mjs

@@ -206,7 +206,8 @@ test('the fallback checklist carries every human step the canonical plan has', (
 
 /* ── 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', () => {
-  assert.match(SCRIPT, /if \(live\.manifest === 'code_received'\)/, 'GitHub’s half is acknowledged');
+  // '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, /GitHub’s part is done/);
   assert.match(SCRIPT, /manifestStale \? '<button type="button" class="linklike" data-action="manifest-start">/, 'a stalled wait gets a restart door');
   assert.match(SCRIPT, /\(Date\.now\(\) - manifestStartedAt\) > 90000/, 'after ~90 seconds');
@@ -558,7 +559,7 @@ test('a manifest error says a plain sentence, folds the route text, and sends a
   assert.match(steps, /\(raw \? '<details><summary>Technical details<\/summary><p>' \+ esc\(raw\) \+ '<\/p><\/details>' : ''\)/);
   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: '', appSlug: null/g) || []).length, 2, 'both resets carry the 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)');
 });
 
 test('the progress rail is gone (task 1004504): no painter, no repaint at the done panel, no static rail', () => {

package/tests/provision.mjs

@@ -1723,6 +1723,59 @@ await ta('a SPENT code is never re-converted — terminal error, no code_receive
   assert.ok(!resolves.some((x) => x.status === 'code_received'), 'never reset for a doomed retry');
 });
 
+// Task 1004572: once the credentials are placed, an App EXISTS on the owner's GitHub
+// account whether or not the project then confirms sign-in. The failed row must keep
+// its id + slug, or the wizard can only say "GitHub setup didn't start" — false, and
+// it sends the founder to make a second App (live on mercury, 2026-10-04).
+await ta('a sign-in check that never confirms still records WHICH App GitHub made (task 1004572)', async () => {
+  const inst = { ...coTenant, domain: 'mercury.example.com' };
+  const deps = {
+    apply: true, privileged: false, log: () => {}, sleep: async () => {},
+    convertManifestCode: async () => ({ clientId: 'Iv1.abcdef0123456789', clientSecret: 'z'.repeat(40), appId: 5189633, appSlug: 'mercury-cloudbongos-com' }),
+    exec: () => ({ ok: true, stdout: '{"ok":true,"auth_configured":false}' }),
+    writeFile: () => ({ ok: true }),
+  };
+  const r = await P.placeManifestCreds(inst, { github_code: 'C', attempts: 1 }, deps);
+  assert.equal(r.ok, false);
+  assert.equal(r.appId, 5189633, 'the App id rides the failure');
+  assert.equal(r.appSlug, 'mercury-cloudbongos-com', 'the App slug rides the failure');
+
+  const resolves = [];
+  let claims = 0;
+  await P.drainOAuthManifests({
+    ...deps, db: {},
+    provisioning: {
+      claimNextOAuthManifest: async () => (claims++ === 0 ? { id: 18, instance_id: 53, github_code: 'C', attempts: 1 } : null),
+      getInstanceById: async () => inst,
+      resolveOAuthManifest: async (_db, _id, status, patch = {}) => { resolves.push({ status, patch }); },
+      recordEvent: async () => {},
+    },
+  });
+  assert.equal(resolves.length, 1);
+  assert.equal(resolves[0].status, 'error');
+  assert.equal(resolves[0].patch.app_slug, 'mercury-cloudbongos-com', 'the error row names the App');
+  assert.equal(resolves[0].patch.app_id, 5189633);
+  assert.equal(resolves[0].patch.github_code, null, 'the burned code is still scrubbed');
+});
+
+await ta('a failure BEFORE GitHub handed over credentials claims no App (task 1004572)', async () => {
+  const resolves = [];
+  let claims = 0;
+  await P.drainOAuthManifests({
+    apply: true, privileged: false, log: () => {}, sleep: async () => {}, db: {},
+    exec: () => ({ ok: true, stdout: '' }), writeFile: () => ({ ok: true }),
+    convertManifestCode: async () => { throw new Error('GitHub manifest conversion failed: code expired'); },
+    provisioning: {
+      claimNextOAuthManifest: async () => (claims++ === 0 ? { id: 19, instance_id: 53, github_code: 'C', attempts: 1 } : null),
+      getInstanceById: async () => ({ ...coTenant, domain: 'mercury.example.com' }),
+      resolveOAuthManifest: async (_db, _id, status, patch = {}) => { resolves.push({ status, patch }); },
+      recordEvent: async () => {},
+    },
+  });
+  assert.ok(resolves.length >= 1);
+  assert.ok(resolves.every((x) => !('app_slug' in x.patch)), 'no App is named when none was handed over');
+});
+
 await ta('a PRE-conversion failure stays retryable — the narrowing spared the retry path (F23)', async () => {
   let claims = 0; const resolves = [];
   const deps = {

package/tests/provisioning_github_app_routes.mjs

@@ -158,6 +158,29 @@ console.log('\nGET /provisioning/github-app/status (the page poll → auto-open
   t("status 'done' → ready:true + terminal:true", res.status === 200 && j.ready === true && j.terminal === true, JSON.stringify(j));
   provisioning.getOAuthManifestByState = prev;
 }
+{
+  // Task 1004572: a setup link nobody finished lapses after 30 minutes, and the
+  // callback refuses it from then on — so the poll must say 'expired' (terminal)
+  // rather than 'pending' forever, or the page waits on a link that can never land.
+  const prev = provisioning.getOAuthManifestByState;
+  provisioning.getOAuthManifestByState = async () => ({ id: 17, instance_id: 42, status: 'pending', attempts: 0, expires_at: new Date(Date.now() - 1000).toISOString() });
+  const res = await fetch(`${base}/provisioning/github-app/status?state=GOODSTATE`);
+  const j = await res.json();
+  t('a LAPSED pending link reads expired + terminal (task 1004572)', res.status === 200 && j.status === 'expired' && j.terminal === true && j.ready === false && j.failure === null, JSON.stringify(j));
+  provisioning.getOAuthManifestByState = prev;
+}
+{
+  // A failure after GitHub handed over credentials: the poll names how far it got,
+  // and never the raw last_error (this route is public by state token).
+  const prev = provisioning.getOAuthManifestByState;
+  provisioning.getOAuthManifestByState = async () => ({ id: 18, instance_id: 42, status: 'error', attempts: 1, app_slug: 'mercury-signin', last_error: 'the credentials are placed, but the project did not report sign-in ready in time', expires_at: new Date(Date.now() - 1000).toISOString() });
+  const res = await fetch(`${base}/provisioning/github-app/status?state=GOODSTATE`);
+  const raw = await res.text();
+  const j = JSON.parse(raw);
+  t("a post-approval failure says failure:'sign_in_unconfirmed' (task 1004572)", j.status === 'error' && j.failure === 'sign_in_unconfirmed' && j.terminal === true, raw);
+  t('…and never leaks last_error', !/did not report/.test(raw) && !('last_error' in j), raw);
+  provisioning.getOAuthManifestByState = prev;
+}
 {
   const res = await fetch(`${base}/provisioning/github-app/status?state=NOPE`);
   t('unknown state → 404 (no oracle)', res.status === 404, `status=${res.status}`);

package/tests/provisioning_settings.mjs

@@ -115,10 +115,12 @@ await ta('owner reads their own instance', async () => {
 
 await ta('the read carries the GitHub-App leg\'s truth — github_app {status, app_slug} from the latest manifest attempt (task 1003235)', async () => {
   reset();
-  manifest = { id: 3, instance_id: 18, status: 'done', app_slug: 'spike-bongos', github_code: 'never-surfaced', state: 'never-surfaced' };
+  manifest = { id: 3, instance_id: 18, status: 'done', app_slug: 'spike-bongos', github_code: 'never-surfaced', state: 'never-surfaced', last_error: 'never-surfaced', created_at: '2026-10-04T20:20:56.930Z' };
   const r = await get('/provisioning/instances/18');
   assert.equal(r.status, 200, r.raw);
-  assert.deepEqual(r.body.github_app, { status: 'done', app_slug: 'spike-bongos' }, 'an allow-list projection — the code and the state token never ride the read');
+  // task 1004572 added failure + started_at to the allow-list; nothing else rides
+  assert.deepEqual(r.body.github_app, { status: 'done', app_slug: 'spike-bongos', failure: null, started_at: '2026-10-04T20:20:56.930Z' }, 'an allow-list projection — the code, the state token and last_error never ride the read');
+  assert.doesNotMatch(r.raw, /never-surfaced/);
   assert.equal(r.body.instance.slug, 'spike', 'the instance projection is untouched');
 });
 
@@ -134,8 +136,8 @@ await ta('no manifest attempt yet → github_app is null, not absent (a reload c
 await ta('publicGithubApp is a pure allow-list projection with the status route\'s vocabulary', async () => {
   assert.equal(provisioning.publicGithubApp(null), null);
   assert.equal(provisioning.publicGithubApp({ app_slug: 'x' }), null, 'a row with no status is no truth');
-  assert.deepEqual(provisioning.publicGithubApp({ status: 'pending', github_code: 'secret' }), { status: 'pending', app_slug: null });
-  assert.deepEqual(provisioning.publicGithubApp({ status: 'code_received', app_slug: 'mercury-bongos' }), { status: 'code_received', app_slug: 'mercury-bongos' });
+  assert.deepEqual(provisioning.publicGithubApp({ status: 'pending', github_code: 'secret' }), { status: 'pending', app_slug: null, failure: null, started_at: null });
+  assert.deepEqual(provisioning.publicGithubApp({ status: 'code_received', app_slug: 'mercury-bongos' }), { status: 'code_received', app_slug: 'mercury-bongos', failure: null, started_at: null });
 });
 
 await ta('ANOTHER builder\'s GET → 404 (no existence leak)', async () => {

package/tests/wizard_github_feedback.mjs

@@ -0,0 +1,239 @@
+// tests/wizard_github_feedback.mjs — the setup checklist tells the founder the truth
+// at every GitHub sign-in stage (task 1004572).
+//
+// WHY. Live on 2026-10-04, a founder setting up mercury was told, in turn:
+//   • "Waiting for your approval on GitHub…" while the platform was already placing
+//     the credentials ('converting' fell through to the pending branch);
+//   • "GitHub setup didn't start. Nothing was changed on GitHub" after GitHub HAD made
+//     an app on their account — so they made another, and another;
+//   • and, once a setup link lapsed, nothing at all: no button, forever, because a
+//     lapsed 'pending' row was never read as expired and the "start again" offer was
+//     timed from a click that a reload forgets;
+//   • and on the project itself, a bare "auth not configured".
+//
+// Four layers, all DB-free and network-free:
+//   1. manifest-truth.js — the effective status and how far a failure got (PURE).
+//   2. renderStepOauthApp, EXECUTED by the vm-slice idiom: the words for each stage.
+//   3. the reload path, EXECUTED: the seed from the instance read and the wait timer.
+//   4. the project's own sign-in door with nothing configured: a page in words.
+//
+// Run:  node --test tests/wizard_github_feedback.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 { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.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 truth = require(path.join(ROOT, 'modules', 'provisioning', 'manifest-truth.js'));
+
+// ── 1. manifest-truth.js ────────────────────────────────────────────────────
+
+const NOW = Date.parse('2026-10-04T20:30:00Z');
+const LATER = '2026-10-04T20:45:00Z';
+const EARLIER = '2026-10-04T20:15:00Z';
+
+test('a pending link past its expiry reads EXPIRED; one still live stays pending', () => {
+  assert.equal(truth.effectiveManifestStatus({ status: 'pending', expires_at: EARLIER }, NOW), 'expired');
+  assert.equal(truth.effectiveManifestStatus({ status: 'pending', expires_at: LATER }, NOW), 'pending');
+  // only 'pending' decays — a finished or failed attempt keeps its word
+  for (const s of ['code_received', 'converting', 'done', 'error']) {
+    assert.equal(truth.effectiveManifestStatus({ status: s, expires_at: EARLIER }, NOW), s, s);
+  }
+});
+
+test('how far a failure got is read from the row\'s shape, never from error text', () => {
+  assert.equal(truth.manifestFailure({ attempts: 0 }), 'not_approved');
+  assert.equal(truth.manifestFailure({ attempts: 1, app_slug: 'mercury-cloudbongos-com' }), 'sign_in_unconfirmed');
+  assert.equal(truth.manifestFailure({ attempts: 1, app_slug: null, last_error: 'did not report sign-in ready' }), 'finish_failed',
+    'an error message alone claims nothing — only a recorded App does');
+  assert.deepEqual([...truth.MANIFEST_FAILURES].sort(), ['finish_failed', 'not_approved', 'sign_in_unconfirmed']);
+});
+
+test('publicGithubApp: effective status, failure only on error, started_at, and nothing else', () => {
+  const row = { status: 'pending', expires_at: EARLIER, created_at: '2026-10-04T19:57:35.018Z', github_code: 'SECRET', state: 'SECRET', last_error: 'SECRET' };
+  const pub = truth.publicGithubApp(row, NOW);
+  assert.deepEqual(pub, { status: 'expired', app_slug: null, failure: null, started_at: '2026-10-04T19:57:35.018Z' });
+  assert.doesNotMatch(JSON.stringify(pub), /SECRET/);
+  assert.equal(truth.publicGithubApp({ status: 'error', attempts: 1, app_slug: 'a' }, NOW).failure, 'sign_in_unconfirmed');
+  assert.equal(truth.publicGithubApp(null), null);
+});
+
+// ── 2. the words for each stage ─────────────────────────────────────────────
+
+const RS = SCRIPT.indexOf('    /* oauth-app — the ADR 0133 one-click GitHub-App manifest flow');
+const RE = SCRIPT.indexOf('    /* device-flow', RS);
+const RENDER = SCRIPT.slice(RS, RE);
+
+test('the GitHub step region is still findable (a rename must fail loudly)', () => {
+  assert.ok(RS > 0 && RE > RS, 'both slice boundaries found');
+  assert.match(RENDER, /function renderStepOauthApp\(\)/);
+});
+
+function stage(live, { stale = false } = {}) {
+  const sandbox = {
+    live: { manifest: null, manifestMsg: '', manifestCode: '', manifestFailure: null, appSlug: null, instStatus: 'active', addrReady: true, ...live },
+    manifestStale: stale,
+    autoOpenArmed: false,
+    resolvedDomain: () => 'mercury.example.com',
+    apexBase: () => 'example.com',
+    esc: (x) => String(x).replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c])),
+    GH_ICON: '',
+    manualOauthDetails: () => '<details>manual</details>',
+    projectPageLink: (t) => '<a>' + t + '</a>',
+    autoOpenTick: () => '<label>auto</label>',
+    progressMarkup: (now, done, note, cls) => `<prog now=${now} done=${done} cls="${cls}">${note}</prog>`,
+  };
+  vm.createContext(sandbox);
+  vm.runInContext(`${RENDER}\nvar out = renderStepOauthApp();`, sandbox);
+  return sandbox.out;
+}
+const startButton = /data-action="manifest-start"/;
+
+test('pending: waiting for approval, and says where a missing GitHub tab went', () => {
+  const html = stage({ manifest: 'pending' });
+  assert.match(html, /Waiting for your approval on GitHub/);
+  assert.match(html, /No GitHub tab\? It may have opened behind this window or in another one/);
+  assert.doesNotMatch(html, startButton, 'no restart offer while the wait is young');
+  assert.match(stage({ manifest: 'pending' }, { stale: true }), /Start the setup again/, 'offered once the wait has gone wrong');
+});
+
+test('converting is the SAME stage as code_received — approved, placing credentials — never "waiting for approval"', () => {
+  for (const m of ['code_received', 'converting']) {
+    const html = stage({ manifest: m });
+    assert.match(html, /GitHub’s part is done/, m);
+    assert.match(html, /<prog now=1 done=1/, `${m}: the strip is past the approval stage`);
+    assert.doesNotMatch(html, /Waiting for your approval/, m);
+  }
+});
+
+test('a failure AFTER approval says an app now exists, names it, and does not push a second one', () => {
+  const html = stage({ manifest: 'error', manifestFailure: 'sign_in_unconfirmed', appSlug: 'mercury-cloudbongos-com' });
+  assert.match(html, /GitHub approved the app and the platform placed its credentials/);
+  assert.match(html, /href="https:\/\/github\.com\/settings\/apps\/mercury-cloudbongos-com"/);
+  assert.match(html, /would make a second app/);
+  assert.match(html, /href="\/contact"/);
+  assert.match(html, /cls="isErr"/, 'the strip shows where it stopped');
+  assert.doesNotMatch(html, /Nothing was changed on GitHub/, 'the old claim was false here');
+  assert.doesNotMatch(html, /class="ghbtn"/, 'no big primary "set up" button inviting a second app');
+  assert.match(html, /Try again anyway/, '…but the founder is never left with no way forward');
+});
+
+test('approved but never finished: delete the app GitHub made first, then try again', () => {
+  const html = stage({ manifest: 'error', manifestFailure: 'finish_failed' });
+  assert.match(html, /GitHub approved the app, but the platform couldn’t finish/);
+  assert.match(html, /delete it first/);
+  assert.doesNotMatch(html, /Nothing was changed on GitHub/);
+  assert.match(html, startButton);
+});
+
+test('a failure before GitHub (or a refused start) keeps the honest "nothing changed" line', () => {
+  assert.match(stage({ manifest: 'error', manifestFailure: 'not_approved' }), /Nothing was changed on GitHub/);
+  const refused = stage({ manifest: 'error', manifestMsg: 'HTTP 500' });
+  assert.match(refused, /Nothing was changed on GitHub/);
+  assert.match(refused, /Technical details/);
+  assert.match(refused, startButton);
+});
+
+test('an expired link offers a fresh one', () => {
+  const html = stage({ manifest: 'expired' });
+  assert.match(html, /That setup link expired/);
+  assert.match(html, startButton);
+});
+
+// ── 3. the reload path ──────────────────────────────────────────────────────
+
+const WS = SCRIPT.indexOf('    function manifestInFlight() {');
+const WE = SCRIPT.indexOf('    function pollManifest(stateToken) {', WS);
+const WAIT = SCRIPT.slice(WS, WE);
+const SS = SCRIPT.indexOf('            var ga = data.github_app;');
+const SE = SCRIPT.indexOf('            /* the checklist reflects live state (task 1002694)', SS);
+const SEED = SCRIPT.slice(SS, SE);
+
+test('the reload regions are still findable (a rename must fail loudly)', () => {
+  assert.ok(WS > 0 && WE > WS, 'wait-timer boundaries found');
+  assert.ok(SS > 0 && SE > SS, 'instance-read seed boundaries found');
+  assert.match(SCRIPT, /if \(!terminal \|\| manifestInFlight\(\)\) pollTimer = setTimeout\(tick, 5000\);/,
+    'a GitHub leg in flight keeps the instance read alive once the project is up — after a reload it is the only watcher');
+});
+
+// A page that RELOADED: no click in this tab, no manifest poll, just the instance read.
+function reloaded(githubApp, now) {
+  const renders = [];
+  const sandbox = {
+    data: { github_app: githubApp },
+    live: { manifest: null, manifestFailure: null, appSlug: null },
+    manifestPollTimer: null, manifestStartedAt: 0, manifestStale: false,
+    rememberManifest: () => {}, renderSteps: () => renders.push(1),
+    Date: { now: () => now, parse: Date.parse },
+  };
+  vm.createContext(sandbox);
+  vm.runInContext(`${WAIT}\n${SEED}`, sandbox);
+  return { sandbox, renders, tick: () => vm.runInContext(SEED, sandbox) };
+}
+
+test('a reloaded page times the wait from when the link was minted, and still reaches "start again"', () => {
+  const minted = '2026-10-04T20:20:00Z';
+  const young = reloaded({ status: 'pending', app_slug: null, failure: null, started_at: minted }, Date.parse(minted) + 30000);
+  assert.equal(young.sandbox.live.manifest, 'pending');
+  assert.equal(young.sandbox.manifestStartedAt, Date.parse(minted), 'seeded from the server');
+  assert.equal(young.sandbox.manifestStale, false);
+
+  const old = reloaded({ status: 'pending', app_slug: null, failure: null, started_at: minted }, Date.parse(minted) + 120000);
+  old.tick();   // the next 5s read: same status, so the wait timer decides
+  assert.equal(old.sandbox.manifestStale, true, 'the offer appears — it used to be never after a reload');
+  assert.equal(vm.runInContext('manifestInFlight()', old.sandbox), true);
+});
+
+test('a reloaded page learns HOW a failure happened, not just that it did', () => {
+  const r = reloaded({ status: 'error', app_slug: 'mercury-cloudbongos-com', failure: 'sign_in_unconfirmed', started_at: null }, NOW);
+  assert.equal(r.sandbox.live.manifest, 'error');
+  assert.equal(r.sandbox.live.manifestFailure, 'sign_in_unconfirmed');
+  assert.equal(r.sandbox.live.appSlug, 'mercury-cloudbongos-com');
+  assert.equal(vm.runInContext('manifestInFlight()', r.sandbox), false, 'a finished attempt stops the watch');
+});
+
+test('the reset literal and the initial literal still agree, failure field included', () => {
+  const lits = SCRIPT.match(/live = \{ instStatus: null[^}]*\}/g) || [];
+  assert.equal(lits.length, 2);
+  assert.equal(lits[0].replace(/^var /, ''), lits[1]);
+  assert.match(lits[0], /manifestFailure: null/);
+});
+
+// ── 4. the project's own door with nothing configured ───────────────────────
+
+test('a project with no sign-in configured answers a page in words, not a bare "auth not configured"', async () => {
+  const auth = require(path.join(ROOT, 'src', 'bongos', 'auth.js'));
+  const prev = { a: auth.authConfigured, i: auth.idpConfigured };
+  auth.authConfigured = () => false;
+  auth.idpConfigured = () => false;
+  const express = require('express');
+  const buildAuthRouter = require(path.join(ROOT, 'src', 'bongos', 'routes', 'auth.js'));
+  const app = express();
+  app.use('/api/bongos', buildAuthRouter());
+  const server = app.listen(0);
+  try {
+    await new Promise((r) => server.once('listening', r));
+    const base = `http://127.0.0.1:${server.address().port}/api/bongos`;
+    for (const p of ['/auth/web/start', '/auth/web/callback']) {
+      const res = await fetch(base + p);
+      const html = await res.text();
+      assert.equal(res.status, 503, p);
+      assert.match(res.headers.get('content-type') || '', /text\/html/, p);
+      assert.match(html, /Sign-in isn&#39;t set up on this project yet|Sign-in isn't set up on this project yet/, p);
+      assert.match(html, /Wire GitHub sign-in/, `${p}: points the owner at the step that fixes it`);
+      assert.doesNotMatch(html, /^auth not configured$/, p);
+    }
+  } finally {
+    server.close();
+    auth.authConfigured = prev.a; auth.idpConfigured = prev.i;
+  }
+});