@bongos/core 1.20.83 → 1.21.2

package/tests/genesis_home.mjs

@@ -91,6 +91,58 @@ test('a plan out of range is refused with the reason', () => {
   assert.equal(gh.parsePlan({ expected_builders: 0 }).reason, 'bad_expected_builders');
 });
 
+// ── the demo's expedited plan (task 1004506) ────────────────────────────────
+
+test('a demo\'s stages are minutes, fitted to a fifth of its time box (10 min to 2 h)', () => {
+  const sum = (m) => Object.values(m).reduce((a, b) => a + b, 0);
+  assert.deepEqual(gh.demoMinutes(4), { scope: 14, strategize: 10, charter: 10, legalize: 5, legislation: 10 },
+    '3 people × 4 hours: about 48 minutes of genesis, then building');
+  assert.deepEqual(Object.keys(gh.demoMinutes(1)), STAGES5);
+  for (const h of [1, 2, 4, 8, 20, 40]) {
+    const total = sum(gh.demoMinutes(h));
+    assert.ok(total <= h * 60 * 0.25, `${h}h: genesis (${total} min) leaves most of the time box for building`);
+    assert.ok(total >= 8 && total <= 125, `${h}h: ${total} min is inside the bounds`);
+    assert.ok(Object.values(gh.demoMinutes(h)).every((m) => Number.isInteger(m) && m >= 1));
+  }
+});
+
+test('the demo plan is the settled one: Monarchy / BDFL, one pass, no advisors, the demo\'s people', () => {
+  const r = gh.parsePlan(gh.demoPlan({ people: 3, hours_each: 4 }));
+  assert.equal(r.ok, true, JSON.stringify(r));
+  assert.equal(r.plan.government, 'monarchy');
+  assert.equal(r.plan.passes, 1);
+  assert.equal(r.plan.advisors, 'none');
+  assert.equal(r.plan.expected_builders, 3);
+  assert.equal(r.plan.existing, false);
+  assert.deepEqual(r.plan.demo, { people: 3, hours_each: 4 });
+  assert.deepEqual(r.plan.minutes, gh.demoMinutes(4));
+  assert.equal(gh.parsePlan({ demo: { people: 0, hours_each: 4 } }).reason, 'bad_demo');
+  assert.equal(gh.parsePlan({ minutes: { scope: 5 } }).reason, 'bad_minutes', 'every stage needs its minutes');
+  assert.equal(gh.parsePlan({}).plan.minutes, undefined, 'a real project\'s plan stays in days');
+});
+
+test('the plan route does not name the demo fields, so only the birth can write a demo plan', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules', 'onboarding', 'routes', 'onboarding.js'), 'utf8');
+  const schema = src.slice(src.indexOf("router.post('/founding/plan'"), src.indexOf("router.post('/founding/stages"));
+  assert.ok(schema.includes('validateOrRespond'));
+  assert.doesNotMatch(schema, /\bdemo\b|\bminutes\b/);
+});
+
+test('a demo genesis reads in minutes: each stage due minutes after it began', () => {
+  const plan = gh.parsePlan(gh.demoPlan({ people: 2, hours_each: 4 })).plan;
+  const g = gh.shapeGenesis({
+    mode: { stage: 'scope', stage_number: 1, stage_count: 5, day: 1 },
+    plan, stageAt: { scope: '2026-10-01T09:00:00.000Z' },
+  });
+  assert.deepEqual(g.demo, { people: 2, hours_each: 4 });
+  assert.equal(g.stages[0].minutes, 14);
+  assert.equal(g.stages[0].due, '2026-10-01T09:14:00.000Z');
+  const real = gh.shapeGenesis({ mode: { stage: 'scope', stage_number: 1, stage_count: 5, day: 1 }, plan: gh.parsePlan({}).plan, stageAt: { scope: '2026-10-01T09:00:00.000Z' } });
+  assert.equal(real.demo, null);
+  assert.equal(real.stages[0].minutes, null);
+  assert.equal(real.stages[0].due, '2026-10-08T09:00:00.000Z', 'a real project is unchanged: days');
+});
+
 // ── the flow, end to end over fakes ──────────────────────────────────────────
 
 function world({ withGovernment = true } = {}) {
@@ -232,7 +284,7 @@ test('every genesis write is the project owner\'s; the read is any signed-in bui
 
 const CARD = fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'genesis-home.js'), 'utf8');
 
