@bongos/core 1.21.1 → 1.21.2

package/scripts/hall-preview/refresh-fixtures.js

@@ -76,6 +76,8 @@ const SNAPSHOTS = [
   ['public/grades?days=7', 'public__grades'],
   ['public/repo-health?days=30', 'public__repo-health'],
   ['public/bounty-table', 'public__bounty-table'],
+  // the roster and the Standing card read the public list, with its roles (task 1004437)
+  ['public/leaderboard', 'public__leaderboard'],
   ['public/cost-summary', 'public__cost-summary'],
   ['public/progress', 'public__progress'],
   ['public/recent-shipped', 'public__recent-shipped'],

package/src/bongos/db.js

@@ -207,6 +207,18 @@ async function getBuilderRoleChoice(builderId) {
   return rows[0] ?? null;
 }
 
+// The same two facts for a whole list of builders, in ONE statement (task
+// 1004437): the public leaderboard names every row's roles. Map<idString, row>.
+async function getBuilderRoleChoices(builderIds) {
+  const ids = (builderIds || []).map(String).filter((v) => /^[1-9]\d*$/.test(v));
+  if (!ids.length) return new Map();
+  const { rows } = await pool.query(
+    `SELECT id, preferred_disciplines, main_discipline FROM builders WHERE id = ANY($1::bigint[])`,
+    [ids]
+  );
+  return new Map(rows.map((r) => [String(r.id), r]));
+}
+
 // The builder-PREFS db slice — the five per-builder preference jsonb columns on
 // `builders` (skill_model_prefs / sound_prefs / behavior_prefs / event_sound_prefs)
 // — was carved into modules/builder-settings/db.js (BV1.R80 / ADR 0093 §1). Core
@@ -1103,6 +1115,7 @@ module.exports = {
   updateBuilderDisciplines,
   UPDATE_BUILDER_DISCIPLINES_SQL,
   getBuilderRoleChoice,
+  getBuilderRoleChoices,
   RANKS,
   setBuilderRank,
   getLatestRankChangeForBuilder,

package/src/bongos/role-stats.js

@@ -149,7 +149,41 @@ async function readRoleStats(builderId, { shippedCount = 0, getRoleChoice } = {}
   return composeRoleStats({ choice, byCraft, shippedCount, artist, ideator });
 }
 
-// Only the reader is exported: the pure halves above are reached through it
+// readRolesForBuilders — the same main/shown rules for a WHOLE LIST at once
+// (task 1004437 / WA6.RP07): the public leaderboard names each builder's roles
+// and ranks a role by the credits earned in it, so every row needs its `shown`
+// crafts and its ledger split. Two reads for the whole page of rows, never one
+// per row: the role choices (`getRoleChoices`, one statement) and economy's
+// `creditsByCraft`, which already batches. Returns Map<idString, { main,
+// main_basis, shown, credits_by_craft }>, every id asked for present. Counts and
+// sums only, as the profile's tally is: nothing here is behind a sign-in.
+async function readRolesForBuilders(builderIds, { getRoleChoices } = {}) {
+  const ids = [...new Set((builderIds || []).map(String).filter((v) => /^[1-9]\d*$/.test(v)))];
+  const out = new Map();
+  if (!ids.length) return out;
+  const reward = seams.resolveOptional('reward');
+  const [choices, byCraftMap] = await Promise.all([
+    getRoleChoices ? getRoleChoices(ids) : new Map(),
+    reward && typeof reward.creditsByCraft === 'function' ? reward.creditsByCraft(ids) : null,
+  ]);
+  for (const id of ids) {
+    const choice = (choices && choices.get(id)) || null;
+    const byCraft = byCraftMap ? (byCraftMap.get(id) || null) : null;
+    const preferred = (choice && choice.preferred_disciplines) || [];
+    const { main, basis } = resolveMainRole({ mainDiscipline: choice && choice.main_discipline, preferred, byCraft });
+    out.set(id, {
+      main,
+      main_basis: basis,
+      shown: shownCrafts({ main, preferred, byCraft }),
+      credits_by_craft: byCraft
+        ? { engineer: byCraft.engineer, artist: byCraft.artist, ideator: byCraft.ideator, other: byCraft.other, total: byCraft.total }
+        : null,
+    });
+  }
+  return out;
+}
+
+// Only the readers are exported: the pure halves above are reached through them
 // (tests/profile_role_stats.mjs drives them via the real route), and an export
 // nothing imports is dead surface to the knip ratchet.
-module.exports = { readRoleStats };
+module.exports = { readRoleStats, readRolesForBuilders };

package/src/bongos/routes/public.js

@@ -37,6 +37,7 @@ const { clientBranding, branding } = require('../../branding');
 const { clientModules } = require('../../modules');
 const { publicReadRateLimitMiddleware } = require('../middleware/rate-limit');
 const { parseId, corsPublicGet, parsePagination, pageMeta } = require('./_helpers');
+const { readRolesForBuilders } = require('../role-stats');
 // task 1003208: structured logging — was console.*. A core file logs through
 // the kernel logger directly; only MODULES go via api.logger (the doorway).
 const log = require('../logger').logger.child({ src: 'public' });
@@ -235,9 +236,19 @@ module.exports = function buildPublicRouter() {
     // 100 preserves the prior ceiling. `page` is additive (readers of .leaderboard
     // unchanged). Mirrors the authed /leaderboard.
     const { limit, offset } = parsePagination(req, { defaultLimit: 100, maxLimit: 200 });
-    const rows = await seams.resolveOptional('reward').getLeaderboardWithAchievements(offset + limit, 5);
+    const rows = (await seams.resolveOptional('reward').getLeaderboardWithAchievements(offset + limit, 5)).slice(offset, offset + limit);
+    // task 1004437 (WA6.RP07): each row names its roles, main first, and carries
+    // the credits each craft earned, so a role filter ranks by a figure the row
+    // itself publishes (ADR 0255). Two reads for the page, not one per row. A
+    // failure costs the roles, never the board: the rows still go out.
+    try {
+      const roles = await readRolesForBuilders(rows.map((r) => r.id), { getRoleChoices: db.getBuilderRoleChoices });
+      for (const r of rows) r.roles = roles.get(String(r.id)) || null;
+    } catch (err) {
+      log.error({ err }, 'leaderboard roles failed');
+    }
     res.set('Cache-Control', 'public, max-age=60');
-    res.json({ leaderboard: rows.slice(offset, offset + limit), page: pageMeta(limit, offset) });
+    res.json({ leaderboard: rows, page: pageMeta(limit, offset) });
   });
 
   // rank: public — est-vs-actual aggregate.

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.21.1'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.2'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');

package/tests/achievements_reconcile.mjs

@@ -100,6 +100,19 @@ function fakeClient({ eligible = new Set(), unlocked = new Set(), credits = 0 })
     if (s.includes("reason = 'ship.net_negative'")) {
       return { rows: [{ n: eligible.has('subtractor') ? 3 : 0 }], rowCount: 1 };
     }
+    // the craft achievements (task 1004438): ONE facts read answers all seven
+    if (s.startsWith('select bool_or(reason like $2) as ignited')) {
+      return {
+        rows: [{
+          ignited: eligible.has('first-thought-ignited'),
+          full_idea: eligible.has('first-full-idea'),
+          ratified: eligible.has('first-board-ratification'),
+          pages: eligible.has('ten-pages-approved') ? 10 : eligible.has('first-page-approved') ? 1 : 0,
+          best_thought_tasks: eligible.has('thought-built-ten') ? 10 : 0,
+        }],
+        rowCount: 1,
+      };
+    }
     return no;
   });
 

