@bongos/core 1.24.79 → 1.24.80

package/tests/profile_role_headline.mjs

@@ -3,7 +3,10 @@
 // criterion wa6-roles-read-true-in-public).
 //
 // The done-when: "engineer, artist and ideator fixtures each render their own
-// headline, matching the mock". Three layers, each run for real:
+// headline, matching the mock". Since task 1005141 (BONGOS-V3) there are two
+// crafts: the engineer is the ARTISAN, and the ideator folded into the ARTIST,
+// so the ideas-only fixture is an artist whose pages count is zero. Three
+// layers, each run for real:
 //
 //   1. The words. profile-roles.js (pure) over the three harness fixtures the
 //      renders were taken from: each craft's tally, tiles and subtitle.
@@ -32,9 +35,16 @@ const OTBKit = require('../modules/hall-ui/public/hall-kit.js');
 const ROLES_SRC = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/profile-roles.js'), 'utf8');
 const PAGE_SRC = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/profile.js'), 'utf8');
 
-const ENGINEER = FIX('builders__profile');
+const ARTISAN = FIX('builders__profile');
 const ARTIST = FIX('builders__2001__profile');
-const IDEATOR = FIX('builders__2002__profile');
+// The ideas-only artist, as the server sends it: role-stats.js merges the page
+// half in, and with copy-desk present a person with no pages gets true zeros
+// (never a missing field), and `credits` is the craft's ledger share.
+const IDEAS_FIX = FIX('builders__2002__profile');
+const IDEAS_ARTIST = { ...IDEAS_FIX, roles: { ...IDEAS_FIX.roles, artist: {
+  ...IDEAS_FIX.roles.artist,
+  pages_approved: 0, pages: 0, surfaces_touched: 0, credits: 186, this_week: 0, surfaces: [], unavailable: false,
+} } };
 const OPTS = { fmt: (n) => Number(n).toLocaleString('en-US'), currency: 'credits' };
 const words = (items) => items.map((t) => `${t.n} ${t.w}`);
 
@@ -42,63 +52,71 @@ const { test, summary } = makeRunner();
 
 // ---- 1. the words --------------------------------------------------------
 
