@bongos/core 1.24.79 → 1.24.80

package/tests/hub_craft_rollup.mjs

@@ -4,7 +4,11 @@
 // The cross-project rollup used to carry one ship count (with no status filter)
 // and "Roles" from the declared preference alone, so on the hub an artist with
 // forty approved pages, or an ideator the board ratified, read as an engineer
-// with nothing shipped. Three halves, each driven through its real code:
+// with nothing shipped. Since task 1005141 (BONGOS-V3) there are two crafts:
+// the engineer is the ARTISAN, and the ideator folded into the ARTIST, whose one
+// block carries the page count AND the idea counts under one credit split. An
+// instance on an older core still reports the old three; the hub folds them.
+// Three halves, each driven through its real code:
 //
 //   1. THE SENDER (core auth-admission.js reportActivityRollup) counts SHIPPED
 //      works only, sends each EARNED craft's counts (the ledger split decides,
@@ -13,7 +17,7 @@
 //      the body strictly — re-sends once without `crafts` when an older hub
 //      refuses the field, so the totals are never lost.
 //   2. THE HUB ROUTE + upsertActivity accept `crafts` and bind only the
-//      sanitised shape: three crafts, named counts, integers or null. Nothing a
+//      sanitised shape: two crafts, named counts, integers or null. Nothing a
 //      sender writes can carry text through it.
 //   3. getRollupForBuilder sums each craft over EVERY project row — named or
 //      not, exactly as the totals are (the aggregate is not the leak, the name
@@ -66,12 +70,12 @@ const seams = require('../src/module-seams.js');
 // One rollup through the real sender. `byCraft` is economy's ledger split for
 // builder 7 (null = no economy module); `ports` the craft stats; `statuses` the
 // HTTP status each successive send answers.