package/tests/craft_achievements.mjs

@@ -0,0 +1,349 @@
+// tests/craft_achievements.mjs — achievements for artist and ideator moments
+// (task 1004438 / WA6.RP08, goal 1000095, criterion wa6-roles-read-true-in-public).
+//
+// The done-when: "fixtures earn each new achievement exactly once, and existing
+// artists and ideators get theirs on backfill". Run for real:
+//
+//   1. THE CATALOG. migrations/core_270 seeds seven craft achievements, renames the
+//      misleading art-pipeline-shipper, and its LIKE literals are economy's own
+//      reason prefixes (a drift there awards nothing and errors nowhere).
+//   2. THE RECONCILE. The REAL reconcileBuilderAchievements over a stateful fake
+//      ledger: an ideator and an artist earn each badge at its threshold, and a
+//      second and third reconcile unlock nothing more.
+//   3. THE WRITERS. The REAL awardIdeaFullPassCredit and awardArtistPageCredit pay
+//      the payee AND put the moment on their shelf — the payment happens inside
+//      someone else's ship, so the shipper's reconcile would never reach them —
+//      and a reconcile that throws never fails the payment.
+//   4. THE BACKFILL. The migration's backfill statements key on the same facts and
+//      stamp the FIRST qualifying credit, idempotently.
+//   5. THE PICTURES. The roster's and the status page's emoji maps carry every id
+//      with the migration's own icon.
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+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 read = (f) => fs.readFileSync(path.join(ROOT, f), 'utf8').replace(/\r\n/g, '\n');
+const MIGRATION = read('migrations/core_270_craft_achievements.sql');
+const seams = require('../src/module-seams.js');
+const achievements = require('../modules/economy/achievements.js');
+const credits = require('../modules/economy/credits.js');
+
+const CRAFT = ['first-thought-ignited', 'first-full-idea', 'first-board-ratification', 'thought-built-ten',
+  'first-page-approved', 'ten-pages-approved', 'whole-surface-tweaked'];
+
+// the catalog rows, read out of the migration's VALUES list
+function catalog() {
+  const out = new Map();
+  for (const m of MIGRATION.matchAll(/\('([a-z0-9-]+)', '([^']+)',\s*'([^']*)',\s*'([^']+)', (\d+), (\d+)\)/g)) {
+    out.set(m[1], { id: m[1], name: m[2], description: m[3], icon: m[4], credit_bonus: Number(m[5]), sort_order: Number(m[6]) });
+  }
+  return out;
+}
+const CATALOG = catalog();
+
+// ---- a stateful fake ledger ---------------------------------------------------------
+// Understands exactly the statements the reconcile and the two writers send; every
+// other read answers "nothing" (the engineer evaluators find no claims, no streak).
+const likeRe = (pat) => new RegExp('^' + pat.replace(/[.*+?^${}()|[\]]/g, (c) => `\\${c}`).replace(/\\\\_/g, '_').replace(/%/g, '.*') + '$');
+function fakeLedger({ failReconcile = false } = {}) {
+  const ledger = [];
+  const unlocked = [];
+  const sql = [];
+  let nextId = 1;
+  const rowsFor = (builderId, pat) => ledger.filter((r) => String(r.builder_id) === String(builderId) && likeRe(pat).test(r.reason) && r.delta > 0);
+  const client = {
+    ledger, unlocked, sql,
+    async query(text, params = []) {
+      const q = text.replace(/\s+/g, ' ').trim();
+      sql.push(q);
+      if (/^(SAVEPOINT|RELEASE SAVEPOINT|ROLLBACK TO SAVEPOINT)/.test(q)) return { rows: [], rowCount: 0 };
+      if (q.startsWith('SELECT 1 FROM builder_achievements WHERE builder_id=$1 AND achievement_id=$2')) {
+        if (failReconcile) throw new Error('reconcile blew up');
+        const hit = unlocked.some((u) => String(u.builder_id) === String(params[0]) && u.achievement_id === params[1]);
+        return { rows: hit ? [{}] : [], rowCount: hit ? 1 : 0 };
+      }
+      if (q.startsWith('SELECT id, name, credit_bonus FROM achievements WHERE id=$1')) {
+        const a = CATALOG.get(params[0]) || (params[0] === 'first-ship' ? null : null);
+        return a ? { rows: [a], rowCount: 1 } : { rows: [], rowCount: 0 };
+      }
+      if (q.startsWith('INSERT INTO builder_achievements')) {
+        if (!unlocked.some((u) => String(u.builder_id) === String(params[0]) && u.achievement_id === params[1])) {
+          unlocked.push({ builder_id: String(params[0]), achievement_id: params[1], task: params[2] });
+        }
+        return { rows: [], rowCount: 1 };
+      }
+      if (q.startsWith('INSERT INTO credit_log')) {
+        // the writers' INSERT ... SELECT ... WHERE NOT EXISTS (per builder+reason, or task+reason)
+        const [builderId, taskId, delta, reason, description] = params;
+        const exists = q.includes('WHERE task_id = $2 AND reason = $4')
+          ? ledger.some((r) => String(r.task_id) === String(taskId) && r.reason === reason)
+          : ledger.some((r) => String(r.builder_id) === String(builderId) && r.reason === reason);
+        if (exists) return { rows: [], rowCount: 0 };
+        ledger.push({ id: nextId++, builder_id: String(builderId), task_id: taskId, delta, reason, description: description || '' });
+        return { rows: [], rowCount: 1 };
+      }
+      if (q.startsWith('SELECT achievement_id FROM builder_achievements WHERE builder_id = $1 AND achievement_id = ANY($2::text[])')) {
+        if (failReconcile) throw new Error('reconcile blew up');
+        return { rows: unlocked.filter((u) => u.builder_id === String(params[0]) && params[1].includes(u.achievement_id)).map((u) => ({ achievement_id: u.achievement_id })) };
+      }
+      if (q.startsWith('SELECT bool_or(reason LIKE $2) AS ignited')) {
+        // the craft facts, computed the way the statement says: one row of aggregates
+        const [b, ship, full, board, page] = params;
+        const byIdea = new Map();
+        for (const r of rowsFor(b, ship)) {
+          const [, idea, task] = r.reason.split(':');
+          if (!byIdea.has(idea)) byIdea.set(idea, new Set());
+          byIdea.get(idea).add(task);
+        }
+        return {
+          rows: [{
+            ignited: rowsFor(b, ship).length > 0 ? true : null,
+            full_idea: rowsFor(b, full).length > 0 ? true : null,
+            ratified: rowsFor(b, board).length > 0 ? true : null,
+            pages: rowsFor(b, page).length,
+            best_thought_tasks: Math.max(0, ...[...byIdea.values()].map((s) => s.size)),
+          }],
+          rowCount: 1,
+        };
+      }
+      if (q.startsWith('SELECT DISTINCT builder_id FROM credit_log')) {
+        const pats = params.slice(0, 4).map(likeRe);
+        const ids = [...new Set(ledger.filter((r) => r.delta > 0 && pats.some((re) => re.test(r.reason))).map((r) => r.builder_id))].sort();
+        return { rows: ids.map((builder_id) => ({ builder_id })) };
+      }
+      if (q.startsWith('SELECT COUNT(*)::int AS n FROM credit_log')) return { rows: [{ n: 0 }], rowCount: 1 };
+      if (q.startsWith('SELECT total_credits FROM builders')) return { rows: [{ total_credits: 0 }], rowCount: 1 };
+      // a page-tweak task read by awardArtistPageCredit
+      if (q.includes('FROM tasks t') && q.includes('artist_id')) {
+        return { rows: [{ source: 'page-tweak', status: 'shipped', credits_reward: 30, kind: 'feature', artist_id: '2001' }], rowCount: 1 };
+      }
+      return { rows: [], rowCount: 0 };
+    },
+  };
+  return client;
+}
+const pay = (client, builderId, reason, delta = 5, task = null) => client.ledger.push({ id: client.ledger.length + 1000, builder_id: String(builderId), task_id: task, delta, reason, description: '' });
+const shelf = (client, builderId) => client.unlocked.filter((u) => u.builder_id === String(builderId)).map((u) => u.achievement_id).sort();
+const craftShelf = (client, builderId) => shelf(client, builderId).filter((id) => CRAFT.includes(id));
+
+// ---- 1. the catalog -------------------------------------------------------------------
+
+await test('the migration seeds seven craft achievements, paying no bonus, and renames the art-pipeline badge', () => {
+  assert.deepEqual([...CATALOG.keys()].sort(), [...CRAFT].sort());
+  for (const a of CATALOG.values()) assert.equal(a.credit_bonus, 0, `${a.id}: recognition only, no minted credits on backfill`);
+  assert.match(MIGRATION, /UPDATE achievements\s+SET name = 'Art Pipeline Engineer'[\s\S]*icon = '🛠️'\s+WHERE id = 'art-pipeline-shipper'/);
+  assert.equal(CATALOG.get('first-page-approved').icon, '🎨', 'the palette is the artist\'s now');
+  const ids = achievements.STATE_EVALUATORS ? achievements.STATE_EVALUATORS.map((e) => e.id) : null;
+  if (ids) for (const id of CRAFT) assert.ok(ids.includes(id), `${id} has an evaluator`);
+});
+
+await test('the migration\'s LIKE literals are economy\'s own reason prefixes, escaped', () => {
+  const lit = (p) => p.replace(/_/g, '\\_') + '%';
+  for (const p of [credits.IDEA_STREAM_REASON_PREFIXES.task_ship, credits.IDEA_STREAM_REASON_PREFIXES.full_pass,
+    credits.IDEA_STREAM_REASON_PREFIXES.governance_pass, credits.ARTIST_PAGE_REASON_PREFIX]) {
+    assert.ok(MIGRATION.includes(`LIKE '${lit(p)}'`), `the backfill spells ${p}`);
+    assert.ok(read('modules/economy/achievements.js').includes(lit(p).replace(/\\/g, '\\\\')), `the evaluator spells ${p}`);
+  }
+});
+
+// ---- 2. the reconcile -----------------------------------------------------------------
+
+await test('an ideator earns each idea badge at its threshold, exactly once', async () => {
+  seams._reset();
+  const c = fakeLedger();
+  const IDE = '2002';
+  await achievements.reconcileBuilderAchievements(c, IDE);
+  assert.deepEqual(craftShelf(c, IDE), [], 'nothing for a builder the ledger has paid nothing');
+  pay(c, IDE, 'idea.credit.task_ship:7:101');
+  pay(c, IDE, 'idea.credit.full_pass:7');
+  pay(c, IDE, 'idea.credit.governance_pass:7');
+  for (let t = 1; t <= 9; t++) pay(c, IDE, `idea.credit.task_ship:8:${200 + t}`);
+  await achievements.reconcileBuilderAchievements(c, IDE);
+  assert.deepEqual(craftShelf(c, IDE), ['first-board-ratification', 'first-full-idea', 'first-thought-ignited'],
+    'nine tasks under one thought (plus one under another) is not ten from one');
+  pay(c, IDE, 'idea.credit.task_ship:8:210');
+  pay(c, IDE, 'idea.credit.task_ship:8:210', 3); // a second payee row for the same task is not a second task
+  await achievements.reconcileBuilderAchievements(c, IDE);
+  await achievements.reconcileBuilderAchievements(c, IDE);
+  assert.deepEqual(craftShelf(c, IDE), ['first-board-ratification', 'first-full-idea', 'first-thought-ignited', 'thought-built-ten']);
+  assert.equal(c.unlocked.length, new Set(c.unlocked.map((u) => u.achievement_id)).size, 'each exactly once');
+});
+
+await test('an artist earns First Page, Ten Pages and A Whole Surface, exactly once', async () => {
+  seams._reset();
+  let surfaces = [{ key: 'landing', tweaked: 5, total: 6 }];
+  seams.registerProvider('copy-desk.artistStats', async () => ({ surfaces }));
+  const c = fakeLedger();
+  const ART = '2001';
+  pay(c, ART, 'tweak.page_approved:301', 30, 301);
+  await achievements.reconcileBuilderAchievements(c, ART);
+  assert.deepEqual(craftShelf(c, ART), ['first-page-approved']);
+  for (let t = 2; t <= 9; t++) pay(c, ART, `tweak.page_approved:${300 + t}`, 30, 300 + t);
+  await achievements.reconcileBuilderAchievements(c, ART);
+  assert.deepEqual(craftShelf(c, ART), ['first-page-approved'], 'nine pages is not ten');
+  pay(c, ART, 'tweak.page_approved:310', 30, 310);
+  surfaces = [{ key: 'landing', tweaked: 6, total: 6 }];
+  await achievements.reconcileBuilderAchievements(c, ART);
+  await achievements.reconcileBuilderAchievements(c, ART);
+  assert.deepEqual(craftShelf(c, ART), ['first-page-approved', 'ten-pages-approved', 'whole-surface-tweaked']);
+  assert.equal(c.unlocked.length, 3, 'each exactly once');
+  seams._reset();
+});
+
+await test('A Whole Surface without the studio\'s port is "could not tell", never a badge', async () => {
+  seams._reset();
+  const c = fakeLedger();
+  pay(c, '2001', 'tweak.page_approved:301', 30, 301);
+  await achievements.reconcileBuilderAchievements(c, '2001');
+  assert.ok(!shelf(c, '2001').includes('whole-surface-tweaked'));
+});
+
+// ---- 3. the writers -------------------------------------------------------------------
+
+await test('a Full Idea payment puts First Full Idea on the ideator\'s shelf, in the same call', async () => {
+  seams._reset();
+  const c = fakeLedger();
+  const r = await credits.awardIdeaFullPassCredit(c, { ideaId: 7, authorId: '2002', completenessScore: 90, config: { ideatorCredit: true } });
+  assert.ok(r.credited > 0, 'paid');
+  assert.deepEqual(craftShelf(c, '2002'), ['first-full-idea']);
+  assert.ok(c.sql.includes('SAVEPOINT ach_craft_credit'), 'under a savepoint, so a gamification error cannot fail the payment');
+  const again = await credits.awardIdeaFullPassCredit(c, { ideaId: 7, authorId: '2002', completenessScore: 90, config: { ideatorCredit: true } });
+  assert.equal(again.credited, 0, 'the second call pays nothing');
+  assert.equal(c.unlocked.length, 1, 'and unlocks nothing more');
+});
+
+await test('an approved page puts First Page Approved on the artist\'s shelf', async () => {
+  seams._reset();
+  const c = fakeLedger();
+  const r = await credits.awardArtistPageCredit(c, 301);
+  assert.equal(r.reason, 'paid');
+  assert.deepEqual(craftShelf(c, '2001'), ['first-page-approved']);
+});
+
+await test('a reconcile that throws never fails the payment', async () => {
+  seams._reset();
+  const c = fakeLedger({ failReconcile: true });
+  const r = await credits.awardIdeaFullPassCredit(c, { ideaId: 9, authorId: '2002', completenessScore: 90, config: { ideatorCredit: true } });
+  assert.ok(r.credited > 0, 'still paid');
+  assert.equal(c.ledger.length, 1);
+  assert.ok(c.sql.includes('ROLLBACK TO SAVEPOINT ach_craft_credit'), 'rolled back to its own savepoint only');
+  // on a POOL (no transaction) SAVEPOINT itself fails; the reconcile still runs
+  const pool = fakeLedger();
+  const q = pool.query.bind(pool);
+  pool.query = (text, params) => (/^SAVEPOINT/.test(text) ? Promise.reject(new Error('SAVEPOINT can only be used in transaction blocks')) : q(text, params));
+  await achievements.reconcileAfterCraftCredit(pool, '2002');
+  pay(pool, '2002', 'idea.credit.full_pass:11');
+  const got = await achievements.reconcileAfterCraftCredit(pool, '2002');
+  assert.deepEqual(got.map((a) => a.id), ['first-full-idea'], 'a pool payer still reaches the shelf');
+});
+
+await test('a payment runs only the craft rules, in two reads, and asks the studio only about an artist', async () => {
+  seams._reset();
+  let portCalls = 0;
+  seams.registerProvider('copy-desk.artistStats', async () => { portCalls++; return { surfaces: [] }; });
+  const c = fakeLedger();
+  await credits.awardIdeaFullPassCredit(c, { ideaId: 7, authorId: '2002', completenessScore: 90, config: { ideatorCredit: true } });
+  const after = c.sql.slice(c.sql.findIndex((q) => q.startsWith('SAVEPOINT ach_craft_credit')));
+  assert.ok(!after.some((q) => /FROM claims|session_records|total_credits FROM builders|ship\.net_negative/.test(q)),
+    'no claim, streak, diff or credit-total check on an idea payment');
+  assert.equal(after.filter((q) => q.startsWith('SELECT achievement_id FROM builder_achievements')).length, 1, 'one read of what is held');
+  assert.equal(after.filter((q) => q.startsWith('SELECT bool_or(reason LIKE $2) AS ignited')).length, 1, 'one read of the craft facts');
+  assert.equal(portCalls, 0, 'an ideator with no approved page is never asked about surfaces');
+  await credits.awardArtistPageCredit(c, 301);
+  assert.equal(portCalls, 1, 'an artist with an approved page is');
+  seams._reset();
+});
+
+await test('a builder holding every craft badge costs one read and nothing more', async () => {
+  seams._reset();
+  const c = fakeLedger();
+  for (const id of CRAFT) c.unlocked.push({ builder_id: '2002', achievement_id: id });
+  const before = c.sql.length;
+  await achievements.reconcileAfterCraftCredit(c, '2002');
+  const sent = c.sql.slice(before).filter((q) => !/SAVEPOINT/.test(q));
+  assert.deepEqual(sent.map((q) => q.slice(0, 40)), ['SELECT achievement_id FROM builder_achie']);
+});
+
+// ---- 4. the backfill ------------------------------------------------------------------
+
+await test('A Whole Surface is backfilled by the once-per-start sweep, for the artists the ledger has paid', async () => {
+  seams._reset();
+  let asked = [];
+  seams.registerProvider('copy-desk.artistStats', async (id) => { asked.push(String(id)); return { surfaces: [{ tweaked: 4, total: 4 }] }; });
+  const c = fakeLedger();
+  pay(c, '2001', 'tweak.page_approved:301', 30, 301);
+  pay(c, '2002', 'idea.credit.task_ship:7:101');
+  pay(c, '95', 'session.token_reward', 40); // an engineer the craft ledger never paid
+  const out = await achievements.backfillCraftAchievements({ client: c });
+  assert.equal(out.checked, 2, 'the artist and the ideator, not the engineer');
+  assert.ok(shelf(c, '2001').includes('whole-surface-tweaked'));
+  assert.ok(!shelf(c, '95').length, 'the engineer is untouched');
+  assert.deepEqual(asked, ['2001'], 'the studio is asked about the artist only');
+  const again = await achievements.backfillCraftAchievements({ client: c });
+  assert.equal(again.unlocked, 0, 'a second run unlocks nothing');
+
+  const reconciler = require('../modules/lifecycle/publish-reconciler.js');
+  const calls = [];
+  const reward = { backfillCraftAchievements: async () => { calls.push(1); return { checked: 1, unlocked: 1 }; } };
+  const quiet = { logFn: () => {}, errFn: () => {} };
+  await reconciler.runCraftAchievementBackfill({ reward, ...quiet, forceCraftBackfill: true });
+  await reconciler.runCraftAchievementBackfill({ reward, ...quiet });
+  assert.equal(calls.length, 1, 'once per process start, not on every tick');
+  const failing = await reconciler.runCraftAchievementBackfill({ reward: { backfillCraftAchievements: async () => { throw new Error('db down'); } }, ...quiet, forceCraftBackfill: true });
+  assert.equal(failing.skipped, 'error', 'a failure is logged and swallowed');
+  assert.match(read('modules/lifecycle/publish-reconciler.js'), /runCraftAchievementBackfill\(deps\)\.catch\(crashHandler\('craft achievement backfill'\)\)/, 'the tick runs it');
+  seams._reset();
+});
+
+await test('the backfill keys each badge on the same ledger fact and stamps the first qualifying credit, idempotently', () => {
+  const blocks = MIGRATION.split('INSERT INTO builder_achievements').slice(1);
+  const ids = blocks.map((b) => (b.match(/'([a-z0-9-]+)'/) || [])[1]);
+  assert.deepEqual(ids.sort(), CRAFT.filter((id) => id !== 'whole-surface-tweaked').sort(),
+    'six backfilled from the ledger; A Whole Surface needs the page inventory (a file), so the reconcile awards it');
+  for (const b of blocks) {
+    assert.match(b, /ON CONFLICT DO NOTHING/, 'a re-run converges');
+    assert.match(b, /delta > 0/, 'a zero or negative row is no moment');
+  }
+  assert.match(blocks.find((b) => b.includes("'ten-pages-approved'")), /WHERE nth = 10/, 'stamped at the tenth page');
+  assert.match(blocks.find((b) => b.includes("'thought-built-ten'")), /PARTITION BY builder_id, split_part\(reason, ':', 2\)/, 'counted per thought');
+  assert.match(MIGRATION, /diagnose-achievements\.js --apply/, 'the migration names how A Whole Surface is backfilled');
+});
+
+// ---- 5. the pictures ------------------------------------------------------------------
+
+await test('the roster and the status page draw every craft badge with the migration\'s icon', () => {
+  const roster = read('modules/hall-ui/public/roster.js');
+  const status = read('modules/status-ui/public/status.js');
+  const unescape = (s) => s.replace(/\\u\{([0-9A-F]+)\}/gi, (_, h) => String.fromCodePoint(parseInt(h, 16)));
+  for (const a of CATALOG.values()) {
+    const r = roster.match(new RegExp(`'${a.id}': '([^']+)'`));
+    const s = status.match(new RegExp(`'${a.id}': '([^']+)'`));
+    assert.ok(r && unescape(r[1]) === a.icon, `roster draws ${a.id} as ${a.icon}`);
+    assert.ok(s && s[1] === a.icon, `status draws ${a.id} as ${a.icon}`);
+  }
+  assert.ok(unescape(roster.match(/'art-pipeline-shipper': '([^']+)'/)[1]) === '🛠️');
+  assert.equal(status.match(/'art-pipeline-shipper': '([^']+)'/)[1], '🛠️');
+});
+
+await test('a badge is named in words for a hover and a screen reader, never its id slug', () => {
+  const roster = read('modules/hall-ui/public/roster.js');
+  const fn = roster.slice(roster.indexOf('function achWords'), roster.indexOf('function achRowHtml'));
+  const achWords = new Function(`${fn}; return achWords;`)();
+  assert.equal(achWords('first-page-approved'), 'First page approved');
+  assert.equal(achWords('thought-built-ten'), 'Thought built ten');
+  assert.match(roster, /title="' \+ esc\(words\) \+ '" aria-label="' \+ esc\(words\) \+ '"/);
+  assert.doesNotMatch(roster, /title="' \+ esc\(id\)/);
+  const status = read('modules/status-ui/public/status.js');
+  assert.doesNotMatch(status, /span\.title = id;/);
+  assert.match(status, /span\.setAttribute\('aria-label', span\.title\)/);
+});
+
+summary();

package/tests/founding_builders.mjs

@@ -192,7 +192,8 @@ async function rosterRows(marks) {
       makeLedger: (cfg) => { rowFn = cfg.rowHtml; return { render() {} }; },
     },
   });
-  sandbox.document = { getElementById: () => ({ innerHTML: '', className: '', textContent: '', hidden: false }) };
+  // addEventListener/querySelectorAll: the role toggle wires its chips (task 1004437).
+  sandbox.document = { getElementById: () => ({ innerHTML: '', className: '', textContent: '', hidden: false, addEventListener() {}, querySelectorAll: () => [] }) };
   if (!marks) delete sandbox.window.OTBFounding; // a page without the script at all
   vm.runInContext(read('roster.js'), sandbox, { filename: 'roster.js' });
   await new Promise((r) => setImmediate(r));

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 },