@bongos/core 1.24.79 → 1.24.80

package/tests/publish_manifest.mjs

@@ -78,7 +78,7 @@ const PUBLISH = [
   'docs/project-context.template.md',      // the neutral scaffold (NOT the OTB-filled one)
   'config/design-tokens.schema.json',      // generic contract schema
   '.claude/skills/status/SKILL.md',
-  'docs/packs/engineer.md',                // the role packs the kernel/pack split moved the methodology into (task 1002990)
+  'docs/packs/artisan.md',                // the role packs the kernel/pack split moved the methodology into (task 1002990)
   'package.json',
   'Dockerfile',
   '.env.local.example',

package/tests/rank_floor_wiring.mjs

@@ -55,7 +55,7 @@ async function createdFloor({ scopeModules, needsMigration = false, requiresRank
     // Stated rather than inferred (task 1002988): createTask now refuses a craft it
     // cannot work out, and "a task" says nothing. This fixture is about the RANK
     // FLOOR, so it should not be at the mercy of the discipline heuristic.
-    discipline: 'engineer',
+    discipline: 'artisan',
     goalId: '1000111',
     needsMigration,
     requiresRank,

package/tests/regrade_actual_minutes.mjs

@@ -43,7 +43,7 @@ const TASK = {
   id: 1003964,
   title: 'A re-graded task keeps the first attempt figure',
   kind: 'bug',
-  discipline: 'engineer',
+  discipline: 'artisan',
   est_minutes: 60,
   actual_minutes: 31337,
   scoping_confidence: 4,

package/tests/removal_proposal.mjs

@@ -439,7 +439,7 @@ await test('the generated task is a backlog REQUEST carrying the preamble', () =
   assert.equal(spec.source, cascade.CASCADE_SOURCE);
   assert.match(spec.description, /it is a REQUEST/);
   assert.match(spec.description, /task 1003944/);
-  assert.equal(spec.discipline, 'engineer');
+  assert.equal(spec.discipline, 'artisan');
 });
 
 await test('cascadesFor threads ctx into the body, not just the predicate', () => {
@@ -503,7 +503,7 @@ await test('nothing in the proposal path changes a status or a credit', () => {
 
 const shippedTask = (over = {}) => ({
   id: '7002', version_id: 'BONGOS-V2', goal_id: '1000095',
-  title: 'Delete the old scorer', discipline: 'engineer',
+  title: 'Delete the old scorer', discipline: 'artisan',
   kind: 'feature', status: 'shipped', source: 'manual', ...over,
 });
 

package/tests/reward_gate.mjs

@@ -224,7 +224,7 @@ async function withStubbedCreatePool(run) {
 
 t('a task CREATED with NO reward is born with a positive, capped value', async () => {
   await withStubbedCreatePool(async (captured) => {
-    const row = await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'engineer', kind: 'feature', estMinutes: 40 });
+    const row = await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'artisan', kind: 'feature', estMinutes: 40 });
     assert.ok(captured.creditsReward > 0, 'INSERT must bind a positive credits_reward');
     assert.equal(captured.creditsReward, 40, 'feature @40min -> 40 drachmae');
     assert.ok(captured.creditsReward <= db.REWARD_SUGGESTION_CAP, 'must respect the cap');
@@ -234,7 +234,7 @@ t('a task CREATED with NO reward is born with a positive, capped value', async (
 
 t('a task CREATED with credits_reward 0 (the route default) is auto-assigned', async () => {
   await withStubbedCreatePool(async (captured) => {
-    await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'engineer', creditsReward: 0, kind: 'bug', estMinutes: 40 });
+    await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'artisan', creditsReward: 0, kind: 'bug', estMinutes: 40 });
     // bug weight 1.25 -> 50; 0 is treated as "unset" so the default kicks in.
     assert.equal(captured.creditsReward, 50);
   });
@@ -242,14 +242,14 @@ t('a task CREATED with credits_reward 0 (the route default) is auto-assigned', a
 
 t('a huge-est new task is CAPPED at creation, not ballooned', async () => {
   await withStubbedCreatePool(async (captured) => {
-    await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'engineer', kind: 'feature', estMinutes: 9999 });
+    await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'artisan', kind: 'feature', estMinutes: 9999 });
     assert.equal(captured.creditsReward, db.REWARD_SUGGESTION_CAP);
   });
 });
 
 t('an EXPLICIT positive credits_reward is PRESERVED (never overridden)', async () => {
   await withStubbedCreatePool(async (captured) => {
-    await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'engineer', creditsReward: 17, kind: 'feature', estMinutes: 40 });
+    await db.createTask({ versionId: 1, goalId: 77, title: 't', discipline: 'artisan', creditsReward: 17, kind: 'feature', estMinutes: 40 });
     assert.equal(captured.creditsReward, 17, 'author-set positive value must survive untouched');
   });
 });

package/tests/reward_mode_cost_plus_only.mjs

@@ -80,7 +80,7 @@ try {
   await q(`INSERT INTO builders (id,github_id,github_login,display_name,rank) VALUES ($1,'rm-w','rm-worker','RM Worker','archon')`, [WORKER]);
   // A confirmed task owned by WORKER with a real estimate. In DEFAULT mode this
   // would pay 60 × 1.0 (feature) at ship; in cost-plus-only it must pay nothing.
-  await q(`INSERT INTO tasks (id,version_id,title,status,credits_reward,kind,shipped_by,discipline) VALUES ($1,$2,'rm task','confirmed',60,'feature',$3,'engineer')`, [TASK, VER, WORKER]);
+  await q(`INSERT INTO tasks (id,version_id,title,status,credits_reward,kind,shipped_by,discipline) VALUES ($1,$2,'rm task','confirmed',60,'feature',$3,'artisan')`, [TASK, VER, WORKER]);
   await q(`INSERT INTO claims (task_id,builder_id,claimed_at) VALUES ($1,$2, now())`, [TASK, WORKER]);
 
   // Drive the REAL ship transition (the same call the reconciler/ship.js use).

package/tests/role_responsibilities.mjs

@@ -39,21 +39,27 @@ function test(name, fn) {
 
 // --- the source ---------------------------------------------------------
 
-// The owner's sentences, verbatim from criterion wa6-written-responsibilities.
-// Duplicated here deliberately — a test that read the value it is checking would
-// assert nothing. This copy is the fixture; the source file is the subject.
+// The owner's sentences, verbatim from criterion wa6-written-responsibilities,
+// as carried through the BONGOS-V3 craft rename (task 1005141): the engineer is the
+// ARTISAN, and the ideator folded into the ARTIST, so the artist's statement is the
+// old artist sentence followed by the old ideator sentence. Only craft NAMES moved
+// ("Ideators and Artists" → "Artists", "Engineers" → "Artisans"); every other
+// word is the owner's. Duplicated here deliberately — a test that read the value it
+// is checking would assert nothing. This copy is the fixture; the source file is
+// the subject.
 const OWNER_TEXT = {
-  engineer: 'Running and optimizing the running of Claude nonstop, and ensuring Ideators and Artists can continue to interface with that system effectively.',
-  artist: 'No slop in the appearance and text of the project; the story, emotion and ideology of the project are communicated effectively; project purpose and gravitas are upheld.',
-  ideator: 'Make good ideas; be a philosopher / thought leader for the project; enable Engineers to scope and Artists to create with maximum efficiency — a baseline for creating scopes of work.',
+  artisan: 'Running and optimizing the running of Claude nonstop, and ensuring Artists can continue to interface with that system effectively.',
+  artist: 'No slop in the appearance and text of the project; the story, emotion and ideology of the project are communicated effectively; project purpose and gravitas are upheld.'
+    + ' Make good ideas; be a philosopher / thought leader for the project; enable Artisans to scope and Artists to create with maximum efficiency — a baseline for creating scopes of work.',
 };
 
-test('the three statements are the owner\'s text, character for character', () => {
+test('the two statements are the owner\'s text, character for character', () => {
   assert.deepEqual({ ...src.ROLE_RESPONSIBILITIES }, OWNER_TEXT);
 });
 
-test('exactly the three CORE crafts carry a statement — no more, no fewer', () => {
-  assert.deepEqual(Object.keys(src.ROLE_RESPONSIBILITIES), ['engineer', 'artist', 'ideator']);
+test('exactly the two CORE crafts carry a statement — no more, no fewer', () => {
+  assert.deepEqual(Object.keys(src.ROLE_RESPONSIBILITIES), ['artisan', 'artist']);
+  assert.equal(src.responsibilityFor('ideator'), null, 'there is no ideator statement: it lives in the artist\'s');
   // Governor is deferred (ADR 0274) and `ui` is module-contributed (ADR 0272):
   // inventing a sentence for either is the paraphrase this task forbids.
   assert.equal(src.responsibilityFor('ui'), null);
@@ -65,7 +71,7 @@ test('the map is frozen — a consumer cannot edit the standard at runtime', ()
 });
 
 test('responsibilityFor: case-insensitive, and absence is null not a placeholder', () => {
-  assert.equal(src.responsibilityFor('ENGINEER'), OWNER_TEXT.engineer);
+  assert.equal(src.responsibilityFor('ARTISAN'), OWNER_TEXT.artisan);
   for (const bad of [null, undefined, '', 'unclassified', 42, {}]) {
     assert.equal(src.responsibilityFor(bad), null, `${JSON.stringify(bad)} must be null`);
   }
@@ -157,9 +163,9 @@ test('no consumer hardcodes a statement — the packs\' generated blocks are the
   // criterion record, or this fixture is a second copy that can drift.
   const ALLOWED = new Set([
     'src/role-responsibilities.js',   // the source
-    'docs/packs/engineer.md',         // generated blocks
+    'docs/packs/artisan.md',         // generated blocks
+    'docs/packs/artist.md',
     'docs/packs/artist.md',
-    'docs/packs/ideator.md',
     'tests/role_responsibilities.mjs', // this fixture
   ]);
   const scan = ['src', 'scripts', 'modules', 'tests', 'docs/packs'];

package/tests/role_stats_db.mjs

@@ -102,7 +102,7 @@ async function fixture() {
   const other = await insertRow('builders', { github_id: `${tag}-gh2`, github_login: `${tag}-2`, display_name: `${tag}-2`, total_credits: 0 });
   const version = await insertRow('versions', { id: `${tag}-v`, status: 'building' });
   const mk = (title, discipline) => insertRow('tasks', { title: `${tag} ${title}`, status: 'shipped', version_id: version.id, discipline });
-  const eng = await mk('eng', 'engineer');
+  const eng = await mk('eng', 'artisan');
   const page = await mk('page', 'artist');
   const ui = await mk('ui', 'ui');
   const sid = `${tag}-session`;
@@ -139,23 +139,24 @@ async function main() {
     await test('credits by craft: every reason lands in its craft and the parts sum to the ledger exactly', async () => {
       const map = await byCraft.creditsByCraft([f.b.id], { client });
       const row = map.get(String(f.b.id));
-      // engineer: 10 shipped + half of the 9 session + the 3 lone session = 17.5
-      // artist:   30 page + the ui half of the session (4.5)               = 34.5
-      // ideator:  4 stream 1 + 5 full pass                                 = 9
+      // artisan: 10 shipped + half of the 9 session + the 3 lone session = 17.5
+      // artist:   30 page + the ui half of the session (4.5)
+      //           + the idea streams the old ideator craft held
+      //             (4 stream 1 + 5 full pass), folded in by task 1005141  = 43.5
       // other:    2 achievement + 7 wildcard twin                          = 9
-      assert.equal(row.ideator, 9);
       assert.equal(row.other, 9);
       assert.equal(row.total, 70);
-      assert.equal(row.engineer + row.artist + row.ideator + row.other, row.total, 'the parts are exact to the whole');
-      // 17.5 and 34.5 floor to 51 of 52; the one left over goes to the larger
-      // remainder, and on a tie to the earlier craft, engineer.
-      assert.equal(row.engineer, 18);
-      assert.equal(row.artist, 34);
+      assert.equal(row.artisan + row.artist + row.other, row.total, 'the parts are exact to the whole');
+      // 17.5 and 43.5 floor to 60 of 61; the one left over goes to the larger
+      // remainder, and on a tie to the earlier craft, artisan.
+      assert.equal(row.artisan, 18);
+      assert.equal(row.artist, 43);
+      assert.equal(row.ideas, 9, 'the idea credits are still told apart inside the artist craft');
     });
 
     await test('credits by craft: another builder on the same task is never counted', async () => {
       const map = await byCraft.creditsByCraft([f.other.id], { client });
-      assert.equal(map.get(String(f.other.id)).engineer, 50);
+      assert.equal(map.get(String(f.other.id)).artisan, 50);
       assert.equal(map.get(String(f.other.id)).total, 50);
     });
 
@@ -177,11 +178,11 @@ async function main() {
       const { UPDATE_BUILDER_DISCIPLINES_SQL: sql } = require('../src/bongos/db.js');
       const run = async (list, setMain, main) =>
         (await client.query(sql, [f.b.id, list, setMain, main])).rows[0].main_discipline;
-      assert.equal(await run(['engineer', 'artist'], true, 'artist'), 'artist', 'chosen');
-      assert.equal(await run(['engineer', 'artist', 'ideator'], false, null), 'artist', 'not mentioned, still one of the crafts: kept');
-      assert.equal(await run(['engineer'], false, null), null, 'the craft was dropped: a main role they no longer practise is cleared');
-      assert.equal(await run(['engineer'], true, 'engineer'), 'engineer');
-      assert.equal(await run(['engineer'], true, null), null, 'cleared on purpose');
+      assert.equal(await run(['artisan', 'artist'], true, 'artist'), 'artist', 'chosen');
+      assert.equal(await run(['artisan', 'artist', 'artist'], false, null), 'artist', 'not mentioned, still one of the crafts: kept');
+      assert.equal(await run(['artisan'], false, null), null, 'the craft was dropped: a main role they no longer practise is cleared');
+      assert.equal(await run(['artisan'], true, 'artisan'), 'artisan');
+      assert.equal(await run(['artisan'], true, null), null, 'cleared on purpose');
     });
 
     await test('artist page read: only rounds whose LATEST web claim is theirs, never a CLI claim, never an ordinary task', async () => {

package/tests/scouting_rollup_fanout.mjs

@@ -82,9 +82,9 @@ try {
   await q(
     `INSERT INTO platform_identity_builder_project_activity
        (client_id, github_id, credits, tasks_shipped, karma, disciplines, last_active)
-     VALUES ($1, $3, 100, 5, 3, '{engineer,ui}',        '2026-01-01T00:00:00Z'),
-            ($2, $3,  50, 2, 1, '{artist,engineer,ui}', '2026-02-01T00:00:00Z'),
-            ($1, $4,  60, 4, 2, '{engineer}',           '2026-03-01T00:00:00Z'),
+     VALUES ($1, $3, 100, 5, 3, '{artisan,ui}',         '2026-01-01T00:00:00Z'),
+            ($2, $3,  50, 2, 1, '{artist,artisan,ui}',  '2026-02-01T00:00:00Z'),
+            ($1, $4,  60, 4, 2, '{artisan}',            '2026-03-01T00:00:00Z'),
             ($2, $5,  10, 1, 0, '{}',                   '2026-04-01T00:00:00Z')`,
     [...CLIENTS, MULTI, SOLO, GHOST],
   );
@@ -99,14 +99,14 @@ try {
   ok(m.total_tasks_shipped === 7, `total_tasks_shipped is 5+2=7 (got ${m.total_tasks_shipped})`);
   ok(m.total_karma === 4, `total_karma is 3+1=4 (got ${m.total_karma})`);
   ok(new Date(m.last_active).toISOString() === '2026-02-01T00:00:00.000Z', 'last_active is the max across projects');
-  assert.deepEqual([...m.disciplines].sort(), ['artist', 'engineer', 'ui']);
+  assert.deepEqual([...m.disciplines].sort(), ['artisan', 'artist', 'ui']);
   pass++; console.log('  ok - disciplines are the deduped union across projects');
   ok(m.github_login === 'multi', 'account display fields join through');
 
   const s = by[SOLO];
   ok(s.project_count === 1 && s.total_credits === 60 && s.total_tasks_shipped === 4 && s.total_karma === 2,
     'single-discipline builder totals are unchanged');
-  assert.deepEqual(s.disciplines, ['engineer']);
+  assert.deepEqual(s.disciplines, ['artisan']);
   pass++; console.log('  ok - single discipline survives as a one-element array');
 
   const g = by[GHOST];

package/tests/seed_tasks.mjs

@@ -31,6 +31,9 @@ const FIX = path.join(ROOT, 'tests/fixtures/seed-tasks');
 const { validateSpec, seedTasks } = require(SEEDER);
 
 // spec fixture -> the old script it replaced, and the sha256 of that script's write log.
+// These fixtures are HISTORY and keep the pre-1005141 craft spellings ('engineer',
+// 'ideator') on purpose: rewriting them moves the hash. seed-tasks.js passes
+// discipline through verbatim; the task-write route normalizes an old spelling.
 const HISTORICAL = [
   { spec: 'bongos-v1-idea-routing.json', old: 'seed-bongos-v1-idea-routing-tasks.js', hash: 'f5bc176890077a62754812cf69666bd49ba0da441dafa84702e1883156c302f8' },
   { spec: 'bv1-profiles.json', old: 'seed-bv1-profiles-tasks.js', hash: 'cf81ee14131a20fe5a07c05b7c5fe3362bc940d5c5592031ad911b709db129a7' },
@@ -111,8 +114,8 @@ await test('an invalid spec is refused before any write', async () => {
 const base = () => ({
   version_id: 'V', goal_id: 7, source_ref_prefix: 'p',
   tasks: [
-    { ref: 'R1', title: 't1', description: 'd', kind: 'feature', discipline: 'engineer', priority: 3, criterion_ids: ['slug-a'] },
-    { ref: 'R2', title: 't2', description: 'd', kind: 'verify', discipline: 'engineer', priority: 3, criterion_ids: ['slug-a'], deps: ['R1'] },
+    { ref: 'R1', title: 't1', description: 'd', kind: 'feature', discipline: 'artisan', priority: 3, criterion_ids: ['slug-a'] },
+    { ref: 'R2', title: 't2', description: 'd', kind: 'verify', discipline: 'artisan', priority: 3, criterion_ids: ['slug-a'], deps: ['R1'] },
   ],
 });
 

package/tests/session_earnings_mirror_db.mjs

@@ -126,7 +126,7 @@ async function fixture(client) {
     status: 'shipped',
     version_id: version.id,
     // Named, not placeholder-filled: tasks_discipline_check admits only the live crafts.
-    discipline: 'engineer',
+    discipline: 'artisan',
   });
   const sessionId = `${tag}-session`;
   await insertRow(client, 'session_records', {

package/tests/session_reward_on_land_db.mjs

@@ -61,7 +61,7 @@ await test('real-DB: fixture setup', async () => {
     [ctx.versionId, `V ${suffix}`]
   );
   const tk = await pool.query(
-    `INSERT INTO tasks (version_id, title, status, discipline) VALUES ($1,$2,'shipped','engineer') RETURNING id`,
+    `INSERT INTO tasks (version_id, title, status, discipline) VALUES ($1,$2,'shipped','artisan') RETURNING id`,
     [ctx.versionId, `shipped task ${suffix}`]
   );
   ctx.taskId = Number(tk.rows[0].id);

package/tests/session_reward_reconcile_db.mjs

@@ -61,12 +61,12 @@ await test('real-DB: fixture setup', async () => {
     [ctx.versionId, `V ${suffix}`]
   );
   const shipped = await pool.query(
-    `INSERT INTO tasks (version_id, title, status, discipline) VALUES ($1,$2,'shipped','engineer') RETURNING id`,
+    `INSERT INTO tasks (version_id, title, status, discipline) VALUES ($1,$2,'shipped','artisan') RETURNING id`,
     [ctx.versionId, `shipped ${suffix}`]
   );
   ctx.shippedTaskId = Number(shipped.rows[0].id);
   const confirmed = await pool.query(
-    `INSERT INTO tasks (version_id, title, status, discipline) VALUES ($1,$2,'confirmed','engineer') RETURNING id`,
+    `INSERT INTO tasks (version_id, title, status, discipline) VALUES ($1,$2,'confirmed','artisan') RETURNING id`,
     [ctx.versionId, `confirmed ${suffix}`]
   );
   ctx.confirmedTaskId = Number(confirmed.rows[0].id);

package/tests/sessions_kit_pager.mjs

@@ -123,7 +123,7 @@ function harness({ total = 320, failAfter = null, viewerRank = 'metic', perPageP
       // 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),

package/tests/settings_art_key_absent.mjs

@@ -52,7 +52,7 @@ async function boot(artKeyStatus) {
   // The markup ships both hidden (settings.html), so the stub starts them hidden.
   $('#art-key').hidden = true;
   $('#artkey-banner').hidden = true;
-  const builder = { id: 4, github_login: 'b4', rank: 'thetes', preferred_disciplines: ['engineer'] };
+  const builder = { id: 4, github_login: 'b4', rank: 'thetes', preferred_disciplines: ['artisan'] };
   const me = { builder, needs: { items: [needs.artKeyNeed({ rank: 'thetes' })] } };
   const api = {
     async request(method, url) {
@@ -74,7 +74,7 @@ async function boot(artKeyStatus) {
     __BRANDING__: {}, __MODULES__: { enabled: {} },
     BongosClient: { createClient: () => api },
     OTB: {
-      $, escapeHtml, toast() {}, disciplines: () => ['engineer'], roleLabel: (d) => d,
+      $, escapeHtml, toast() {}, disciplines: () => ['artisan'], roleLabel: (d) => d,
       hubOrigin: () => null, settingsPanels: () => [],
     },
     OTBKit: { emptyStateHtml: (m) => m, makeSectionRail: () => ({ refresh() {}, activate() {} }) },

package/tests/settings_main_role.mjs

@@ -33,7 +33,8 @@ async function t(name, fn) {
   catch (e) { failed++; console.error(`  FAIL ${name}\n       ${e.message}`); }
 }
 
-const DISCIPLINES = ['engineer', 'artist', 'ideator', 'ui'];
+// The two core crafts since task 1005141 (the ideator folded into the artist), plus ui.
+const DISCIPLINES = ['artisan', 'artist', 'ui'];
 
 // A permissive element: everything settings.js touches at boot, with listeners
 // recorded so a test can fire them.
@@ -120,7 +121,7 @@ async function boot({ builder }) {
   return { $, options, checked, toggleRole, pickMain, save, patches };
 }
 
-const B = (over = {}) => ({ id: 4, github_login: 'b4', display_name: 'Builder 4', preferred_disciplines: ['engineer', 'ideator'], main_discipline: null, ...over });
+const B = (over = {}) => ({ id: 4, github_login: 'b4', display_name: 'Builder 4', preferred_disciplines: ['artisan', 'artist'], main_discipline: null, ...over });
 
 console.log('\nthe main-role picker:');
 
@@ -139,39 +140,39 @@ await t('GET /me carries the saved main role (getBuilderById selects the column)
 
 await t('options are "Let my work decide" plus exactly the ticked roles; nothing saved → by work', async () => {
   const p = await boot({ builder: B() });
-  assert.deepEqual(p.options().map((o) => o.value), ['', 'engineer', 'ideator']);
+  assert.deepEqual(p.options().map((o) => o.value), ['', 'artisan', 'artist']);
   assert.equal(p.options()[0].label, 'Let my work decide');
-  assert.deepEqual(p.options().map((o) => o.label).slice(1), ['Engineer', 'Ideator']);
+  assert.deepEqual(p.options().map((o) => o.label).slice(1), ['Artisan', 'Artist']);
   assert.equal(p.checked(), '', 'no saved main role → "Let my work decide" is chosen');
 });
 
 await t('a saved main role is the one chosen on load', async () => {
-  const p = await boot({ builder: B({ main_discipline: 'ideator' }) });
-  assert.equal(p.checked(), 'ideator');
+  const p = await boot({ builder: B({ main_discipline: 'artist' }) });
+  assert.equal(p.checked(), 'artist');
 });
 
 await t('ticking a role adds its option; unticking the MAIN role hands the choice back to your work', async () => {
-  const p = await boot({ builder: B({ main_discipline: 'ideator' }) });
-  p.toggleRole('artist', true);
-  assert.deepEqual(p.options().map((o) => o.value), ['', 'engineer', 'artist', 'ideator'], 'in the instance\'s role order');
-  assert.equal(p.checked(), 'ideator', 'adding a role keeps the pick');
-  p.toggleRole('ideator', false);
-  assert.deepEqual(p.options().map((o) => o.value), ['', 'engineer', 'artist']);
+  const p = await boot({ builder: B({ main_discipline: 'artist' }) });
+  p.toggleRole('ui', true);
+  assert.deepEqual(p.options().map((o) => o.value), ['', 'artisan', 'artist', 'ui'], 'in the instance\'s role order');
+  assert.equal(p.checked(), 'artist', 'adding a role keeps the pick');
+  p.toggleRole('artist', false);
+  assert.deepEqual(p.options().map((o) => o.value), ['', 'artisan', 'ui']);
   assert.equal(p.checked(), '', 'a role you no longer have cannot lead');
 });
 
 await t('Save sends the pick in the same PATCH, and the echo re-seeds it', async () => {
   const p = await boot({ builder: B() });
-  p.pickMain('ideator');
+  p.pickMain('artist');
   await p.save();
   assert.equal(p.patches.length, 1);
-  assert.deepEqual(JSON.parse(JSON.stringify(p.patches[0])), { preferred_disciplines: ['engineer', 'ideator'], main_discipline: 'ideator' });
-  assert.equal(p.checked(), 'ideator', 'the server\'s echo is what the control shows after saving');
-  assert.match(p.$('#craft-status').textContent, /Main role: Ideator\./);
+  assert.deepEqual(JSON.parse(JSON.stringify(p.patches[0])), { preferred_disciplines: ['artisan', 'artist'], main_discipline: 'artist' });
+  assert.equal(p.checked(), 'artist', 'the server\'s echo is what the control shows after saving');
+  assert.match(p.$('#craft-status').textContent, /Main role: Artist\./);
 });
 
 await t('"Let my work decide" saves null, which clears a saved main role', async () => {
-  const p = await boot({ builder: B({ main_discipline: 'engineer' }) });
+  const p = await boot({ builder: B({ main_discipline: 'artisan' }) });
   p.pickMain('');
   await p.save();
   assert.equal(p.patches[0].main_discipline, null);
@@ -180,10 +181,10 @@ await t('"Let my work decide" saves null, which clears a saved main role', async
 });
 
 await t('unticking the main role, then saving, sends null — never a role outside the set', async () => {
-  const p = await boot({ builder: B({ main_discipline: 'ideator' }) });
-  p.toggleRole('ideator', false);
+  const p = await boot({ builder: B({ main_discipline: 'artist' }) });
+  p.toggleRole('artist', false);
   await p.save();
-  assert.deepEqual(JSON.parse(JSON.stringify(p.patches[0])), { preferred_disciplines: ['engineer'], main_discipline: null });
+  assert.deepEqual(JSON.parse(JSON.stringify(p.patches[0])), { preferred_disciplines: ['artisan'], main_discipline: null });
 });
 
 console.log(`\n${passed} passed, ${failed} failed`);

package/tests/setup_flow.mjs

@@ -77,7 +77,7 @@ function bootGate({ patchOk = true } = {}) {
     activeElement: null,
   };
   // the crafts this project offers (dom-utils.js reads them off __MODULES__)
-  const window = { OTB: { ...realOTB(), disciplines: () => ['engineer', 'artist', 'ui'] }, location: { reload: () => { reloaded += 1; } } };
+  const window = { OTB: { ...realOTB(), disciplines: () => ['artisan', 'artist', 'ui'] }, location: { reload: () => { reloaded += 1; } } };
   const sandbox = { window, document, setInterval: (fn) => { intervals.push(fn); return intervals.length; }, clearInterval() {} };
   vm.createContext(sandbox);
   vm.runInContext(GATE, sandbox, { filename: 'setup-gate.js' });
@@ -104,7 +104,7 @@ await t('the screen lists every step in order, ticks the cleared ones, and opens
   assert.deepEqual(steps.map((s) => s.className), ['setup-gate__step is-done', 'setup-gate__step is-done', 'setup-gate__step is-current', 'setup-gate__step']);
   assert.match(steps[2].textContent, /Hint pick_disciplines/, 'only the current step shows its hint');
   assert.doesNotMatch(steps[3].textContent, /Hint first_start/);
-  assert.deepEqual(gate.querySelectorAll('[data-craft]').map((b) => b.textContent), ['Engineer', 'Artist', 'UI'],
+  assert.deepEqual(gate.querySelectorAll('[data-craft]').map((b) => b.textContent), ['Artisan', 'Artist', 'UI'],
     'the crafts this project offers');
 });
 
@@ -128,7 +128,7 @@ await t('choosing a craft saves it through PATCH /me/disciplines, the route ever
 await t('a craft that does not save says so and can be tried again', async () => {
   const g = bootGate({ patchOk: false });
   g.show({ complete: false, steps: STEPS(['signed_in', 'cli_setup']) });
-  g.click(g.gate().querySelector('[data-craft="engineer"]'));
+  g.click(g.gate().querySelector('[data-craft="artisan"]'));
   g.click(g.gate().querySelector('[data-save-crafts]'));
   await settle();
   const err = g.gate().querySelector('[data-craft-err]');

package/tests/setup_smoke.mjs

@@ -145,6 +145,26 @@ test('--dry-run respects a pre-existing valid-looking session in HOME', () => {
   }
 });
 
+// Setup asks for no API key (task 1005189). It used to stop every new builder at
+// a Google AI Studio key question, on every project — including ones with no art
+// pipeline, and agent-run setups where nobody can type an answer. The dry-run
+// plan is the half a spawn can see; the source check covers the prompt itself,
+// which only ever ran on a TTY.
+test('setup asks for no API key — not in the plan, not in either script', () => {
+  const fakeHome = fs.mkdtempSync(path.join(os.tmpdir(), 'otb-setup-smoke-'));
+  try {
+    const r = runSetup(['--dry-run', '--skip-keys'], { HOME: fakeHome });
+    assert.equal(r.status, 0, `--skip-keys must still be accepted; stderr: ${r.stderr}`);
+    assert.doesNotMatch(r.stdout, /gemini|ai studio|GOOGLE_AI_STUDIO_KEY/i, 'the dry-run plan must not list a key step');
+  } finally {
+    fs.rmSync(fakeHome, { recursive: true, force: true });
+  }
+  for (const rel of ['scripts/bongos/setup.js', 'scripts/setup-builder.js']) {
+    const src = fs.readFileSync(path.join(REPO_ROOT, rel), 'utf8');
+    assert.doesNotMatch(src, /GOOGLE_AI_STUDIO_KEY|aistudio\.google\.com/, `${rel} must not ask for or print anything about an image key`);
+  }
+});
+
 // ---- runner ----
 
 let failed = 0;

package/tests/ship_card.mjs

@@ -225,7 +225,7 @@ test('claimed: neutral tone, scope rows, discipline action, brief in dropdown',
   const m = card.buildCardModel({
     stage: 'claimed', taskId: 1275, title: 'Lifecycle card', brand: BRAND,
     description: 'Extend the card to every stage.',
-    estMinutes: 120, touchesCount: 4, version: 'GDS-V4', kind: 'feature', priority: 2, discipline: 'engineer',
+    estMinutes: 120, touchesCount: 4, version: 'GDS-V4', kind: 'feature', priority: 2, discipline: 'artisan',
   });
   assert.equal(m.stage, 'claimed');
   assert.equal(m.cfg.tone, 'neutral');
@@ -233,7 +233,7 @@ test('claimed: neutral tone, scope rows, discipline action, brief in dropdown',
   assert.equal(row(m, 'Estimate'), '~2h');
   assert.equal(row(m, 'Touches'), '4 files');
   assert.equal(row(m, 'Value'), undefined); // no value summary pre-work
-  assert.equal(m.action.cmd, 'Read docs/packs/engineer.md and start the work');
+  assert.equal(m.action.cmd, 'Read docs/packs/artisan.md and start the work');
   const html = card.renderCardHtml(m);
   assert.match(html, /Extend the card to every stage\./); // brief in dropdown
 });
@@ -246,13 +246,13 @@ test('claimed: neutral tone, scope rows, discipline action, brief in dropdown',
 test('claimed action routes by discipline — core crafts to their pack, modules to their skill', () => {
   const cmdFor = (discipline) => card.buildCardModel({ stage: 'claimed', taskId: 1, discipline, brand: BRAND }).action.cmd;
   assert.equal(cmdFor('artist'), 'Read docs/packs/artist.md and start the work');
-  assert.equal(cmdFor('ideator'), 'Read docs/packs/ideator.md and start the work');
+  assert.equal(cmdFor('artist'), 'Read docs/packs/artist.md and start the work');
   assert.equal(cmdFor('ui'), '/design');
   // An unknown or unset discipline falls back to the Engineer pack, exactly as it
   // used to fall back to /dev — engineering is the project's default loop.
-  assert.equal(cmdFor('unclassified'), 'Read docs/packs/engineer.md and start the work');
-  assert.equal(cmdFor(undefined), 'Read docs/packs/engineer.md and start the work');
-  for (const d of ['engineer', 'artist', 'ideator']) {
+  assert.equal(cmdFor('unclassified'), 'Read docs/packs/artisan.md and start the work');
+  assert.equal(cmdFor(undefined), 'Read docs/packs/artisan.md and start the work');
+  for (const d of ['artisan', 'artist', 'artist']) {
     assert.ok(!cmdFor(d).startsWith('/'), `${d} must not be routed to a slash command — /dev, /paint and /ideate no longer exist`);
   }
 });

package/tests/specialities.mjs

@@ -14,10 +14,10 @@ const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const S = require(path.join(ROOT, 'modules', 'specialities', 'specialities.js'));
 
-const DISCIPLINES = ['engineer', 'ideator', 'artist', 'ui'];
+const DISCIPLINES = ['artisan', 'artist', 'ui'];
 const draft = (over = {}) => ({
   name: 'Economics',
-  discipline: 'ideator',
+  discipline: 'artist',
   owner_kind: 'builder',
   owner_builder_id: '1000025',
   ...over,
@@ -130,7 +130,7 @@ test('canAdopt refuses rather than throws on missing inputs', () => {
 });
 
 // ---------- the injected fragment ----------
-const active = { id: '7', slug: 'economics', name: 'Economics', discipline: 'ideator', summary: 'Markets and incentives.', contract_md: 'Argue from mechanism, not vibes.' };
+const active = { id: '7', slug: 'economics', name: 'Economics', discipline: 'artist', summary: 'Markets and incentives.', contract_md: 'Argue from mechanism, not vibes.' };
 
 test('no active speciality injects nothing at all', () => {
   assert.equal(S.describeForApi(null), null);
@@ -140,7 +140,7 @@ test('the contract carries the name, the craft and the owner terms', () => {
   const d = S.describeForApi(active, {});
   assert.equal(d.inject, true);
   assert.match(d.contract, /Economics/);
-  assert.match(d.contract, /under ideator/);
+  assert.match(d.contract, /under artist/);
   assert.match(d.contract, /Argue from mechanism/);
   assert.equal(d.speciality_id, '7');
 });
@@ -212,3 +212,15 @@ test('an empty borrowed speciality still injects nothing', () => {
   const bare = { id: '9', slug: 'x', name: '', discipline: '', summary: '', contract_md: '' };
   assert.equal(S.describeForApi(bare, { selfAuthored: false }).inject, false);
 });
+
+test('the write routes read an OLD craft spelling as the new one (task 1005141)', () => {
+  // An old CLI or form still posts discipline 'engineer'/'ideator'; the routes run
+  // it through the doorway's normalizeCraft before validating, on create AND update.
+  const fs = require('node:fs');
+  const src = fs.readFileSync(path.join(ROOT, 'modules', 'specialities', 'routes', 'specialities.js'), 'utf8');
+  assert.equal((src.match(/discipline: api\.crafts\.normalizeCraft\(b\.discipline\)/g) || []).length, 2);
+  const { normalizeCraft } = require(path.join(ROOT, 'src', 'crafts.js'));
+  assert.equal(normalizeCraft('engineer'), 'artisan');
+  assert.equal(normalizeCraft('ideator'), 'artist');
+  assert.equal(S.validateDraft(draft({ discipline: normalizeCraft('ideator') }), { disciplines: DISCIPLINES }).ok, true);
+});

package/tests/speciality_db_shape.mjs

@@ -38,13 +38,13 @@ function fake(results = []) {
 
 test('adopt DEACTIVATES the craft before inserting — the unique index demands it', async () => {
   const q = fake([{ rows: [], rowCount: 1 }, { rows: [{ builder_id: '1', speciality_id: '7' }], rowCount: 1 }]);
-  await db.adopt({ builderId: '1', specialityId: '7', discipline: 'ideator' }, q);
+  await db.adopt({ builderId: '1', specialityId: '7', discipline: 'artist' }, q);
 
   assert.equal(q.calls.length, 2, 'exactly two statements: the deactivate, then the insert');
   const [first, second] = q.calls;
   assert.match(first.sql, /UPDATE specialities_adoptions SET active = FALSE/);
   assert.match(first.sql, /builder_id = \$1 AND discipline = \$2 AND active/);
-  assert.deepEqual(first.params, ['1', 'ideator'], 'scoped to THIS builder and THIS craft, not all of either');
+  assert.deepEqual(first.params, ['1', 'artist'], 'scoped to THIS builder and THIS craft, not all of either');
   assert.match(second.sql, /INSERT INTO specialities_adoptions/);
   // The order is the whole point: insert-then-deactivate would hit the index.
   assert.ok(q.calls.indexOf(first) < q.calls.indexOf(second));
@@ -68,8 +68,8 @@ test('the injected contract is read with the contract text itself', async () =>
 
 test('activeForCraft reads ONE craft for ONE builder, and only an active row', async () => {
   const q = fake([{ rows: [{ id: '7' }], rowCount: 1 }]);
-  await db.activeForCraft('1', 'ideator', q);
-  assert.deepEqual(q.calls[0].params, ['1', 'ideator']);
+  await db.activeForCraft('1', 'artist', q);
+  assert.deepEqual(q.calls[0].params, ['1', 'artist']);
   assert.match(q.calls[0].sql, /a\.active/);
 });
 
@@ -136,8 +136,8 @@ test('describeTrainingFor with no ids asks the database nothing', async () => {
 });
 
 test('taskDiscipline reads the CORE tasks table by id', async () => {
-  const q = fake([{ rows: [{ discipline: 'engineer' }], rowCount: 1 }]);
-  assert.equal(await db.taskDiscipline('1234', q), 'engineer');
+  const q = fake([{ rows: [{ discipline: 'artisan' }], rowCount: 1 }]);
+  assert.equal(await db.taskDiscipline('1234', q), 'artisan');
   assert.deepEqual(q.calls[0].params, ['1234']);
 });