-function bootCard({ founding }) {
+function bootCard({ founding, data = { genesis: null } }) {
   const calls = [];
   let widget = null;
   let observer = null;
@@ -240,7 +292,7 @@ function bootCard({ founding }) {
   const sandbox = {
     window: {
       OTB: { escapeHtml: (s) => String(s), contributeHallWidget: (w) => { widget = w; } },
-      BongosClient: { createClient: () => ({ request: async (m, p) => { calls.push(`${m} ${p}`); return { ok: true, status: 200, data: { genesis: null } }; } }) },
+      BongosClient: { createClient: () => ({ request: async (m, p) => { calls.push(`${m} ${p}`); return { ok: true, status: 200, data }; } }) },
     },
     document: { documentElement: { getAttribute: (k) => attrs[k] || null } },
     MutationObserver: class { constructor(fn) { observer = fn; } observe() {} disconnect() {} },
@@ -277,6 +329,23 @@ test('founding mode stamped after mount still starts the card, once', async () =
   assert.deepEqual(b.calls, ['GET /api/bongos/founding/genesis']);
 });
 
+test('a demo\'s genesis card: no decide form, the settled plan in one line, each stage in minutes (task 1004506)', async () => {
+  const genesis = gh.shapeGenesis({
+    mode: { stage: 'scope', stage_number: 1, stage_count: 5, day: 1 },
+    plan: gh.parsePlan(gh.demoPlan({ people: 3, hours_each: 4 })).plan,
+    stageAt: { scope: '2026-10-01T09:00:00.000Z' },
+  });
+  const { host } = bootCard({ founding: true, data: { genesis, viewer_id: '1' } });
+  await new Promise((r) => setImmediate(r));
+  await new Promise((r) => setImmediate(r));
+  assert.equal(host.hidden, false);
+  assert.match(host.innerHTML, /Monarchy \/ BDFL, 3 people, 4 hours each/);
+  assert.match(host.innerHTML, /about 49 minutes/);
+  assert.match(host.innerHTML, /14 min, due /, 'the stage in progress is due at a time, not a date');
+  assert.match(host.innerHTML, /Stage 1 of 5 · scope · demo/);
+  assert.doesNotMatch(host.innerHTML, /data-genesis-plan/, 'a demo never shows the decide form');
+});
+
 test('the hall carries the five life plates byte-identical to the world\'s', () => {
   const world = path.join(ROOT, 'modules', 'public-landing', 'public', 'assets', 'world');
   const hall = path.join(ROOT, 'modules', 'hall-ui', 'public', 'genesis');

package/tests/hall_builders_page_pass.mjs

@@ -174,7 +174,8 @@ test('A: the quiet fill is a defined variant, not an inline colour', () => {
 // capture the rowHtml it hands makeLedger, and call the real function.
 async function rosterRowHtml(rows) {
   let rowFn = null;
-  const elStub = { innerHTML: '', className: '', textContent: '', hidden: false };
+  // addEventListener/querySelectorAll: the role toggle wires its chips (task 1004437).
+  const elStub = { innerHTML: '', className: '', textContent: '', hidden: false, addEventListener() {}, querySelectorAll: () => [] };
   const sandbox = {
     window: {
       OTB: { fmtInt: (n) => String(n == null ? 0 : n), rankLabel: (r) => r },

package/tests/hub_map_orb_states.mjs

@@ -66,6 +66,10 @@ const PA_START = SCRIPT.indexOf('function planetAttrs(');
 const PA_END = SCRIPT.indexOf('var PLANET_SHAPE_WORDS');
 assert.ok(PA_START > 0 && PA_END > PA_START, 'planetAttrs must still be sliceable');
 const PLANET_ATTRS = SCRIPT.slice(PA_START, PA_END);
+// The row's site door (task 1004505) and the rule it asks, sliced the same way.
+const ADDRESS_READY = (SCRIPT.match(/function addressReady\(inst\) \{[^\n]*\}/) || [''])[0];
+const SITE_HREF = (SCRIPT.match(/function siteHref\(p\) \{[^\n]*\}/) || [''])[0];
+assert.ok(ADDRESS_READY && SITE_HREF, 'addressReady and siteHref must still be sliceable');
 
 // ── the DOM stub ─────────────────────────────────────────────────────────────
 // Narrow on purpose: it supports exactly what the region touches, so it stays
@@ -111,7 +115,7 @@ function boot() {
     listedDate: (iso) => String(iso),
   };
   vm.createContext(sandbox);
-  vm.runInContext(PLANET_ATTRS + '\n' + REGION, sandbox);
+  vm.runInContext(PLANET_ATTRS + '\n' + ADDRESS_READY + '\n' + SITE_HREF + '\n' + REGION, sandbox);
   return {
     sandbox,
     sky,

package/tests/leaderboard_roles.mjs

@@ -0,0 +1,272 @@
+// tests/leaderboard_roles.mjs — the leaderboard, the roster and the status page
+// tell the roles apart (task 1004437 / WA6.RP07, goal 1000095, criterion
+// wa6-roles-read-true-in-public).
+//
+// The done-when: "all three lists show roles per the mock and no browser-only
+// artist shows a misleading 0". Run for real:
+//
+//   1. THE READ. readRolesForBuilders over a page of builders: the profile's own
+//      main/shown rules (chosen, else earned, else preferred), a craft shown only
+//      once it earned, two reads for the whole page and never one per row.
+//   2. THE ROUTE. GET /public/leaderboard carries each row's roles and per-craft
+//      credits (the figure a role ranks by is in the row, ADR 0255), and a roles
+//      failure costs the roles, never the board.
+//   3. THE ROSTER. The REAL roster.js over the harness's public fixture: a Roles
+//      column, the Everyone / Engineers / Artists / Ideators toggle ranking by
+//      the credits that craft earned, and a dash, not a 0, for a builder with no
+//      AI sessions.
+//   4. THE STANDING CARD and 5. THE STATUS PAGE: the real functions, run.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import { makeRunner } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const ROOT = fileURLToPath(new URL('..', import.meta.url));
+const { test, summary } = makeRunner();
+const seams = require('../src/module-seams.js');
+const creditsByCraftLib = require('../modules/economy/credits-by-craft.js');
+const FIX = JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts/hall-preview/fixtures/public__leaderboard.json'), 'utf8'));
+const read = (f) => fs.readFileSync(path.join(ROOT, f), 'utf8').replace(/\r\n/g, '\n');
+
+// economy's own fold over hand-written grouped rows: what the ledger statement returns
+function rewardOver(grouped, calls) {
+  return {
+    craftForPreference: creditsByCraftLib.craftForPreference,
+    creditsByCraft: async (ids) => { calls.push(['credits', ids]); return creditsByCraftLib.foldCraftRows(ids, grouped); },
+  };
+}
+
+// ---- 1. the read ------------------------------------------------------------------
+
+await test('a page of builders: chosen, earned and preferred main roles, and a craft shown only once it earned', async () => {
+  const { readRolesForBuilders } = require('../src/bongos/role-stats.js');
+  const calls = [];
+  seams._reset();
+  seams.registerProvider('reward', rewardOver([
+    { builder_id: '1', discipline: 'engineer', amount: 900 },
+    { builder_id: '1', discipline: 'ideator', amount: 20 },
+    { builder_id: '2', discipline: 'artist', amount: 370 },
+    { builder_id: '2', discipline: 'ideator', amount: 42 },
+    { builder_id: '3', discipline: 'ideator', amount: 186 },
+  ], calls));
+  const choices = new Map([
+    ['2', { preferred_disciplines: ['artist', 'ideator'], main_discipline: 'artist' }],
+    ['3', { preferred_disciplines: ['ideator', 'artist'], main_discipline: null }],
+    ['4', { preferred_disciplines: ['ui'], main_discipline: null }],
+  ]);
+  const out = await readRolesForBuilders(['1', '2', 3, '4', 'x', '2'], { getRoleChoices: async (ids) => { calls.push(['choices', ids]); return choices; } });
+  assert.deepEqual([...out.keys()], ['1', '2', '3', '4'], 'every valid id once, a bad one dropped');
+  const r = (id) => JSON.parse(JSON.stringify(out.get(id)));
+  assert.deepEqual([r('1').main, r('1').main_basis, r('1').shown], ['engineer', 'earned', ['engineer', 'ideator']]);
+  assert.deepEqual([r('2').main, r('2').main_basis, r('2').shown], ['artist', 'chosen', ['artist', 'ideator']]);
+  assert.deepEqual(r('3').shown, ['ideator'], 'a preferred craft that earned nothing does not show');
+  assert.deepEqual([r('4').main, r('4').main_basis, r('4').shown], ['artist', 'preferred', ['artist']], 'ui is the artist\'s craft, as on the profile');
+  assert.equal(r('2').credits_by_craft.artist, 370);
+  assert.equal(r('2').credits_by_craft.total, 412);
+  assert.deepEqual(calls.map((c) => c[0]).sort(), ['choices', 'credits'], 'two reads for the whole page, never one per row');
+  seams._reset();
+});
+
+// ---- 2. the route -----------------------------------------------------------------
+
+async function bootPublic({ rolesThrow = false } = {}) {
+  const db = require('../src/bongos/db.js');
+  const realChoices = db.getBuilderRoleChoices;
+  db.getBuilderRoleChoices = async () => {
+    if (rolesThrow) throw new Error('db down');
+    return new Map([['2001', { preferred_disciplines: ['artist'], main_discipline: 'artist' }]]);
+  };
+  seams._reset();
+  seams.registerProvider('reward', {
+    craftForPreference: creditsByCraftLib.craftForPreference,
+    getLeaderboardWithAchievements: async () => [
+      { id: '1', github_login: 'eng', total_credits: 900, tokens_used: '5000' },
+      { id: '2001', github_login: 'art', total_credits: 370, tokens_used: '0' },
+    ],
+    creditsByCraft: async (ids) => creditsByCraftLib.foldCraftRows(ids, [
+      { builder_id: '1', discipline: 'engineer', amount: 900 },
+      { builder_id: '2001', discipline: 'artist', amount: 370 },
+    ]),
+  });
+  const express = require('express');
+  const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
+  const app = express();
+  app.use(attachFail);
+  app.use(require('../src/bongos/routes/public.js')());
+  const server = await new Promise((r) => { const s = app.listen(0, '127.0.0.1', () => r(s)); });
+  const get = async (p) => { const res = await fetch(`http://127.0.0.1:${server.address().port}${p}`); return { status: res.status, body: await res.json() }; };
+  const close = async () => {
+    db.getBuilderRoleChoices = realChoices;
+    seams._reset();
+    server.closeAllConnections();
+    await new Promise((r) => server.close(r));
+    await new Promise((r) => setTimeout(r, 50));
+  };
+  return { get, close };
+}
+
+await test('GET /public/leaderboard: every row names its roles and the credits each craft earned', async () => {
+  const s = await bootPublic();
+  try {
+    const { status, body } = await s.get('/public/leaderboard');
+    assert.equal(status, 200);
+    const [eng, art] = body.leaderboard;
+    assert.deepEqual(eng.roles.shown, ['engineer']);
+    assert.deepEqual(art.roles.shown, ['artist']);
+    assert.equal(art.roles.main_basis, 'chosen');
+    assert.equal(art.roles.credits_by_craft.artist, 370, 'the figure an Artists toggle ranks by is in the row');
+  } finally { await s.close(); }
+});
+
+await test('a roles failure costs the roles, never the board', async () => {
+  const s = await bootPublic({ rolesThrow: true });
+  try {
+    const { status, body } = await s.get('/public/leaderboard');
+    assert.equal(status, 200);
+    assert.equal(body.leaderboard.length, 2, 'the rows still go out');
+    assert.ok(body.leaderboard.every((r) => r.roles === undefined), 'and simply carry no roles');
+  } finally { await s.close(); }
+});
+
+await test('the public list carries karma, so the roster can read it and keep its karma column', () => {
+  const sql = read('modules/economy/achievements.js');
+  const q = sql.slice(sql.indexOf('async function getLeaderboardWithAchievements'), sql.indexOf('async function getLeaderboardWithAchievements') + 1200);
+  assert.match(q, /\bb\.karma\b/);
+});
+
+// ---- 3. the roster ----------------------------------------------------------------
+
+function bootRoster() {
+  const els = {};
+  const el = (id) => (els[id] = els[id] || {
+    id, innerHTML: '', textContent: '', className: '', hidden: true,
+    listeners: {}, addEventListener(t, f) { this.listeners[t] = f; },
+    querySelectorAll: () => [],
+  });
+  let ledgerOpts = null;
+  let rendered = [];
+  const kit = {
+    esc: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
+    makePager: () => ({ page: 1 }),
+    makeFilterBar: () => {},
+    makeLedger: (opts) => { ledgerOpts = opts; return { render: (rows) => { rendered = rows; } }; },
+  };
+  let resolveLoaded;
+  const loaded = new Promise((r) => { resolveLoaded = r; });
+  const sandbox = {
+    window: { OTBKit: kit, OTB: { fmtInt: (n) => String(Number(n) || 0), rankLabel: (r) => r } },
+    document: { getElementById: el },
+    fetch: async (url) => { sandbox.__url = url; return { ok: true, json: async () => FIX }; },
+    console, Promise, setTimeout,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(read('modules/hall-ui/public/roster.js'), sandbox, { filename: 'roster.js' });
+  setTimeout(resolveLoaded, 30);
+  return {
+    loaded, sandbox, els,
+    get opts() { return ledgerOpts; },
+    get rows() { return rendered; },
+    click(roleKey) {
+      els['roster-roles'].listeners.click({ target: { closest: () => ({ dataset: { role: roleKey } }) } });
+    },
+  };
+}
+
+await test('the roster reads the public list and draws a Roles column, main role first', async () => {
+  const r = bootRoster();
+  await r.loaded;
+  assert.equal(r.sandbox.__url, '/api/bongos/public/leaderboard', 'the list that carries the roles');
+  const labels = JSON.parse(JSON.stringify(r.opts.columns.map((c) => (typeof c === 'string' ? c : c.label))));
+  assert.deepEqual(labels, ['Place', 'Builder', 'Roles', 'Rank', 'Credits', 'Karma', 'Tokens']);
+  const art = r.rows.find((b) => String(b.id) === '2001');
+  const html = r.opts.rowHtml(art);
+  assert.match(html, /<span class="lb-role lb-role--lead">Artist<\/span><span class="lb-role">Ideator<\/span>/);
+  assert.match(r.els['roster-roles'].innerHTML, /Everyone[\s\S]*Engineers[\s\S]*Artists[\s\S]*Ideators/);
+});
+
+await test('a builder with no AI sessions reads a dash and a sentence, never a 0 of tokens', async () => {
+  const r = bootRoster();
+  await r.loaded;
+  const art = r.rows.find((b) => String(b.id) === '2001');
+  const cells = r.opts.rowHtml(art).split('</td>');
+  const tokensCell = cells[6];
+  assert.ok(!/>0</.test(tokensCell), 'no bare 0 in the tokens cell');
+  assert.match(tokensCell, /—/);
+  assert.match(tokensCell, /No AI sessions recorded/, 'the tooltip says why, instead of a tokens-per-credit figure');
+  const eng = r.rows.find((b) => Number(b.tokens_used) > 0);
+  assert.match(r.opts.rowHtml(eng), /tokens per credit/, 'the efficiency figure still shows where there are tokens');
+});
+
+await test('the Artists toggle shows only artists, ranked by the credits that craft earned, with its own places', async () => {
+  const r = bootRoster();
+  await r.loaded;
+  r.click('artist');
+  const ids = r.rows.map((b) => String(b.id));
+  const artists = FIX.leaderboard.filter((b) => b.roles.shown.includes('artist'));
+  assert.deepEqual(ids.sort(), artists.map((b) => String(b.id)).sort(), 'exactly the builders shown as artists');
+  const credits = r.rows.map((b) => b.roles.credits_by_craft.artist);
+  assert.deepEqual(credits, [...credits].sort((a, b) => b - a), 'ranked by artist credits, not total credits');
+  assert.equal(String(r.rows[0].id), '2001', 'the browser-only artist leads the artists');
+  const labels = r.opts.columns.map((c) => (typeof c === 'string' ? c : c.label));
+  assert.equal(labels[4], 'Credits as artist', 'the header names the craft');
+  assert.match(r.opts.rowHtml(r.rows[0]), /ledger__place">1</, 'the place is the place among artists');
+  assert.match(r.opts.rowHtml(r.rows[0]), /<td class="ledger__num">370<\/td>/, 'and the figure is the artist credits');
+  r.click('');
+  assert.equal(r.rows.length, FIX.leaderboard.length, 'Everyone brings every builder back');
+});
+
+// ---- 4. the standing card ---------------------------------------------------------
+
+function extract(src, start, end) {
+  const a = src.indexOf(start);
+  const b = src.indexOf(end, a);
+  assert.ok(a !== -1 && b !== -1, `found ${start}`);
+  return src.slice(a, b);
+}
+
+await test('the standing card adds the place inside the builder\'s main role, only when it says something new', () => {
+  const src = read('modules/hall-ui/public/hall-render.js');
+  const code = extract(src, 'const lbState = { rows: [] };', '// task 1003459');
+  const sandbox = { rows: FIX.leaderboard };
+  vm.createContext(sandbox);
+  vm.runInContext(`${code}; lbState.rows = rows; this.place = leaderboardPlace; this.text = rolePlaceText;`, sandbox);
+  const art = sandbox.place('builder-7');
+  assert.equal(art.role.craft, 'artist');
+  assert.equal(sandbox.text(art), `#1 as an artist`);
+  const top = sandbox.place(FIX.leaderboard[0].github_login);
+  assert.equal(sandbox.text(top), '', 'the top engineer is #1 either way, so nothing is added');
+  assert.match(src, /setText\('stat-rank-sub', rollPlace \? \[`#\$\{rollPlace\.place\} on the leaderboard`, rolePlaceText\(rollPlace\)\]/);
+  assert.match(read('modules/hall-ui/public/builders.js'), /getJSON\(`\$\{API\}\/public\/leaderboard`\)/, 'the hall reads the list with the roles');
+});
+
+// ---- 5. the status page -----------------------------------------------------------
+
+await test('the status leaderboard names each builder\'s roles, main one first, as text', () => {
+  const src = read('modules/status-ui/public/status.js');
+  const code = extract(src, 'const ROLE_WORD', 'async function loadLeaderboard');
+  const made = [];
+  const node = (tag) => {
+    const n = { tag, className: '', textContent: '', children: [], attrs: {}, appendChild(c) { this.children.push(c); }, setAttribute(k, v) { this.attrs[k] = v; } };
+    made.push(n);
+    return n;
+  };
+  const sandbox = { document: { createElement: node } };
+  vm.createContext(sandbox);
+  vm.runInContext(`${code}; this.renderRoles = renderRoles;`, sandbox);
+  const row = sandbox.renderRoles({ shown: ['artist', 'ideator', 'wizard'] });
+  assert.deepEqual(row.children.map((c) => [c.className, c.textContent]), [
+    ['leader__role leader__role--lead', 'Artist'],
+    ['leader__role', 'Ideator'],
+  ], 'a word the page does not know is dropped, not printed');
+  assert.equal(sandbox.renderRoles(null), null, 'a row without roles draws nothing');
+  assert.match(src, /const roles = renderRoles\(b\.roles\);\s*if \(roles\) name\.appendChild\(roles\);/);
+});
+
+summary();

package/tests/npm_release_release.mjs

@@ -99,6 +99,41 @@ test('an unreadable registry and a missing dispatcher both release nothing, and
   assert.equal((await requestRelease({ version: '1.20.73', registry: REG, dispatch: null })).body.error.code, 'dispatch_unavailable');
 });
 
+// ── the refusal names the credential the server actually uses (task 1004518) ─────────
+
+test('a server on the access token is told to edit the ACCESS TOKEN', async () => {
+  const saved = process.env.GITHUB_PUSH_TOKEN;
+  process.env.GITHUB_PUSH_TOKEN = 'PAT';
+  try {
+    const d = await gp.dispatchWorkflow({ workflow: 'publish.yml' }, { appToken: async () => null, repoInfo: REPO, fetchImpl: async () => ({ ok: false, status: 403 }) });
+    assert.equal(d.credential, 'token');
+    const r = await requestRelease({ version: '1.20.73', registry: REG, dispatch: async () => d });
+    assert.match(r.body.error.message, /access token \(GITHUB_PUSH_TOKEN/);
+    assert.doesNotMatch(r.body.error.message, /GitHub App/);
+  } finally {
+    if (saved === undefined) delete process.env.GITHUB_PUSH_TOKEN; else process.env.GITHUB_PUSH_TOKEN = saved;
+  }
+});
+
+test('a server on a GitHub App is told to edit the APP — the App wins over a token, as resolveToken orders them', async () => {
+  const saved = process.env.GITHUB_PUSH_TOKEN;
+  process.env.GITHUB_PUSH_TOKEN = 'PAT';
+  try {
+    let auth = null;
+    const d = await gp.dispatchWorkflow({ workflow: 'publish.yml' }, {
+      appToken: async () => 'APPTOK', repoInfo: REPO,
+      fetchImpl: async (_u, opts) => { auth = opts.headers.Authorization || opts.headers.authorization; return { ok: false, status: 403 }; },
+    });
+    assert.equal(d.credential, 'app');
+    assert.match(String(auth), /APPTOK/, 'the App token is the one sent');
+    const r = await requestRelease({ version: '1.20.73', registry: REG, dispatch: async () => d });
+    assert.match(r.body.error.message, /the server's GitHub App needs/);
+    assert.doesNotMatch(r.body.error.message, /access token/);
+  } finally {
+    if (saved === undefined) delete process.env.GITHUB_PUSH_TOKEN; else process.env.GITHUB_PUSH_TOKEN = saved;
+  }
+});
+
 test('GitHub refusing for want of Actions: write is named as exactly that', async () => {
   const r = await requestRelease({ version: '1.20.73', registry: REG, dispatch: async () => ({ ok: false, code: 'REFUSED', status: 403 }) });
   assert.equal(r.status, 502);
@@ -113,7 +148,7 @@ test('dispatchWorkflow POSTs ref + inputs to the workflow\'s dispatches endpoint
   let captured = null;
   const fetchImpl = async (url, opts) => { captured = { url, opts, body: JSON.parse(opts.body) }; return { ok: false, status: 204 }; };
   const r = await gp.dispatchWorkflow({ workflow: 'publish.yml', ref: 'main', inputs: { release_version: '1.20.73' } }, { token: 'T', repoInfo: REPO, fetchImpl });
-  assert.deepEqual(r, { ok: true });
+  assert.deepEqual(r, { ok: true, credential: 'token' });
   assert.equal(captured.url, 'https://api.github.com/repos/someowner/somerepo/actions/workflows/publish.yml/dispatches');
   assert.equal(captured.opts.method, 'POST');
   assert.deepEqual(captured.body, { ref: 'main', inputs: { release_version: '1.20.73' } });
@@ -135,7 +170,7 @@ test('dispatchWorkflow: no credential is UNCONFIGURED; a 403 is REFUSED with its
   } finally {
     if (saved !== undefined) process.env.GITHUB_PUSH_TOKEN = saved;
   }
-  assert.deepEqual(await gp.dispatchWorkflow({ workflow: 'publish.yml' }, { token: 'T', repoInfo: REPO, fetchImpl: async () => ({ ok: false, status: 403 }) }), { ok: false, code: 'REFUSED', status: 403 });
+  assert.deepEqual(await gp.dispatchWorkflow({ workflow: 'publish.yml' }, { token: 'T', repoInfo: REPO, fetchImpl: async () => ({ ok: false, status: 403 }) }), { ok: false, code: 'REFUSED', status: 403, credential: 'token' });
   assert.equal((await gp.dispatchWorkflow({ workflow: 'publish.yml' }, { token: 'T', repoInfo: REPO, fetchImpl: async () => { throw new Error('down'); } })).code, 'UNREACHABLE');
 });
 

package/tests/projects_hub.mjs

@@ -765,7 +765,9 @@ test('the table is in the world: a masthead, then ledger rows — no panel, no s
   assert.match(COSMOS, /\.tbl \.tblRow:hover\{border-top-color:var\(--ink-faint\);\}/, 'hover is the hairline taking ink, not an accent tint');
   assert.match(COSMOS, /\.rowGo\{[^}]*border:1px solid var\(--rule\);border-radius:var\(--radius-pill\);/, 'the row\'s door is the mine row\'s hairline pill');
   assert.match(HUB, /<a class="rowGo" href="\/">view<\/a>/, 'the self row\'s door');
-  assert.match(SCRIPT, /'<a class="rowGo" href="' \+ esc\(safeHttpUrl\(p\.origin\)\)/, 'the generated rows\' door');
+  assert.match(SCRIPT, /'<a class="rowGo" href="' \+ esc\(siteHref\(p\)\)/, 'the generated rows\' door');
+  assert.match(SCRIPT, /function siteHref\(p\) \{ return p\._inst && !addressReady\(p\._inst\) \? '' : safeHttpUrl\(p\.origin\); \}/,
+    'scheme-checked, and none for your own project until its address answers (task 1004505)');
   assert.match(COSMOS, /\.mastObj\{display:block;--dia:clamp\(96px,10vw,132px\);[^}]*background-image:var\(--plate-set-cut\);/, 'the object is the set\'s small bead by token, in both modes');
   assert.doesNotMatch(COSMOS, /mix-blend-mode:var\(--mast/, 'the cutout needs no blend — the view wrap is a stacking context');
 });
@@ -1426,7 +1428,7 @@ test('the save sends the choice and shows the platform’s receipt verbatim —
 test('what the project RUNS comes only from its own manifest, and every answer is said', () => {
   const runs = fnHub('loadVisRuns');
   const manifest = fnHub('ensureManifest');
-  assert.match(runs, /inst\.status !== 'active' \|\| !inst\.domain/, 'only a live project with an address can be asked');
+  assert.match(runs, /inst\.status !== 'active' \|\| !addressReady\(inst\)/, 'only a live project whose address answers can be asked (task 1004505)');
   assert.match(manifest, /'https:\/\/' \+ domain \+ '\/api\/bongos\/instance'/,
     'the same public GET /instance the platform’s runner reads after a restart');
   assert.doesNotMatch(runs, /fetch\(/, 'the card fires no GET of its own — one manifest read serves the pair (task 1003554)');
@@ -1631,7 +1633,7 @@ test('the joinability save sends the one key and shows the platform’s receipt
 
 test('what the project RUNS for joinability comes only from its own manifest, and every answer is said', () => {
   const runs = fnHub('loadJoinRuns');
-  assert.match(runs, /inst\.status !== 'active' \|\| !inst\.domain/, 'only a live project with an address can be asked');
+  assert.match(runs, /inst\.status !== 'active' \|\| !addressReady\(inst\)/, 'only a live project whose address answers can be asked (task 1004505)');
   assert.match(runs, /ensureManifest\(inst\.domain\)/, 'the same public GET /instance the runner reads, through the shared reader');
   assert.doesNotMatch(runs, /fetch\(/, 'the second card of the pair adds no round trip of its own (task 1003554)');
   assert.match(runs, /p && p\.joinability/, 'the manifest key is brand.project.joinability');

package/tests/projects_hub_dns_ready.mjs

@@ -0,0 +1,153 @@
+// tests/projects_hub_dns_ready.mjs
+//
+// No address link renders before the platform's own lookup answers (task 1004505,
+// BV2.PS17). A founder's first click on a name that does not resolve yet is cached as
+// "not found" by their resolver for the zone's negative TTL (30 minutes on
+// cloudbongos.com), so the hub holds every door to the address until the instance read
+// 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
+// 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
+// compared as primitives or through JSON.
+//
+// The runner half (the record is created first) is tests/provision_dns_first.mjs.
+//
+// Run:  node tests/projects_hub_dns_ready.mjs
+
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const LANDING = path.join(ROOT, 'modules', 'public-landing', 'public');
+const HUB = fs.readFileSync(path.join(LANDING, 'projects.html'), 'utf8').replace(/\r\n/g, '\n');
+
+function slice(from, to) {
+  const a = HUB.indexOf(from);
+  const b = HUB.indexOf(to, a + 1);
+  assert.ok(a > 0, `slice start must exist: ${from}`);
+  assert.ok(b > a, `slice end must follow it: ${to}`);
+  return HUB.slice(a, b);
+}
+
+const PROGRESS = slice('var PROG_FLOWS = {', 'function startProgress(');
+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]]) {
+  assert.ok(region.includes(`function ${name}(`), `the slice must carry ${name}`);
+}
+
+function boot() {
+  const liveProgress = { innerHTML: '' };
+  const sandbox = {
+    $: (id) => (id === 'liveProgress' ? liveProgress : null),
+    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>',
+    relTime: () => '2 minutes ago',
+    canRestart: () => false,
+    planetOf: () => ({ tpl: 'blob-tint', acc: 'var(--a1)' }),
+    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 };
+}
+
+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/;
+
+test('active but not yet resolved: the done panel holds the link, says so, and keeps watching', () => {
+  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/);
+});
+
+test('a down probe on a never-resolved address is still "being set up", never a link', () => {
+  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/);
+});
+
+test('once the lookup answers, the done panel links the address', () => {
+  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);
+  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);
+});
+
+test('the card and the manage page: no link and no name before the lookup answers, in every pre-live state', () => {
+  const { sandbox } = boot();
+  for (const status of ['requested', 'provisioning', 'active']) {
+    const row = sandbox.addressRow({ ...base, status, dns_resolves: false });
+    assert.doesNotMatch(row, /<a /, `${status}: no link`);
+    assert.doesNotMatch(row, /lantern\.cloudbongos\.com/, `${status}: no name`);
+    assert.equal(row, sandbox.ADDRESS_SETTING_UP, `${status}: the being-set-up line`);
+    assert.doesNotMatch(sandbox.addressRow({ ...base, status, dns_resolves: false }, true), /<a /, `${status}: the manage page too`);
+  }
+});
+
+test('the card links the address once it resolves, and keeps a verified-up project linked', () => {
+  const { sandbox } = boot();
+  assert.match(sandbox.addressRow({ ...base, dns_resolves: true }), ADDRESS_LINK);
+  assert.match(sandbox.addressRow({ ...base, last_verified_up: true, last_verified_at: NOW() }), ADDRESS_LINK, 'an up probe is the same proof');
+});
+
+test('a manual-DNS note still names the address (pointing it is the owner\'s step) but never links it', () => {
+  const { sandbox } = boot();
+  const note = 'Automatic DNS isn\'t set up on this platform — point it at your server.';
+  for (const status of ['provisioning', 'active']) {
+    const row = sandbox.addressRow({ ...base, status, dns_resolves: false, dns_note: note });
+    assert.match(row, /<code>lantern\.cloudbongos\.com<\/code>/);
+    assert.doesNotMatch(row, /<a /);
+  }
+});
+
+test('the row\'s planet opens the site only once the address answers', () => {
+  const { sandbox } = boot();
+  assert.match(sandbox.orbFor({ ...base, dns_resolves: false }), /^<span /);
+  assert.match(sandbox.orbFor({ ...base, dns_resolves: true }), /^<a [^>]*href="https:\/\/lantern\.cloudbongos\.com"/);
+});
+
+test('addressReady: a domain plus a sighting or an up probe — never the status alone', () => {
+  const { sandbox } = boot();
+  const cases = [
+    [{ ...base }, false],
+    [{ ...base, dns_resolves: true }, true],
+    [{ ...base, last_verified_up: true }, true],
+    [{ ...base, last_verified_up: false }, false],
+    [{ ...base, domain: null, dns_resolves: true }, false],
+  ];
+  assert.equal(JSON.stringify(cases.map(([i]) => sandbox.addressReady(i))), JSON.stringify(cases.map(([, want]) => want)));
+});
+
+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');
+  assert.match(SCRIPT, /live\.instStatus !== 'active' \|\| !live\.addrReady \|\| live\.manifest !== 'done'/, 'first sign-in and the hall step stay locked');
+  assert.match(SCRIPT, /live\.addrReady = addressReady\(inst\); renderSteps\(\);/, 'and unlock on the tick the lookup answers');
+  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
+  const raw = SCRIPT.match(/href="https:\/\/' \+ esc\(inst\.domain\)/g) || [];
+  assert.equal(raw.length, 4, 'orb, the card link, View and Open site — each gated above or in addressRow');
+});