-async function sendRollup({ byCraft = null, preferred = ['engineer'], ports = {}, statuses = [200] } = {}) {
+async function sendRollup({ byCraft = null, preferred = ['artisan'], ports = {}, statuses = [200] } = {}) {
   seams._reset();
   if (byCraft) {
     seams.registerProvider('reward', {
       creditsByCraft: async (ids) => new Map(ids.map((id) => [String(id), byCraft])),
-      craftForPreference: (d) => (d === 'ui' ? 'artist' : ['engineer', 'artist', 'ideator'].includes(d) ? d : null),
+      craftForPreference: (d) => (d === 'ui' ? 'artist' : ['artisan', 'artist'].includes(d) ? d : null),
     });
   }
   for (const [k, fn] of Object.entries(ports)) seams.registerProvider(k, fn);
@@ -110,52 +114,51 @@ await t('the ship count asks for SHIPPED works only (the missing status filter)'
   assert.match(q.text, /status = 'shipped'/, 'a count without the status filter also counts work handed back after shipping');
 });
 
-await t('an artist who is also an ideator sends both crafts\' counts, and only counts', async () => {
+await t('an artist with pages AND ideas sends ONE artist block of both halves\' counts, and only counts', async () => {
   const { sent } = await sendRollup({
-    byCraft: { engineer: 0, artist: 1100, ideator: 160, other: 0, total: 1260 },
+    byCraft: { artisan: 0, artist: 1260, other: 0, total: 1260 },
     preferred: ['ui'],
     ports: { 'copy-desk.artistStats': ARTIST_STATS, 'ideas.ideatorStats': IDEATOR_STATS },
   });
   assert.equal(sent.length, 1);
   const body = sent[0];
   assert.deepEqual(body.crafts, {
-    artist: { pages_approved: 42, credits: 1100 },
-    ideator: { filed: 12, full_ideas: 2, ratified: 1, credits: 160 },
-  }, 'exactly the named counts — no surface line, no size, no wording');
+    artist: { pages_approved: 42, filed: 12, full_ideas: 2, ratified: 1, credits: 1260 },
+  }, 'exactly the named counts — no surface line, no size, no wording; credits are the craft ledger split');
   assert.ok(!JSON.stringify(body).includes('secret wording'), 'no page wording leaves the instance');
-  assert.deepEqual(body.disciplines, ['artist', 'ideator'], 'crafts from evidence of work, in preferred order (ui → artist)');
+  assert.deepEqual(body.disciplines, ['artist'], 'crafts from evidence of work, once each (ui → artist)');
   assert.equal(body.tasks_shipped, 5, 'CONTROL: the totals still ride');
 });
 
 await t('an unearned craft sends nothing, and its stats port is never asked', async () => {
   let asked = 0;
   const { sent } = await sendRollup({
-    byCraft: { engineer: 900, artist: 0, ideator: 0, other: 0, total: 900 },
-    preferred: ['artist', 'engineer'],
+    byCraft: { artisan: 900, artist: 0, other: 0, total: 900 },
+    preferred: ['artist', 'artisan'],
     ports: { 'copy-desk.artistStats': async () => { asked++; return {}; } },
   });
-  assert.deepEqual(sent[0].crafts, { engineer: { shipped: 5, credits: 900 } });
-  assert.deepEqual(sent[0].disciplines, ['engineer'], 'a declared but unearned role is not shown once work exists elsewhere');
+  assert.deepEqual(sent[0].crafts, { artisan: { shipped: 5, credits: 900 } });
+  assert.deepEqual(sent[0].disciplines, ['artisan'], 'a declared but unearned role is not shown once work exists elsewhere');
   assert.equal(asked, 0, 'a craft that will not be sent is not read');
 });
 
 await t('nothing earned, or no economy to ask → the declared preference, and no crafts field', async () => {
-  const none = await sendRollup({ byCraft: { engineer: 0, artist: 0, ideator: 0, other: 0, total: 0 }, preferred: ['ideator'] });
-  assert.deepEqual(none.sent[0].disciplines, ['ideator'], 'the fallback is the preference');
+  const none = await sendRollup({ byCraft: { artisan: 0, artist: 0, other: 0, total: 0 }, preferred: ['artist'] });
+  assert.deepEqual(none.sent[0].disciplines, ['artist'], 'the fallback is the preference');
   assert.ok(!('crafts' in none.sent[0]), 'no crafts field, so an older hub never sees one');
-  const vanilla = await sendRollup({ byCraft: null, preferred: ['engineer', 'ui'] });
-  assert.deepEqual(vanilla.sent[0].disciplines, ['engineer', 'ui']);
+  const vanilla = await sendRollup({ byCraft: null, preferred: ['artisan', 'ui'] });
+  assert.deepEqual(vanilla.sent[0].disciplines, ['artisan', 'ui']);
   assert.ok(!('crafts' in vanilla.sent[0]));
 });
 
 await t('a craft whose port cannot be asked sends null counts, never 0', async () => {
-  const { sent } = await sendRollup({ byCraft: { engineer: 0, artist: 50, ideator: 0, other: 0, total: 50 }, preferred: [] });
-  assert.deepEqual(sent[0].crafts, { artist: { pages_approved: null, credits: 50 } });
+  const { sent } = await sendRollup({ byCraft: { artisan: 0, artist: 50, other: 0, total: 50 }, preferred: [] });
+  assert.deepEqual(sent[0].crafts, { artist: { pages_approved: null, filed: null, full_ideas: null, ratified: null, credits: 50 } });
 });
 
 await t('an older hub refusing `crafts` (400) gets the report again without it — once', async () => {
   const { sent } = await sendRollup({
-    byCraft: { engineer: 0, artist: 1100, ideator: 0, other: 0, total: 1100 },
+    byCraft: { artisan: 0, artist: 1100, other: 0, total: 1100 },
     ports: { 'copy-desk.artistStats': ARTIST_STATS },
     statuses: [400, 200],
   });
@@ -195,6 +198,7 @@ function hubRoute() {
     resolveSession: async () => null,
     logger: () => ({ info() {}, warn() {}, error() {} }),
     LIVE_RANK_LADDER: realApi.LIVE_RANK_LADDER,
+    crafts: realApi.crafts,
     withTx: realApi.withTx,
     corsPublicGet: () => (_q, _s, next) => next(),
     on: () => () => {},
@@ -225,26 +229,60 @@ await t('a report carrying crafts is accepted and binds the craft counts', async
   assert.equal(res.failure, null, JSON.stringify(res.failure));
   assert.match(insert.text, /reported_as_of, crafts\)/, 'the upsert writes the crafts column');
   assert.match(insert.text, /crafts = EXCLUDED\.crafts/, 'and a later report replaces it');
-  assert.deepEqual(JSON.parse(insert.params[9]), { artist: { pages_approved: 42, credits: 1100 } });
+  assert.deepEqual(JSON.parse(insert.params[9]), {
+    artist: { pages_approved: 42, filed: null, full_ideas: null, ratified: null, credits: 1100 },
+  }, 'a count the report did not carry is bound as null, never 0');
 });
 
-await t('the hub keeps only the three crafts and their named integer counts', async () => {
+await t('a report from an older core (engineer / artist / ideator) is folded into today\'s two crafts', async () => {
+  const { res, insert } = await postRollup({
+    crafts: {
+      engineer: { shipped: 3, credits: 9 },
+      artist: { pages_approved: 42, credits: 1100 },
+      ideator: { filed: 12, full_ideas: 2, ratified: 1, credits: 160 },
+    },
+  });
+  assert.equal(res.failure, null, JSON.stringify(res.failure));
+  assert.deepEqual(JSON.parse(insert.params[9]), {
+    artisan: { shipped: 3, credits: 9 },
+    artist: { pages_approved: 42, filed: 12, full_ideas: 2, ratified: 1, credits: 1260 },
+  }, 'engineer → artisan; the ideator counts join the artist block, credits summed');
+});
+
+await t('the hub keeps only the two crafts and their named integer counts', async () => {
   const { insert } = await postRollup({
     crafts: {
-      artist: { pages_approved: 'forty', credits: -3, title: '<script>' },
-      ideator: { filed: 1.5, full_ideas: 99_000_000, ratified: 2, credits: 7, idea_title: 'A secret plan' },
+      artist: { pages_approved: 'forty', filed: 1.5, full_ideas: 99_000_000, ratified: 2, credits: -3, title: '<script>', idea_title: 'A secret plan' },
       governor: { laws: 4 },
-      engineer: 'lots',
+      artisan: 'lots',
     },
   });
   const bound = JSON.parse(insert.params[9]);
   assert.deepEqual(bound, {
-    artist: { pages_approved: null, credits: null },
-    ideator: { filed: null, full_ideas: null, ratified: 2, credits: 7 },
+    artist: { pages_approved: null, filed: null, full_ideas: null, ratified: 2, credits: null },
   });
   assert.ok(!insert.params[9].includes('secret') && !insert.params[9].includes('script'), 'no text survives');
 });
 
+await t('an old-shape report is capped half by half: a hostile count on one side cannot shave the other', async () => {
+  const { insert } = await postRollup({
+    crafts: {
+      artist: { pages_approved: 'forty', credits: -3, title: '<script>' },
+      ideator: { filed: 1.5, full_ideas: 99_000_000, ratified: 2, credits: 7, idea_title: 'A secret plan' },
+    },
+  });
+  assert.deepEqual(JSON.parse(insert.params[9]), {
+    artist: { pages_approved: null, filed: null, full_ideas: null, ratified: 2, credits: 7 },
+  }, 'the -3 is dropped before the sum, never subtracted from the 7');
+  assert.ok(!insert.params[9].includes('secret') && !insert.params[9].includes('script'), 'no text survives the fold');
+});
+
+await t('an older core\'s disciplines (engineer, ideator) are read as today\'s crafts, once each', async () => {
+  const { res, insert } = await postRollup({ disciplines: ['engineer', 'ideator', 'artist', 'ui'] });
+  assert.equal(res.failure, null, JSON.stringify(res.failure));
+  assert.deepEqual(insert.params[6], ['artisan', 'artist', 'ui'], 'engineer → artisan; ideator and artist are one craft; ui stays');
+});
+
 await t('a report with no crafts (an older instance) binds the empty object', async () => {
   const { res, insert } = await postRollup({});
   assert.deepEqual(res.body, { ok: true });
@@ -271,6 +309,7 @@ await t('getRollupForBuilder sums each craft over EVERY project row, named or no
       return { rows: [
         { name: 'Pub', origin: 'https://pub.example', rank_held: 'metic', recent_ships: [], is_public: true,
           crafts: { artist: { pages_approved: 40, credits: 1000 } } },
+        // A row stored by an older core, before the hub migration ran: folded on read.
         { name: 'Hidden', origin: 'https://priv.example', rank_held: 'xenos', recent_ships: [], is_public: false,
           crafts: { artist: { pages_approved: 2, credits: null }, ideator: { filed: 5, full_ideas: 1, ratified: null, credits: 60 } } },
         { name: 'Old', origin: 'https://old.example', rank_held: null, recent_ships: [], is_public: true, crafts: {} },
@@ -281,9 +320,8 @@ await t('getRollupForBuilder sums each craft over EVERY project row, named or no
   const r = await pi.getRollupForBuilder(42, { pool });
   assert.match(pool.find(/recent_ships/).text, /a\.crafts/, 'the per-project read carries crafts');
   assert.deepEqual(r.crafts, {
-    artist: { pages_approved: 42, credits: 1000 },
-    ideator: { filed: 5, full_ideas: 1, ratified: null, credits: 60 },
-  }, 'a private project is counted, as its totals are; a count nobody reported stays null');
+    artist: { pages_approved: 42, filed: 5, full_ideas: 1, ratified: null, credits: 1060 },
+  }, 'a private project is counted, as its totals are; an old-shape row folds in; a count nobody reported stays null');
   assert.deepEqual(r.projects.map((p) => p.name), ['Pub', 'Old'], 'CONTROL: the private project is still not NAMED');
   assert.ok(!JSON.stringify(r.projects).includes('pages_approved'), 'per-project numbers never cross, only the sum');
 });
@@ -323,8 +361,8 @@ const tileOf = (html, label) => {
   return m ? m[1] : null;
 };
 
-await t('an artist\'s and an ideator\'s tiles show their own craft\'s numbers', async () => {
-  const html = await renderXp(CP({ artist: { pages_approved: 42, credits: 1100 }, ideator: { filed: 12, full_ideas: 2, ratified: 1, credits: 160 } }));
+await t('the artist\'s tiles show both halves of the craft: pages, thoughts and Full Ideas', async () => {
+  const html = await renderXp(CP({ artist: { pages_approved: 42, filed: 12, full_ideas: 2, ratified: 1, credits: 1260 } }));
   assert.equal(tileOf(html, 'Pages approved'), '42');
   assert.equal(tileOf(html, 'Thoughts filed'), '12');
   assert.equal(tileOf(html, 'Full Ideas'), '2');
@@ -334,12 +372,13 @@ await t('an artist\'s and an ideator\'s tiles show their own craft\'s numbers',
 });
 
 await t('a count no project could report is a dash, never 0', async () => {
-  const html = await renderXp(CP({ artist: { pages_approved: null, credits: 50 } }));
+  const html = await renderXp(CP({ artist: { pages_approved: null, filed: null, full_ideas: null, ratified: null, credits: 50 } }));
   assert.equal(tileOf(html, 'Pages approved'), '—');
+  assert.equal(tileOf(html, 'Thoughts filed'), '—');
 });
 
-await t('no crafts (an engineer, or an older hub) → no craft band at all', async () => {
-  for (const crafts of [undefined, {}, { engineer: { shipped: 3, credits: 9 } }]) {
+await t('no crafts (an artisan, or an older hub) → no craft band at all', async () => {
+  for (const crafts of [undefined, {}, { artisan: { shipped: 3, credits: 9 } }]) {
     const html = await renderXp(CP(crafts));
     assert.ok(!html.includes('stat-row--craft'), `no craft band for ${JSON.stringify(crafts)}`);
     assert.equal((html.match(/stat-tile__num/g) || []).length, 4);

package/tests/hub_recent_ships.mjs

@@ -184,6 +184,7 @@ await t('the route passes recent_ships through and takes the origin from the CLI
       resolveSession: async () => null,
       logger: () => ({ info() {}, warn() {}, error() {} }),
       LIVE_RANK_LADDER: realApi.LIVE_RANK_LADDER,
+      crafts: realApi.crafts,   // the rollup normalizes reported disciplines (task 1005141)
       corsPublicGet: () => (_q, _s, next) => next(),
       on: () => () => {},
       hasProvider: () => false,
@@ -201,7 +202,7 @@ await t('the route passes recent_ships through and takes the origin from the CLI
   const req = {
     body: {
       client_id: 'c1', client_secret: SECRET, github_id: 42,
-      credits: 10, tasks_shipped: 2, karma: 1, rank: 'metic', disciplines: ['engineer'],
+      credits: 10, tasks_shipped: 2, karma: 1, rank: 'metic', disciplines: ['artisan'],
       // Five, so the HUB's cap is what decides — a sender that ignores its own
       // cap must not widen the section.
       recent_ships: [1, 2, 3, 4, 5].map((n) => ship({ id: n, title: `work ${n}`, url: `${ORIGIN}/builders#/task/${n}` })),
@@ -222,7 +223,7 @@ console.log('\n4. a work title surfaces only where the project name may:');
 await t('getRollupForBuilder attaches recent_ships to publicly-named projects only', async () => {
   const pool = mockPool((sql) => {
     if (/WITH agg AS/.test(sql)) {
-      return { rows: [{ projects: 2, credits: 5, works_shipped: 2, karma: 0, last_active: null, disciplines: ['engineer'] }] };
+      return { rows: [{ projects: 2, credits: 5, works_shipped: 2, karma: 0, last_active: null, disciplines: ['artisan'] }] };
     }
     return {
       rows: [

package/tests/idea_cascade.mjs

@@ -51,7 +51,7 @@ test('a Full Idea matches, and files for the ENGINEER', () => {
   const { matched, errors } = C.cascadesFor(idea(), C.IDEA_CASCADES, {}, C.TRIGGERS.idea);
   assert.deepEqual(errors, []);
   assert.equal(matched.length, 1);
-  assert.equal(matched[0].rule.discipline, 'engineer');
+  assert.equal(matched[0].rule.discipline, 'artisan');
   assert.match(matched[0].spec.title, /Scope the Full Idea: Price swaps from mechanism/);
 });
 
@@ -138,7 +138,7 @@ test('the runner files the task from the event payload alone', async () => {
   assert.deepEqual(report.errors, []);
   assert.equal(report.created.length, 1);
   assert.equal(d.created.length, 1);
-  assert.equal(d.created[0].discipline, 'engineer');
+  assert.equal(d.created[0].discipline, 'artisan');
 });
 
 test('an already-filed cascade is SKIPPED, not filed twice', async () => {

package/tests/idea_credit_streams_db.mjs

@@ -147,7 +147,7 @@ async function fixture(client, { completeness = 70, developed = false, taskCount
     const task = await insertRow(client, 'tasks', {
       // discipline is named for the same reason as the version status above:
       // tasks_discipline_check admits only the live crafts.
-      version_id: version.id, title: `ic6 task ${i + 1}`, status: 'shipped', discipline: 'engineer',
+      version_id: version.id, title: `ic6 task ${i + 1}`, status: 'shipped', discipline: 'artisan',
     });
     await insertRow(client, 'ideas_task_lineage', {
       task_id: task.id, idea_id: idea.id, origin: 'promote',

package/tests/idea_detail_page.mjs

@@ -95,7 +95,7 @@ function render(idea, { template = TEMPLATE, templateFails = false, ideaStatus =
       // the same reason categoryChip is: an undefined helper throws mid-render.
       roleAxisLabel: () => 'Role',
       roleLabel: (d) => (!d ? '' : d === 'unclassified' ? 'No role yet' : d === 'ui' ? 'UI' : d.charAt(0).toUpperCase() + d.slice(1)),
-      roleOptions: () => [{ value: '', label: '— any —' }, { value: 'engineer', label: 'Engineer' }, { value: 'artist', label: 'Artist' }],
+      roleOptions: () => [{ value: '', label: '— any —' }, { value: 'artisan', label: 'Artisan' }, { value: 'artist', label: 'Artist' }],
       roleIsUnset: (d) => !d || d === 'unclassified',
       ROLE_UNSET: 'unclassified',
       escapeHtml: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),

package/tests/idea_ideate_full.mjs

@@ -5,7 +5,7 @@
 //
 // WHERE THAT PLAYBOOK LIVES (task 1002990). It used to be the /ideate skill. The
 // kernel/pack split moved it into the Ideator role pack and deleted the skill, so
-// this suite now reads docs/packs/ideator.md. Every contract below is unchanged —
+// this suite now reads docs/packs/artist.md. Every contract below is unchanged —
 // the file moved, the promises did not — and pointing the suite at the new home is
 // what stops the split from silently dropping the guard with the skill.
 //
@@ -37,7 +37,10 @@ import { namesFieldKey } from './helpers.mjs';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const SKILL = fs.readFileSync(path.join(ROOT, 'docs/packs/ideator.md'), 'utf8');
+// The ideas half's detail moved to docs/recipes/ideation-playbook.md when the ideator
+// folded into the artist (task 1005141): the pack and its playbook are read as one text.
+const SKILL = fs.readFileSync(path.join(ROOT, 'docs/packs/artist.md'), 'utf8')
+  + '\n' + fs.readFileSync(path.join(ROOT, 'docs/recipes/ideation-playbook.md'), 'utf8');
 // Prose assertions run against a WHITESPACE-NORMALISED copy. Markdown is hard-
 // wrapped, so any phrase long enough to be worth asserting will eventually
 // straddle a newline — and a regex that does not allow for that fails on a

package/tests/idea_spark_hall.mjs

@@ -195,7 +195,7 @@ function boot({
       // the same reason categoryChip is: an undefined helper throws mid-render.
       roleAxisLabel: () => 'Role',
       roleLabel: (d) => (!d ? '' : d === 'unclassified' ? 'No role yet' : d === 'ui' ? 'UI' : d.charAt(0).toUpperCase() + d.slice(1)),
-      roleOptions: () => [{ value: '', label: '— any —' }, { value: 'engineer', label: 'Engineer' }, { value: 'artist', label: 'Artist' }],
+      roleOptions: () => [{ value: '', label: '— any —' }, { value: 'artisan', label: 'Artisan' }, { value: 'artist', label: 'Artist' }],
       roleIsUnset: (d) => !d || d === 'unclassified',
       ROLE_UNSET: 'unclassified',
       escapeHtml: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),

package/tests/init.mjs

@@ -134,7 +134,7 @@ test('kickoffTasks: includes the load-bearing owner-manual steps', () => {
 
 // Every kickoff task must satisfy the DB CHECK constraints (tasks_kind_check /
 // tasks_discipline_check) or the insert is rejected — which is how the branding
-// step vanished on 1.18.18: kind:'ideator' (a discipline, not a kind) violated
+// step vanished on 1.18.18: kind:'artist' (a discipline, not a kind) violated
 // tasks_kind_check and postTask absorbed the failure. Pin the vocabulary at the
 // source so this class of bug can't reach a user again.
 test('kickoffTasks: every kind/discipline satisfies the DB CHECK vocabulary', () => {
@@ -156,7 +156,7 @@ test('kickoffTasks: the branding step is a decision BY an ideator (kind vs disci
   const look = init.kickoffTasks(fullSpec()).find((t) => /instance look/i.test(t.title));
   assert.ok(look, 'the branding kickoff step exists');
   assert.equal(look.kind, 'decision');
-  assert.equal(look.discipline, 'ideator');
+  assert.equal(look.discipline, 'artist');
 });
 
 // ---- validateSpec ----
@@ -695,7 +695,7 @@ async function runSeedTests() {
     const look = findTaskPost(api, /instance look/i);
     assert.ok(look, 'the branding kickoff task was POSTed');
     assert.equal(look.body.kind, 'decision');
-    assert.equal(look.body.discipline, 'ideator');
+    assert.equal(look.body.discipline, 'artist');
   });
 
   await at('seedViaApi: a rejected task POST is LOUD — failures returned, counts reflect actual vs expected', async () => {

package/tests/instance_manifest.mjs

@@ -31,11 +31,11 @@ const BRAND_VANILLA = {
 };
 const MODULES_OTB = {
   enabled: { game: true, 'art-pipeline': true, discord: true },
-  disciplines: ['engineer', 'artist'],
+  disciplines: ['artisan', 'artist'],
 };
 const MODULES_VANILLA = {
   enabled: { game: false, 'art-pipeline': false, discord: false },
-  disciplines: ['engineer'],
+  disciplines: ['artisan'],
 };
 const REPO = { owner: 'example-owner', repo: 'example', branch: 'main', blob_base: 'x', tree_base: 'y' };
 

package/tests/kickoff_checklist.mjs

@@ -96,7 +96,7 @@ test('the look step is a decision BY an ideator in every variant', () => {
     const look = kickoffChecklist(spec(), opts).find((t) => /instance look/i.test(t.title));
     assert.ok(look, `look step present for ${JSON.stringify(opts)}`);
     assert.equal(look.kind, 'decision');
-    assert.equal(look.discipline, 'ideator');
+    assert.equal(look.discipline, 'artist');
   }
 });
 

package/tests/leaderboard_roles.mjs

@@ -12,9 +12,10 @@
 //      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.
+//      column, the Everyone / Artisans / Artists toggle ranking by the credits
+//      that craft earned, and a dash, not a 0, for a builder with no AI sessions.
+//      (Two crafts since task 1005141: the engineer is the artisan, and the
+//      ideator folded into the artist, so idea credits rank as artist credits.)
 //   4. THE STANDING CARD and 5. THE STATUS PAGE: the real functions, run.
 
 import { strict as assert } from 'node:assert';
@@ -49,26 +50,27 @@ await test('a page of builders: chosen, earned and preferred main roles, and a c
   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 },
+    { builder_id: '1', discipline: 'artisan', amount: 900 },
+    { builder_id: '1', discipline: 'artist', amount: 20 },
+    // pages (370) and ideas (42): one craft, so the grouped statement sends one row
+    { builder_id: '2', discipline: 'artist', amount: 412 },
+    { builder_id: '3', discipline: 'artist', amount: 186 },
   ], calls));
   const choices = new Map([
-    ['2', { preferred_disciplines: ['artist', 'ideator'], main_discipline: 'artist' }],
-    ['3', { preferred_disciplines: ['ideator', 'artist'], main_discipline: null }],
+    ['2', { preferred_disciplines: ['artist'], main_discipline: 'artist' }],
+    ['3', { preferred_disciplines: ['artisan', '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('1').main, r('1').main_basis, r('1').shown], ['artisan', 'earned', ['artisan', 'artist']]);
+  assert.deepEqual([r('2').main, r('2').main_basis, r('2').shown], ['artist', 'chosen', ['artist']], 'one artist, never two');
+  assert.deepEqual([r('3').main, r('3').main_basis, r('3').shown], ['artist', 'earned', ['artist']], '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.artist, 412, 'pages and ideas, one craft');
   assert.equal(r('2').credits_by_craft.total, 412);
+  assert.equal(r('2').credits_by_craft.ideator, undefined, 'no ideator column any more');
   assert.deepEqual(calls.map((c) => c[0]).sort(), ['choices', 'credits'], 'two reads for the whole page, never one per row');
   seams._reset();
 });
@@ -90,7 +92,7 @@ async function bootPublic({ rolesThrow = false } = {}) {
       { 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: '1', discipline: 'artisan', amount: 900 },
       { builder_id: '2001', discipline: 'artist', amount: 370 },
     ]),
   });
@@ -117,7 +119,7 @@ await test('GET /public/leaderboard: every row names its roles and the credits e
     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(eng.roles.shown, ['artisan']);
     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');
@@ -190,8 +192,11 @@ await test('the roster reads the public list and draws a Roles column, main role
   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/);
+  assert.match(html, /<td class="ledger__roles"><span class="lb-roles"><span class="lb-role lb-role--lead">Artist<\/span><\/span><\/td>/, 'one Artist chip, and no Ideator beside it');
+  const mixed = r.rows.find((b) => String(b.id) === '3');
+  assert.match(r.opts.rowHtml(mixed), /<span class="lb-role lb-role--lead">Artist<\/span><span class="lb-role">Artisan<\/span>/, 'main role first');
+  assert.match(r.els['roster-roles'].innerHTML, /Everyone[\s\S]*Artisans[\s\S]*Artists/);
+  assert.doesNotMatch(r.els['roster-roles'].innerHTML, /Ideators|Engineers/);
 });
 
 await test('a builder with no AI sessions reads a dash and a sentence, never a 0 of tokens', async () => {
@@ -216,11 +221,15 @@ await test('the Artists toggle shows only artists, ranked by the credits that cr
   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');
+  // The top artisan's idea credits (1,159) are artist credits now, so they lead
+  // the artists; the browser-only artist is next, by her own 412, never a 0.
+  assert.deepEqual(r.rows.slice(0, 2).map((b) => String(b.id)), ['1', '2001'], 'ranked by artist credits, idea credits included');
   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');
+  assert.match(r.opts.rowHtml(r.rows[0]), /<td class="ledger__num">1159<\/td>/, 'and the figure is the artist credits, not the 38,644 total');
+  assert.match(r.opts.rowHtml(r.rows[1]), /ledger__place">2</);
+  assert.match(r.opts.rowHtml(r.rows[1]), /<td class="ledger__num">412<\/td>/, 'the browser-only artist reads her artist credits');
   r.click('');
   assert.equal(r.rows.length, FIX.leaderboard.length, 'Everyone brings every builder back');
 });
@@ -242,9 +251,9 @@ await test('the standing card adds the place inside the builder\'s main role, on
   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`);
+  assert.equal(sandbox.text(art), `#2 as an artist`, 'fourth overall, second among artists: something new, so it is said');
   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.equal(sandbox.text(top), '', 'the top artisan is #1 either way, so nothing is added');
   // task 1005054: the stats strip (and its rank tile) left Home; the Standing chip's card carries the role place
   assert.match(src, /\$\{rolePlaceText\(rollPlace\) \? `<span title="Your place among the/);
   assert.match(read('modules/hall-ui/public/builders.js'), /getJSON\(`\$\{API\}\/public\/leaderboard`\)/, 'the hall reads the list with the roles');
@@ -264,11 +273,11 @@ await test('the status leaderboard names each builder\'s roles, main one first,
   const sandbox = { document: { createElement: node } };
   vm.createContext(sandbox);
   vm.runInContext(`${code}; this.renderRoles = renderRoles;`, sandbox);
-  const row = sandbox.renderRoles({ shown: ['artist', 'ideator', 'wizard'] });
+  const row = sandbox.renderRoles({ shown: ['artist', 'artisan', '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');
+    ['leader__role', 'Artisan'],
+  ], 'a word the page does not know (the retired ideator included) 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\);/);
 });

package/tests/lifecycle_claim_ladder_refs.mjs

@@ -0,0 +1,55 @@
+// tests/lifecycle_claim_ladder_refs.mjs — the claim refusal ladder in
+// modules/lifecycle/CLAUDE.md points at code by NAME, never by line number.
+//
+// task 1005183: the ladder cited `claims.js:138`, `:176`, `db-claims.js:414` and a dozen
+// more bare `:NNN` anchors; every one had drifted (gateOneActiveClaimPerSession was at
+// :208, claimTasksBatch at :541). A line number rots on the next edit above it and then
+// sends a reader to the wrong code with full confidence. A function name or a refusal
+// code is greppable and fails loudly here when it is renamed away.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+const doc = readFileSync(new URL('../modules/lifecycle/CLAUDE.md', import.meta.url), 'utf8');
+const dbClaims = readFileSync(new URL('../modules/lifecycle/db-claims.js', import.meta.url), 'utf8');
+const routes = readFileSync(new URL('../modules/lifecycle/routes/claims.js', import.meta.url), 'utf8');
+
+function ladderSection() {
+  const start = doc.indexOf('## The claim refusal ladder');
+  assert.ok(start >= 0, 'the ladder section exists');
+  const next = doc.indexOf('\n## ', start + 5);
+  return doc.slice(start, next < 0 ? undefined : next);
+}
+
+test('the claim ladder carries no line-number anchors (task 1005183)', () => {
+  const s = ladderSection();
+  const stale = s.match(/`[\w./-]*:\d+`|`[\w./-]+\.js:\d+`|\b[\w-]+\.js:\d+\b/g) || [];
+  assert.deepEqual(stale, [], `line-number anchors rot — name the function or refusal code instead: ${stale.join(', ')}`);
+});
+
+test('every function the ladder names exists where it says', () => {
+  // The db-claims entry points are loaded, not grepped: a rename or a dropped export
+  // reds this even when the old wording survives in a comment.
+  const claims = require('../modules/lifecycle/db-claims.js');
+  for (const fn of ['claimTask', 'claimTasksBatch', 'validateClaimBatch', 'claimUniqueViolationError']) {
+    assert.equal(typeof claims[fn], 'function', `db-claims.js exports ${fn}`);
+    assert.ok(ladderSection().includes(fn), `the ladder names ${fn}`);
+  }
+  // The two route gates are private to the router, so only their definitions can be checked.
+  for (const fn of ['gateOneActiveClaimPerSession', 'gateNewcomerClaim']) {
+    assert.match(routes, new RegExp(`function ${fn}\\b`), `routes/claims.js defines ${fn}`);
+  }
+  assert.match(routes, /router\.post\('\/claims', auth\.requireBuilder, gateOneActiveClaimPerSession, gateNewcomerClaim,/);
+});
+
+test('every refusal code the ladder names is thrown in db-claims.js', () => {
+  const s = ladderSection();
+  for (const code of ['BUILDER_INACTIVE', 'REBASE_REQUIRED', 'TASK_NOT_FOUND', 'TASK_NOT_READY', 'OPEN_BLOCKER',
+    'rank_too_low_for_task', 'INSUFFICIENT_RANK', 'DEPS_NOT_SHIPPED']) {
+    assert.ok(s.includes(code), `ladder names ${code}`);
+    assert.ok(dbClaims.includes(`'${code}'`), `db-claims.js carries ${code}`);
+  }
+});