-await test('an engineer leads with works shipped, and keeps karma', () => {
-  const v = headline(ENGINEER, OPTS);
+await test('an artisan leads with works shipped, and keeps karma', () => {
+  const v = headline(ARTISAN, OPTS);
   assert.deepEqual(words(v.tally), ['4,630 credits', '24 works shipped', '1 karma']);
   assert.deepEqual(words(v.tiles).slice(0, 4), ['24 works shipped', '4,630 credits', '1 karma', '2 achievements']);
   assert.equal(`${v.tally[1].n} ${v.tally[1].w}`, '24 works shipped', 'the main craft leads the tally');
   assert.deepEqual(v.surfaces, [], 'the per-surface rows are the artist\'s');
 });
 
-await test('an artist who never shipped a task leads with pages approved and the per-surface share', () => {
+await test('an artist who never shipped a task leads with pages approved, her ideas and the per-surface share', () => {
   const v = headline(ARTIST, OPTS);
-  assert.deepEqual(words(v.tally), ['412 credits', '9 pages approved', '+38 this week']);
-  assert.deepEqual(words(v.tiles), ['9 pages approved', '270 credits from pages', '+38 this week', '4 thoughts filed', '6 karma']);
+  assert.deepEqual(words(v.tally), ['412 credits', '9 pages approved', '4 thoughts filed'],
+    'one number from each half of the craft: pages, then thoughts (task 1005141)');
+  assert.deepEqual(words(v.tiles), ['9 pages approved', '+38 this week', '270 credits', '4 thoughts filed', '1 ignited',
+    '0 Full Ideas', '42 total size', '85% still alive', '6 karma'], 'the pages tiles, then the ideas tiles, in ONE set');
+  assert.equal(v.tiles[2].f, 'pages and ideas', 'the craft credits are both halves');
   assert.equal(v.tiles[0].f, '3 surfaces');
   assert.equal(`${v.tally[1].n} ${v.tally[1].w}`, '9 pages approved', 'the main craft leads the tally');
   assert.ok(!v.tally.some((t) => t.w === 'works shipped'), 'an artist\'s tally never says works shipped');
   assert.ok(!('sub' in v), 'no sub-line is computed: the page has none (task 1004827)');
   assert.deepEqual(v.surfaces.map((s) => s.line), ['6 of 12 tweaked', '2 of 19 tweaked', '1 of 6 tweaked']);
-  assert.ok(!words(v.tiles).some((w) => /works shipped/.test(w)), 'no engineer figure on an artist\'s numbers');
-  assert.equal(words(v.tiles).at(-1), '6 karma', 'karma ends every non-engineer set (the owner, 2026-10-01)');
+  assert.ok(!words(v.tiles).some((w) => /works shipped/.test(w)), 'no artisan figure on an artist\'s numbers');
+  assert.equal(words(v.tiles).at(-1), '6 karma', 'karma ends every non-artisan set (the owner, 2026-10-01)');
 });
 
-await test('an ideator leads with thoughts, size and what is still alive', () => {
-  const v = headline(IDEATOR, OPTS);
-  assert.deepEqual(words(v.tally), ['186 credits', '14 thoughts filed', '7 ignited']);
-  assert.deepEqual(words(v.tiles), ['14 thoughts filed', '7 ignited', '3 Full Ideas', '186~ total size', '72% still alive', '3 karma']);
-  assert.equal(v.tiles[2].f, '1 ratified by the board');
-  assert.match(v.tiles[3].title, /Includes 24 credits of historical estimate/, 'the ~ says what it means');
-  assert.equal(`${v.tally[1].n} ${v.tally[1].w}`, '14 thoughts filed', 'the main craft leads the tally');
+await test('an artist who only files ideas shows thoughts, size and what is still alive', () => {
+  const v = headline(IDEAS_ARTIST, OPTS);
+  assert.deepEqual(words(v.tally), ['186 credits', '14 thoughts filed', '7 ignited'], 'no approved page: the lead is the ideas, never a zero (task 1005141)');
+  assert.deepEqual(words(v.tiles), ['0 pages approved', '+0 this week', '186 credits', '14 thoughts filed', '7 ignited',
+    '3 Full Ideas', '186~ total size', '72% still alive', '3 karma']);
+  assert.equal(v.tiles[5].f, '1 ratified by the board');
+  assert.match(v.tiles[6].title, /Includes 24 credits of historical estimate/, 'the ~ says what it means');
+  assert.deepEqual(v.surfaces, [], 'no surface rows without pages');
 });
 
 await test('several crafts each show, main first, in the server\'s order', () => {
-  assert.deepEqual(headline(ARTIST, OPTS).crafts.map((c) => c.label), ['Artist, main role', 'Ideator']);
-  assert.deepEqual(headline(ENGINEER, OPTS).crafts.map((c) => c.label), ['Engineer, main role', 'Ideator']);
-  // The other craft adds its one headline tile after the main craft's set.
-  assert.equal(words(headline(ENGINEER, OPTS).tiles).at(-1), '9 thoughts filed');
-  const reordered = { ...ARTIST, roles: { ...ARTIST.roles, main: 'ideator', shown: ['ideator', 'artist'] } };
+  assert.deepEqual(headline(ARTIST, OPTS).crafts.map((c) => c.label), ['Artist, main role'], 'one artist chip, never two');
+  assert.deepEqual(headline(ARTISAN, OPTS).crafts.map((c) => c.label), ['Artisan, main role', 'Artist']);
+  // The other craft adds its one headline tile after the main craft's set; the
+  // artist's names their pages, with their thoughts beneath.
+  const second = headline(ARTISAN, OPTS).tiles.at(-1);
+  assert.equal(second.w, 'pages approved');
+  assert.equal(second.f, '9 thoughts filed');
+  const reordered = { ...ARTIST, roles: { ...ARTIST.roles, main: 'artisan', shown: ['artisan', 'artist'], artisan: { shipped: 0, credits: 0 } } };
   const v = headline(reordered, OPTS);
-  assert.deepEqual(v.crafts.map((c) => c.label), ['Ideator, main role', 'Artist']);
-  assert.equal(words(v.tiles).at(-2), '9 pages approved', 'the other craft\'s tile, just before karma');
+  assert.deepEqual(v.crafts.map((c) => c.label), ['Artisan, main role', 'Artist']);
+  assert.equal(words(v.tiles).at(-1), '9 pages approved', 'the other craft\'s tile closes the artisan set');
+  assert.equal(v.tiles.at(-1).f, '4 thoughts filed');
   assert.deepEqual(v.surfaces, [], 'the per-surface rows follow the MAIN craft, not any craft');
 });
 
 await test('a number the instance could not read is a dash, never a zero', () => {
-  const noDesk = { ...ARTIST, roles: { ...ARTIST.roles, artist: { pages_approved: null, credits: null, this_week: null, surfaces_touched: null, surfaces: [], unavailable: true } } };
+  const noDesk = { ...ARTIST, roles: { ...ARTIST.roles, artist: { ...ARTIST.roles.artist, pages_approved: null, pages: null, this_week: null, surfaces_touched: null, surfaces: [] } } };
   const v = headline(noDesk, OPTS);
-  assert.deepEqual(words(v.tally).slice(1), ['— pages approved', '— this week']);
+  assert.deepEqual(words(v.tally).slice(1), ['— pages approved', '4 thoughts filed'], 'the page half unknown, the ideas half still read');
   assert.equal(v.tiles[0].f, '', 'no "0 surfaces" under an unknown count');
-  const noWork = { ...IDEATOR, roles: { ...IDEATOR.roles, ideator: { ...IDEATOR.roles.ideator, alive: { share: null, has_work: false, attributable: null } } } };
+  const noWork = { ...IDEAS_ARTIST, roles: { ...IDEAS_ARTIST.roles, artist: { ...IDEAS_ARTIST.roles.artist, alive: { share: null, has_work: false, attributable: null } } } };
   assert.deepEqual(headline(noWork, OPTS).tiles.at(-2), { n: '—', w: 'still alive', f: 'nothing has come of them yet' });
-  const untraced = { ...IDEATOR, roles: { ...IDEATOR.roles, ideator: { ...IDEATOR.roles.ideator, alive: { share: null, has_work: true, attributable: false } } } };
+  const untraced = { ...IDEAS_ARTIST, roles: { ...IDEAS_ARTIST.roles, artist: { ...IDEAS_ARTIST.roles.artist, alive: { share: null, has_work: true, attributable: false } } } };
   assert.equal(headline(untraced, OPTS).tiles.at(-2).f, 'not measurable yet');
 });
 
-await test('a response from before the roles block reads as the engineer it always was', () => {
-  const { roles, ...old } = ENGINEER;
+await test('a response from before the roles block reads as the artisan (the engineer) it always was', () => {
+  const { roles, ...old } = ARTISAN;
   const v = headline(old, OPTS);
-  assert.deepEqual(v.crafts.map((c) => c.label), ['Engineer, main role']);
+  assert.deepEqual(v.crafts.map((c) => c.label), ['Artisan, main role']);
   assert.equal(`${v.tally[1].n} ${v.tally[1].w}`, '24 works shipped', 'the main craft leads the tally');
 });
 
@@ -124,7 +142,7 @@ async function boot(profileData) {
   };
   const windowObj = {
     __BRANDING__: { currency: { label: 'credits' } },
-    __MODULES__: { responsibilities: { engineer: 'E.', artist: 'A.', ideator: 'I.' } },
+    __MODULES__: { responsibilities: { artisan: 'E.', artist: 'A.' } },
     BongosClient: { createClient: () => api },
     // The real kit draws the surface bars; the section rail needs a real DOM and
     // is not what this suite is about, so it is left out (profile.js skips it).
@@ -154,22 +172,23 @@ const text = (html) => html.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim()
 await test('the real page draws the artist\'s tally, chips, tiles and surface rows', async () => {
   const p = await boot(ARTIST);
   assert.equal(p.sub, '', 'no sub-line: the head names the person, rank and headline (task 1004827)');
-  assert.match(text(p.head), /Artist, main role Ideator/);
-  assert.match(text(p.head), /412 credits 9 pages approved \+38 this week/);
+  assert.match(text(p.head), /Artist, main role Answerable for/, 'one artist chip, and no ideator chip beside it');
+  assert.ok(!/Ideator/.test(p.head), 'the ideator is not a craft any more (task 1005141)');
+  assert.match(text(p.head), /412 credits 9 pages approved 4 thoughts filed/);
   assert.match(p.head, /Answerable for:/, 'the responsibility line stays');
-  assert.match(text(p.nums), /^9 pages approved 3 surfaces 270 credits from pages \+38 this week 4 thoughts filed 1 ignited/);
+  assert.match(text(p.nums), /^9 pages approved 3 surfaces \+38 this week 270 credits pages and ideas 4 thoughts filed 1 ignited/);
   assert.equal((p.nums.match(/kit-bars__row/g) || []).length, 3, 'one kit bar row per surface');
   assert.match(text(p.nums), /Landing 6 of 12 tweaked/);
   assert.ok(!/works shipped/i.test(p.sub + p.head + p.nums), 'nothing on an artist\'s header says works shipped');
 });
 
-await test('the real page draws the ideator\'s and the engineer\'s own headlines', async () => {
-  const i = await boot(IDEATOR);
+await test('the real page draws the ideas-only artist\'s and the artisan\'s own headlines', async () => {
+  const i = await boot(IDEAS_ARTIST);
   assert.match(text(i.head), /186 credits 14 thoughts filed 7 ignited/);
   assert.match(text(i.nums), /186~ total size/);
   assert.match(text(i.nums), /72% still alive/);
-  assert.ok(!i.nums.includes('kit-bars'), 'no surface rows for an ideator');
-  const e = await boot({ ...ENGINEER, recent_ships: [] }); // the works ledger is not this suite's
+  assert.ok(!i.nums.includes('kit-bars'), 'no surface rows for an artist with no pages');
+  const e = await boot({ ...ARTISAN, recent_ships: [] }); // the works ledger is not this suite's
   assert.equal(e.sub, '', 'no sub-line (task 1004827)');
   assert.match(text(e.head), /4,630 credits 24 works shipped 1 karma/);
 });
@@ -181,21 +200,29 @@ await test('the server\'s roles block, through JSON, renders the artist\'s headl
   const { readRoleStats } = require('../src/bongos/role-stats.js');
   seams._reset();
   seams.registerProvider('reward', {
-    craftForPreference: (d) => ({ engineer: 'engineer', artist: 'artist', ui: 'artist', ideator: 'ideator' }[d] || null),
-    async creditsByCraft(ids) { return new Map([[String(ids[0]), { engineer: 0, artist: 370, ideator: 42, other: 0, total: 412 }]]); },
+    craftForPreference: (d) => ({ artisan: 'artisan', artist: 'artist', ui: 'artist' }[d] || null),
+    async creditsByCraft(ids) { return new Map([[String(ids[0]), { artisan: 0, artist: 412, other: 0, total: 412 }]]); },
   });
-  seams.registerProvider('copy-desk.artistStats', async () => ARTIST.roles.artist);
-  seams.registerProvider('ideas.ideatorStats', async () => ARTIST.roles.ideator);
+  // Each port answers ITS half of the artist block, as in production.
+  const PAGE_KEYS = ['pages_approved', 'pages', 'surfaces_touched', 'credits', 'this_week', 'week_since', 'surfaces'];
+  const pick = (keep) => Object.fromEntries(Object.entries(ARTIST.roles.artist).filter(([k]) => keep(k)));
+  seams.registerProvider('copy-desk.artistStats', async () => pick((k) => PAGE_KEYS.includes(k)));
+  seams.registerProvider('ideas.ideatorStats', async () => pick((k) => !PAGE_KEYS.includes(k)));
   const roles = await readRoleStats('2001', {
     shippedCount: 0,
-    getRoleChoice: async () => ({ main_discipline: 'artist', preferred_disciplines: ['artist', 'ideator'] }),
+    getRoleChoice: async () => ({ main_discipline: 'artist', preferred_disciplines: ['artist'] }),
   });
+  assert.equal(roles.ideator, undefined, 'no ideator block on the wire');
+  assert.equal(roles.artist.filed, 4, 'the ideas half reached the artist block');
+  assert.equal(roles.artist.pages_approved, 9, 'and so did the pages half');
+  assert.equal(roles.artist.credits, 412, 'the craft credits are the ledger split, both halves');
   seams._reset();
   const { roles: _fixture, ...rest } = ARTIST;
   const p = await boot({ ...rest, roles });
   assert.equal(p.sub, '', 'no sub-line (task 1004827)');
-  assert.match(text(p.head), /Artist, main role Ideator/);
-  assert.match(text(p.head), /412 credits 9 pages approved \+38 this week/);
+  assert.match(text(p.head), /Artist, main role Answerable for/);
+  assert.match(text(p.head), /412 credits 9 pages approved 4 thoughts filed/);
+  assert.match(text(p.nums), /412 credits pages and ideas/);
   assert.equal((p.nums.match(/kit-bars__row/g) || []).length, 3);
 });
 

package/tests/profile_role_stats.mjs

@@ -10,8 +10,9 @@
 // over the REAL page inventory, and economy's REAL fold of the ledger rows:
 //
 //   Ines Varga   an artist who has never shipped a task: pages and ideas only
-//   Tobi Rahn    an ideator who has never shipped a task: thoughts only
-//   Mara Okonkwo an engineer, who also earned a little from an idea
+//   Tobi Rahn    an artist (the old ideator, folded in by task 1005141) who has
+//                never shipped a task: thoughts only, no pages
+//   Mara Okonkwo an artisan, who also earned a little from an idea
 //
 // The SQL halves (which ledger rows the classification and the per-person
 // earnings reach) run against a real Postgres in tests/role_stats_db.mjs; here
@@ -40,29 +41,32 @@ async function t(name, fn) {
 
 const INES = 201; const TOBI = 202; const MARA = 203; const NEW = 204; const UI = 205; const LEA = 206;
 const ROWS = {
-  [INES]: { id: INES, github_login: 'ines', display_name: 'Ines Varga', total_credits: 312, karma: 0, rank: 'thetes', preferred_disciplines: ['artist', 'ideator'], main_discipline: null },
-  [TOBI]: { id: TOBI, github_login: 'tobi', display_name: 'Tobi Rahn', total_credits: 186, karma: 0, rank: 'thetes', preferred_disciplines: ['ideator'], main_discipline: null },
-  [MARA]: { id: MARA, github_login: 'mara', display_name: 'Mara Okonkwo', total_credits: 2480, karma: 118, rank: 'metic', preferred_disciplines: ['engineer', 'ideator'], main_discipline: 'engineer' },
+  [INES]: { id: INES, github_login: 'ines', display_name: 'Ines Varga', total_credits: 312, karma: 0, rank: 'thetes', preferred_disciplines: ['artist'], main_discipline: null },
+  [TOBI]: { id: TOBI, github_login: 'tobi', display_name: 'Tobi Rahn', total_credits: 186, karma: 0, rank: 'thetes', preferred_disciplines: ['artist'], main_discipline: null },
+  [MARA]: { id: MARA, github_login: 'mara', display_name: 'Mara Okonkwo', total_credits: 2480, karma: 118, rank: 'metic', preferred_disciplines: ['artisan', 'artist'], main_discipline: 'artisan' },
   [NEW]: { id: NEW, github_login: 'new', display_name: 'Newcomer', total_credits: 0, karma: 0, rank: 'xenos', preferred_disciplines: [], main_discipline: null },
-  [UI]: { id: UI, github_login: 'priya', display_name: 'Priya Das', total_credits: 60, karma: 0, rank: 'metic', preferred_disciplines: ['engineer', 'ui'], main_discipline: 'ui' },
+  [UI]: { id: UI, github_login: 'priya', display_name: 'Priya Das', total_credits: 60, karma: 0, rank: 'metic', preferred_disciplines: ['artisan', 'ui'], main_discipline: 'ui' },
   [LEA]: { id: LEA, github_login: 'lea', display_name: 'Lea Brandt', total_credits: 30, karma: 0, rank: 'thetes', preferred_disciplines: ['artist'], main_discipline: null },
 };
 const SHIPPED = { [INES]: 0, [TOBI]: 0, [MARA]: 64, [NEW]: 0, [UI]: 2, [LEA]: 0 };
 
 // What CREDITS_BY_CRAFT_SQL returns, grouped by (builder, discipline). Ines's
 // session reward was split across two tasks of different crafts, so her rows
-// arrive as halves; the fold has to make them exact again.
+// arrive as halves; the fold has to make them exact again. Her page credits
+// (120) and her idea credits (42) both count as artist money since task 1005141;
+// the statement tags the idea streams 'ideas' so the sky's idea total can still
+// read them alone (credits-by-craft.js IDEAS), so they arrive as two rows.
 const LEDGER_ROWS = [
   { builder_id: String(INES), discipline: 'artist', amount: 120 },
-  { builder_id: String(INES), discipline: 'ideator', amount: 42 },
-  { builder_id: String(INES), discipline: 'engineer', amount: 74.5 },
+  { builder_id: String(INES), discipline: 'ideas', amount: 42 },
+  { builder_id: String(INES), discipline: 'artisan', amount: 74.5 },
   { builder_id: String(INES), discipline: 'ui', amount: 74.5 },
   { builder_id: String(INES), discipline: 'other', amount: 1 },
-  { builder_id: String(TOBI), discipline: 'ideator', amount: 186 },
-  { builder_id: String(MARA), discipline: 'engineer', amount: 2460 },
-  { builder_id: String(MARA), discipline: 'ideator', amount: 20 },
+  { builder_id: String(TOBI), discipline: 'ideas', amount: 186 },
+  { builder_id: String(MARA), discipline: 'artisan', amount: 2460 },
+  { builder_id: String(MARA), discipline: 'ideas', amount: 20 },
   { builder_id: String(UI), discipline: 'ui', amount: 60 },
-  // a discipline nobody mapped yet counts as engineering, never vanishes
+  // a discipline nobody mapped yet counts as artisan work, never vanishes
   { builder_id: String(UI), discipline: 'some-module-craft', amount: 0 },
 ];
 
@@ -227,23 +231,26 @@ const profile = async (id) => {
 
 // ---- the artist who has never shipped a task --------------------------------
 
-await t('ARTIST, never shipped: leads with artist, by what she earned, and shows ideator beside it', async () => {
+await t('ARTIST, never shipped: leads with artist, by what she earned, and shows artisan beside it', async () => {
   const { json } = await profile(INES);
   assert.equal(json.shipped_count, 0, 'the fixture is the case the task names: no shipped task at all');
   const r = json.roles;
   assert.equal(r.main, 'artist');
   assert.equal(r.main_basis, 'earned', 'no main role chosen yet, so it is inferred and says so');
-  assert.deepEqual(r.shown, ['artist', 'ideator', 'engineer'],
-    'main first, then every craft she EARNED in, in her preferred order (her session reward was part engineering)');
-  assert.equal(r.engineer.shipped, 0);
+  assert.deepEqual(r.shown, ['artist', 'artisan'],
+    'main first, then every craft she EARNED in, ONCE each (her session reward was part artisan work)');
+  assert.equal(r.artisan.shipped, 0);
 });
 
-await t('ARTIST: pages approved, pages, N of M per surface, credits from pages and this week', async () => {
+await t('ARTIST: pages approved, pages, N of M per surface, the craft credits and this week', async () => {
   const a = (await profile(INES)).json.roles.artist;
   assert.equal(a.pages_approved, 4, 'four approved rounds, each one paid');
   assert.equal(a.pages, 3, 'on three distinct pages (one was tweaked twice)');
   assert.equal(a.surfaces_touched, 2);
-  assert.equal(a.credits, 120, 'credits from pages are the page rows only, not her other pay');
+  assert.equal(a.credits, 236, 'the artist craft ledger share: pages (120) + ideas (42) + the ui half of her session (74)');
+  assert.equal(a.size.paid, 42, 'her ideas total is her idea streams alone, never her page credits (task 1005141)');
+  assert.equal(a.filed, 4, 'and the same block carries her ideas (task 1005141)');
+  assert.equal(a.unavailable, false);
   assert.equal(a.this_week, 60, 'two approvals inside the trailing week');
   const landing = a.surfaces.find((s) => s.id === 'landing');
   const builders = a.surfaces.find((s) => s.id === 'builders');
@@ -258,30 +265,32 @@ await t('ARTIST: pages approved, pages, N of M per surface, credits from pages a
 
 await t('the credit split is exact: halves rounded by largest remainder, ui folded into artist', async () => {
   const c = (await profile(INES)).json.roles.credits_by_craft;
-  assert.deepEqual(c, { engineer: 75, artist: 194, ideator: 42, other: 1, total: 312 },
+  assert.deepEqual(c, { artisan: 75, artist: 236, other: 1, total: 312 },
     '74.5 + 74.5 must not round to 150 or 148; the parts equal the whole');
-  assert.equal(c.engineer + c.artist + c.ideator + c.other, c.total);
+  assert.equal(c.artisan + c.artist + c.other, c.total);
 });
 
-// ---- the ideator who has never shipped a task -------------------------------
+// ---- the artist who only files ideas, and has never shipped a task -----------
 
-await t('IDEATOR, never shipped: leads with ideator, shows nothing it did not earn', async () => {
+await t('IDEAS-ONLY ARTIST, never shipped: leads with artist, shows nothing it did not earn', async () => {
   const { json } = await profile(TOBI);
   assert.equal(json.shipped_count, 0);
-  assert.equal(json.roles.main, 'ideator');
-  assert.deepEqual(json.roles.shown, ['ideator']);
-  assert.equal(json.roles.engineer, null, 'no engineering block for someone with no engineering credit');
-  assert.equal(json.roles.artist, null);
+  assert.equal(json.roles.main, 'artist');
+  assert.deepEqual(json.roles.shown, ['artist']);
+  assert.equal(json.roles.artisan, null, 'no artisan block for someone with no artisan credit');
+  assert.equal(json.roles.ideator, undefined, 'there is no separate ideator craft any more');
+  assert.equal(json.roles.artist.pages_approved, 0, 'no pages approved is an answer, not a gap');
+  assert.equal(json.roles.artist.credits, 186, 'every one of them from ideas');
 });
 
-await t('IDEATOR: filed, ignited, Full Ideas, ratified, total size every stream + the estimate marker, still alive', async () => {
-  const i = (await profile(TOBI)).json.roles.ideator;
+await t('ARTIST ideas: filed, ignited, Full Ideas, ratified, total size every stream + the estimate marker, still alive', async () => {
+  const i = (await profile(TOBI)).json.roles.artist;
   assert.equal(i.filed, 8);
   assert.equal(i.ignited, 5, 'the five that were paid for work, a burned-out one included');
   assert.equal(i.full_ideas, 3);
   assert.equal(i.ratified, 1, 'the one the board carried');
   assert.deepEqual(i.size, { total: 196, paid: 186, estimated: 10, historical: true },
-    'the ledger ideator column (every stream) plus the historical estimate, marked');
+    'the ledger artist column (every idea stream: Tobi has no pages) plus the historical estimate, marked');
   const expected = (64 * 1 + 42 * 0.6 + 18 + 22 * 0 + 26 * 0.85) / (64 + 42 + 18 + 22 + 26);
   assert.ok(Math.abs(i.alive.share - expected) < 1e-9, `size-weighted live share, got ${i.alive.share}`);
   assert.equal(i.alive.has_work, true);
@@ -294,30 +303,31 @@ await t('the trail is read at the public rank, so a count never changes with who
   assert.deepEqual(skyCalls, [{ builderId: TOBI, viewerRank: 'xenos' }]);
 });
 
-// ---- the engineer ------------------------------------------------------------
+// ---- the artisan ------------------------------------------------------------
 
-await t('ENGINEER: unchanged headline (works shipped), chosen main role, a little ideator beside it', async () => {
+await t('ARTISAN: unchanged headline (works shipped), chosen main role, a little artist (one idea) beside it', async () => {
   const r = (await profile(MARA)).json.roles;
-  assert.equal(r.main, 'engineer');
+  assert.equal(r.main, 'artisan');
   assert.equal(r.main_basis, 'chosen');
-  assert.deepEqual(r.shown, ['engineer', 'ideator']);
-  assert.deepEqual(r.engineer, { shipped: 64, credits: 2460 });
-  assert.equal(r.artist, null, 'no page read for someone with no artist credit');
-  assert.equal(r.ideator.filed, 1);
-  assert.equal(r.ideator.size.paid, 20);
+  assert.deepEqual(r.shown, ['artisan', 'artist']);
+  assert.deepEqual(r.artisan, { shipped: 64, credits: 2460 });
+  assert.equal(r.artist.pages_approved, 0, 'her artist credit is an idea, so the page count is a true zero');
+  assert.equal(r.artist.credits, 20);
+  assert.equal(r.artist.filed, 1);
+  assert.equal(r.artist.size.paid, 20);
 });
 
 // ---- the fallbacks and the boundary ------------------------------------------
 
-await t('main role: a chosen ui reads as artist; nothing chosen and nothing earned is engineering, said to be a default', async () => {
+await t('main role: a chosen ui reads as artist; nothing chosen and nothing earned is artisan, said to be a default', async () => {
   const ui = (await profile(UI)).json.roles;
   assert.equal(ui.main, 'artist');
   assert.equal(ui.main_basis, 'chosen');
-  assert.deepEqual(ui.preferred, ['engineer', 'artist']);
+  assert.deepEqual(ui.preferred, ['artisan', 'artist']);
   const nobody = (await profile(NEW)).json.roles;
-  assert.equal(nobody.main, 'engineer');
+  assert.equal(nobody.main, 'artisan');
   assert.equal(nobody.main_basis, 'default');
-  assert.deepEqual(nobody.shown, ['engineer']);
+  assert.deepEqual(nobody.shown, ['artisan']);
   assert.equal(nobody.credits_by_craft.total, 0, 'zero credits is an answer, not a gap');
 });
 
@@ -336,8 +346,8 @@ await t('a missing port reads as unknown (null), never as zero', async () => {
   seams.registerProvider('reward', { getBuilderAchievements: async () => [], creditsByCraft: (ids) => creditsByCraftLib.creditsByCraft(ids, { client: ledgerClient }) });
   try {
     const r = (await profile(TOBI)).json.roles;
-    assert.equal(r.ideator.filed, null);
-    assert.equal(r.ideator.unavailable, true);
+    assert.equal(r.artist.filed, null);
+    assert.equal(r.artist.unavailable, true);
   } finally {
     seams.registerProvider('ideas.ideatorStats', ideasPort);
   }
@@ -354,7 +364,7 @@ await t('apportion hands out exactly the rounding left over, larger remainder fi
 await t('the ledger statement classifies by reason, splits the session reward and escapes the artist prefix', () => {
   const sql = creditsByCraftLib.CREDITS_BY_CRAFT_SQL;
   assert.match(sql, /cl\.reason LIKE \$2 THEN 'artist'/);
-  assert.match(sql, /idea\.credit\.%' OR cl\.reason = 'idea_promotion_bonus' THEN 'ideator'/);
+  assert.match(sql, /idea\.credit\.%' OR cl.reason = 'idea_promotion_bonus' THEN 'ideas'/);
   assert.match(sql, /GREATEST\(COALESCE\(cardinality\(sr\.task_ids\), 0\), 1\)/, 'an even split, and a session that shipped nothing still counts once');
   const last = ledgerSql[ledgerSql.length - 1];
   assert.equal(last.params[1], 'tweak.page\\_approved:%', 'the underscore is escaped, so it is not a LIKE wildcard');

package/tests/profile_rollup_consent.mjs

@@ -144,14 +144,14 @@ try {
   await q(
     `INSERT INTO platform_identity_builder_project_activity
        (client_id, github_id, credits, tasks_shipped, karma, rank_held, disciplines, last_active)
-     VALUES ($1, $6, 100, 5, 3, 'metic',  '{engineer,ui}', '2026-01-01T00:00:00Z'),
+     VALUES ($1, $6, 100, 5, 3, 'metic',  '{artisan,ui}',  '2026-01-01T00:00:00Z'),
             ($2, $6,  50, 2, 1, 'archon', '{artist}',      '2026-02-01T00:00:00Z'),
             ($3, $6,  25, 1, 0, NULL,     '{}',            '2026-03-01T00:00:00Z'),
             ($4, $6,   0, 0, 0, 'thetes', '{}',            '2025-12-01T00:00:00Z'),
             ($5, $6,   0, 0, 0, 'thetes', '{}',            '2025-12-01T00:00:00Z'),
-            ($1, $7,  60, 4, 2, 'metic',  '{engineer}',    '2026-01-01T00:00:00Z'),
-            ($1, $8,  10, 1, 0, 'xenos',  '{engineer}',    '2026-01-01T00:00:00Z'),
-            ($1, $9,  90, 3, 1, 'metic',  '{engineer}',    '2026-01-01T00:00:00Z')`,
+            ($1, $7,  60, 4, 2, 'metic',  '{artisan}',     '2026-01-01T00:00:00Z'),
+            ($1, $8,  10, 1, 0, 'xenos',  '{artisan}',     '2026-01-01T00:00:00Z'),
+            ($1, $9,  90, 3, 1, 'metic',  '{artisan}',     '2026-01-01T00:00:00Z')`,
     [...ALL_CLIENTS, ACTIVE, HIDDEN, PROV, LEGACY],
   );
 
@@ -170,7 +170,7 @@ try {
   const r = await pi.getRollupForBuilder(ACTIVE, { pool });
   assert.deepEqual(r.totals, { projects: 5, credits: 175, works_shipped: 8, karma: 4 });
   pass++; console.log('  ok - totals aggregate un-fanned across the builder\'s projects');
-  assert.deepEqual([...r.disciplines].sort(), ['artist', 'engineer', 'ui']);
+  assert.deepEqual([...r.disciplines].sort(), ['artisan', 'artist', 'ui']);
   pass++; console.log('  ok - disciplines are the deduped union');
   ok(new Date(r.last_active).toISOString() === '2026-03-01T00:00:00.000Z', 'last_active is the max');
   ok(r.projects.length === 1 && r.projects[0].name === 'Pub Proj', 'only the on-the-map Public project is named — unfeatured, and named anyway');
@@ -240,7 +240,7 @@ try {
   await pi.upsertActivity({
     clientId: PUB_CLIENT, githubId: LAZY, credits: 1,
     rank: 'Supreme Overlord',
-    disciplines: ['engineer', 42, 'x'.repeat(33), 'a', 'b', 'c', 'd', 'e', 'f', 'g'],
+    disciplines: ['artisan', 42, 'x'.repeat(33), 'a', 'b', 'c', 'd', 'e', 'f', 'g'],
   }, { pool });
   const { rows: [act] } = await q(
     `SELECT rank_held, disciplines FROM platform_identity_builder_project_activity
@@ -249,6 +249,19 @@ try {
   ok(act.disciplines.length <= 8 && act.disciplines.every((d) => d.length <= 32),
     'disciplines land validated + capped');
 
+  // 6 — a reporting instance on a core older than the craft rename (task 1005141) still
+  // sends engineer / ideator. They land as today's crafts, folded and deduped, so the hub
+  // never shows an old name beside the new one (task 1005193).
+  await pi.upsertActivity({
+    clientId: PUB_CLIENT, githubId: LAZY, credits: 1,
+    disciplines: ['engineer', 'artist', 'ideator', 'ui', 'artisan'],
+  }, { pool });
+  const { rows: [folded] } = await q(
+    `SELECT disciplines FROM platform_identity_builder_project_activity
+      WHERE client_id = $1 AND github_id = $2`, [PUB_CLIENT, LAZY]);
+  assert.deepEqual(folded.disciplines, ['artisan', 'artist', 'ui']);
+  pass++; console.log('  ok - old craft names from an older core are folded to today\'s on ingest');
+
   console.log(`\nprofile_rollup_consent.mjs: ${pass} passed`);
 } finally {
   await cleanup();

package/tests/profile_route.mjs

@@ -69,7 +69,7 @@ const FULL_ROW = {
   deactivated_at: null,
   reactivated_at: null,
   deactivated_reason: SECRET_REASON,
-  preferred_disciplines: ['engineer'],
+  preferred_disciplines: ['artisan'],
   system_role: 'superadmin',
   anthropic_email: SECRET_EMAIL,
   anthropic_user_id: SECRET_USER,
@@ -107,8 +107,8 @@ function stubPublicProfileExtras() {
     .map((r) => ({ name: r.name, origin: r.origin, rank_held: r.rank_held, recent_ships: [] }));
   return {
     totals: { projects: 2, credits: 150, works_shipped: 7, karma: 4 },
-    disciplines: ['engineer', 'ui'],
-    crafts: { artist: { pages_approved: 3, credits: 40 } },
+    disciplines: ['artisan', 'ui'],
+    crafts: { artist: { pages_approved: 3, filed: 2, full_ideas: null, ratified: null, credits: 40 } },
     last_active: '2026-08-01T00:00:00.000Z',
     projects: named,
     more_projects: CROSS_PROJECT_ROWS.length - named.length,
@@ -118,11 +118,11 @@ function stubPublicProfileExtras() {
 // crafts (task 1004440) is each craft's summed counts — always present, {} when
 // no project reported any — so it belongs in the exact list too.
 const CP_PUBLIC_KEYS = ['totals', 'disciplines', 'crafts', 'last_active', 'projects', 'more_projects'];
-// The only shape crafts may take: the three crafts, each a block of counts.
+// The only shape crafts may take: the two crafts, each a block of counts. The
+// artist block carries the pages AND the ideas (task 1005141 folded the ideator in).
 const CP_ROLE_FIELDS = {
-  engineer: ['credits', 'shipped'],
-  artist: ['credits', 'pages_approved'],
-  ideator: ['credits', 'filed', 'full_ideas', 'ratified'],
+  artisan: ['credits', 'shipped'],
+  artist: ['credits', 'filed', 'full_ideas', 'pages_approved', 'ratified'],
 };
 // recent_ships rides the project row (task 1002803) and is ALWAYS present —
 // getRollupForBuilder defaults it to [] — so it belongs in the exact key list.
@@ -139,7 +139,7 @@ function assertCrossProjectContract(cp, text) {
   assert.deepEqual(Object.keys(cp).sort(), [...CP_PUBLIC_KEYS].sort(), 'cross_project keys are exactly the contract');
   assert.deepEqual(Object.keys(cp.totals).sort(), ['credits', 'karma', 'projects', 'works_shipped']);
   for (const [craft, block] of Object.entries(cp.crafts)) {
-    assert.ok(CP_ROLE_FIELDS[craft], `crafts carries only the three crafts — found "${craft}"`);
+    assert.ok(CP_ROLE_FIELDS[craft], `crafts carries only the two crafts — found "${craft}"`);
     assert.deepEqual(Object.keys(block).sort(), CP_ROLE_FIELDS[craft], `${craft} carries only its named counts`);
     for (const v of Object.values(block)) assert.ok(v === null || Number.isInteger(v), 'a craft count is a number or null, never text');
   }
@@ -393,7 +393,7 @@ const SCOUTING_TABLE = [
   { profile_state: 'active', terms_accepted_at: ACCEPTED_AT, account_visibility: 'public', hide_stats: false,
     row: { github_id: '11', github_login: 'r06-visible', display_name: 'Visible', avatar_url: null,
       project_count: 2, total_credits: 5, total_tasks_shipped: 1, total_karma: 0,
-      last_active: '2026-08-01T00:00:00.000Z', disciplines: ['engineer'] } },
+      last_active: '2026-08-01T00:00:00.000Z', disciplines: ['artisan'] } },
   { profile_state: 'active', terms_accepted_at: ACCEPTED_AT, account_visibility: 'public', hide_stats: true,
     row: { github_id: '12', github_login: HIDDEN_LOGIN, display_name: 'Hidden', avatar_url: null,
       project_count: 7, total_credits: 88817, total_tasks_shipped: 6613, total_karma: 5519,
@@ -405,7 +405,7 @@ const SCOUTING_TABLE = [
   { profile_state: 'active', terms_accepted_at: ACCEPTED_AT, account_visibility: 'private', hide_stats: false,
     row: { github_id: '14', github_login: PRIVATE_LOGIN, display_name: 'Private', avatar_url: null,
       project_count: 3, total_credits: 63127, total_tasks_shipped: 4409, total_karma: 2287,
-      last_active: '2026-08-04T00:00:00.000Z', disciplines: ['engineer'] } },
+      last_active: '2026-08-04T00:00:00.000Z', disciplines: ['artisan'] } },
 ];
 
 const engine = {
@@ -458,7 +458,7 @@ const engine = {
     if (/AS works_shipped/.test(sql)) {
       return { rows: [{ projects: PROOF_PROJECTS.length, credits: sumOf('credits'),
         works_shipped: sumOf('tasks_shipped'), karma: sumOf('karma'),
-        last_active: '2026-08-02T00:00:00.000Z', disciplines: ['engineer', 'ui'] }] };
+        last_active: '2026-08-02T00:00:00.000Z', disciplines: ['artisan', 'ui'] }] };
     }
     throw new Error(`fake engine: unexpected query ${sql.slice(0, 60)}`);
   },
@@ -496,7 +496,7 @@ await t('R06.1 a two-project builder\'s COMBINED record shows to another account
   assert.equal(cp.totals.credits, sumOf('credits'), 'credits are the sum across BOTH projects');
   assert.equal(cp.totals.works_shipped, sumOf('tasks_shipped'), 'ships are summed across both');
   assert.equal(cp.totals.karma, sumOf('karma'), 'karma is summed across both');
-  assert.deepEqual(cp.disciplines, ['engineer', 'ui'], 'the disciplines union spans both projects');
+  assert.deepEqual(cp.disciplines, ['artisan', 'ui'], 'the disciplines union spans both projects');
   assert.equal(cp.projects.length, 1, 'only the Public project is NAMED — unfeatured, and named anyway');
   assert.equal(cp.projects[0].name, PROOF_PROJECTS[0].name);
   assert.equal(cp.more_projects, 1, 'the Private one is counted, never named — featured, and unnamed anyway');

package/tests/profile_ui_cross_project.mjs

@@ -37,12 +37,12 @@ const HTML = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/profile.htm
 const BUILDER = {
   id: 7, github_login: 'pheidias', display_name: 'Pheidias', avatar_url: null,
   rank: 'metic', total_credits: 120, karma: 3, created_at: '2026-01-01T00:00:00.000Z',
-  preferred_disciplines: ['engineer'],
+  preferred_disciplines: ['artisan'],
 };
 
 const CP_FULL = {
   totals: { projects: 3, credits: 150, works_shipped: 7, karma: 4 },
-  disciplines: ['engineer', 'ui'],
+  disciplines: ['artisan', 'ui'],
   last_active: '2026-08-01T00:00:00.000Z',
   projects: [
     { name: 'Public Proj', origin: 'https://pub.example', rank_held: 'metic' },
@@ -84,7 +84,7 @@ async function boot({ search = '', me, profile } = {}) {
       // 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,
@@ -172,7 +172,7 @@ test('full cross_project → tiles, named rows, plain-text standing, +N more', a
   assert.ok(!html.includes('rank-badge'), 'never the local rank-badge component for another project\'s rank (spec Decision 1)');
   assert.match(html, /\+ 1 more project/, 'non-public projects are counted, never named');
   // task 1003936: one word for the axis, and the values are named not slugged.
-  assert.match(html, /Roles: Engineer, UI/);
+  assert.match(html, /Roles: Artisan, UI/);
   assert.match(html, /Last active 2026-08-01/);
   assert.ok(!html.includes('/settings#cross-project'), 'no self link for a stranger');
 });

package/tests/project_invite_suggestions.mjs

@@ -34,8 +34,8 @@ function fakePool(rows) {
 }
 
 const BUILDERS = [
-  { github_id: 1, github_login: 'ada', display_name: 'Ada L', avatar_url: 'a.png', disciplines: ['engineer'], project_count: 3, total_tasks_shipped: 40, total_credits: 900 },
-  { github_id: 2, github_login: 'grace', display_name: 'Grace H', avatar_url: 'g.png', disciplines: ['engineer'], project_count: 2, total_tasks_shipped: 30, total_credits: 800 },
+  { github_id: 1, github_login: 'ada', display_name: 'Ada L', avatar_url: 'a.png', disciplines: ['artisan'], project_count: 3, total_tasks_shipped: 40, total_credits: 900 },
+  { github_id: 2, github_login: 'grace', display_name: 'Grace H', avatar_url: 'g.png', disciplines: ['artisan'], project_count: 2, total_tasks_shipped: 30, total_credits: 800 },
   { github_id: 3, github_login: 'linus', display_name: null, avatar_url: null, disciplines: null, project_count: 1, total_tasks_shipped: 10, total_credits: 100 },
 ];
 

package/tests/promote_goal_id.mjs

@@ -230,7 +230,7 @@ await test('BEHAVIOUR: a failed create throws with the status, it does not retur
 // The hall promote once sent no discipline, and an idea whose wording names no
 // craft was refused "discipline was not supplied and could not be inferred".
 await test('BOTH PATHS: the hall promote payload always sends a discipline', () => {
-  assert.match(HALL, /discipline: \(form\.discipline && form\.discipline\.value\) \|\| 'engineer'/,
+  assert.match(HALL, /discipline: \(form\.discipline && form\.discipline\.value\) \|\| 'artisan'/,
     'hall: discipline must reach the create payload, defaulting to engineer');
   assert.match(HALL, /<select name="discipline">/, 'hall: the promote form offers a Craft picker');
 });