@bongos/core 1.24.79 → 1.24.81

package/tests/speciality_injection.mjs

@@ -21,8 +21,8 @@ const conductor = require(path.join(ROOT, '.claude', 'hooks', 'conductor.js'));
 
 const sp = (over = {}) => ({
   inject: true,
-  contract: 'Speciality: Economics (under ideator).',
-  discipline: 'ideator',
+  contract: 'Speciality: Economics (under artist).',
+  discipline: 'artist',
   name: 'Economics',
   ...over,
 });
@@ -30,9 +30,9 @@ const claim = (discipline) => ({ task_id: '1', title: 't', discipline });
 const ids = (out) => out.map((a) => a.id);
 
 test('the contract is injected when its craft matches the claim in hand', () => {
-  const out = conductor.evaluateTriggers({ activeClaims: [claim('ideator')], specialities: [sp()] });
-  assert.ok(ids(out).includes('speciality:ideator'), `expected the ideator contract, got ${JSON.stringify(ids(out))}`);
-  const entry = out.find((a) => a.id === 'speciality:ideator');
+  const out = conductor.evaluateTriggers({ activeClaims: [claim('artist')], specialities: [sp()] });
+  assert.ok(ids(out).includes('speciality:artist'), `expected the artist contract, got ${JSON.stringify(ids(out))}`);
+  const entry = out.find((a) => a.id === 'speciality:artist');
   assert.match(entry.text, /Economics/);
 });
 
@@ -41,7 +41,7 @@ test('a speciality for a DIFFERENT craft is not injected', () => {
   // actively misleading at worst. This is the assertion that keeps the selection
   // honest — without it, "inject everything active" would pass the test above.
   const out = conductor.evaluateTriggers({
-    activeClaims: [claim('engineer')],
+    activeClaims: [claim('artisan')],
     specialities: [sp({ discipline: 'artist', contract: 'Speciality: Pixel art (under artist).' })],
   });
   assert.equal(ids(out).filter((i) => String(i).startsWith('speciality:')).length, 0);
@@ -55,7 +55,7 @@ test('with no active claim there is no craft, so nothing is injected', () => {
 
 test('inject:false is honoured — an empty speciality spends no context', () => {
   const out = conductor.evaluateTriggers({
-    activeClaims: [claim('ideator')],
+    activeClaims: [claim('artist')],
     specialities: [sp({ inject: false })],
   });
   assert.equal(ids(out).filter((i) => String(i).startsWith('speciality:')).length, 0);
@@ -63,24 +63,24 @@ test('inject:false is honoured — an empty speciality spends no context', () =>
 
 test('one contract per craft, and two crafts in play get one each', () => {
   const out = conductor.evaluateTriggers({
-    activeClaims: [claim('ideator'), claim('engineer')],
-    specialities: [sp(), sp({ discipline: 'engineer', contract: 'Speciality: Compilers (under engineer).' })],
+    activeClaims: [claim('artist'), claim('artisan')],
+    specialities: [sp(), sp({ discipline: 'artisan', contract: 'Speciality: Compilers (under artisan).' })],
   });
   const got = ids(out).filter((i) => String(i).startsWith('speciality:'));
-  assert.deepEqual(got.sort(), ['speciality:engineer', 'speciality:ideator']);
+  assert.deepEqual(got.sort(), ['speciality:artisan', 'speciality:artist']);
 });
 
 test('malformed entries are skipped rather than thrown on', () => {
   const out = conductor.evaluateTriggers({
-    activeClaims: [claim('ideator')],
+    activeClaims: [claim('artist')],
     specialities: [null, { inject: true }, sp({ contract: '' }), sp()],
   });
   assert.equal(ids(out).filter((i) => String(i).startsWith('speciality:')).length, 1);
 });
 
 test('no specialities at all changes nothing about the hook', () => {
-  const before = conductor.evaluateTriggers({ activeClaims: [claim('ideator')] });
-  const after = conductor.evaluateTriggers({ activeClaims: [claim('ideator')], specialities: [] });
+  const before = conductor.evaluateTriggers({ activeClaims: [claim('artist')] });
+  const after = conductor.evaluateTriggers({ activeClaims: [claim('artist')], specialities: [] });
   assert.deepEqual(ids(before), ids(after));
 });
 
@@ -112,16 +112,16 @@ test('the adoption read selects the contract itself', () => {
 test('two claims in two worktrees: each session gets only its own contract', () => {
   const claims = [
     { ...claim('artist'), task_id: '1', worktree_name: 'task-1' },
-    { ...claim('engineer'), task_id: '2', worktree_name: 'task-2' },
+    { ...claim('artisan'), task_id: '2', worktree_name: 'task-2' },
   ];
   const specs = [
     sp({ discipline: 'artist', contract: 'Speciality: Pixel art (under artist).' }),
-    sp({ discipline: 'engineer', contract: 'Speciality: Compilers (under engineer).' }),
+    sp({ discipline: 'artisan', contract: 'Speciality: Compilers (under artisan).' }),
   ];
   const got = (worktree) => ids(conductor.evaluateTriggers({ activeClaims: claims, specialities: specs, worktree }))
     .filter((i) => String(i).startsWith('speciality:'));
   assert.deepEqual(got('task-1'), ['speciality:artist']);
-  assert.deepEqual(got('task-2'), ['speciality:engineer']);
+  assert.deepEqual(got('task-2'), ['speciality:artisan']);
   // No claim bound to this tree (main checkout): today's behaviour, every craft in play.
-  assert.deepEqual(got('main-checkout').sort(), ['speciality:artist', 'speciality:engineer']);
+  assert.deepEqual(got('main-checkout').sort(), ['speciality:artisan', 'speciality:artist']);
 });

package/tests/speciality_offer_ui.mjs

@@ -34,8 +34,8 @@ const INSTALLED = [
   { name: 'status', does: 'Shows how far along a version is.', cost: 'Free, and it changes nothing.' },
 ];
 
-const mine = (over = {}) => ({ id: 12, name: 'Pricing', discipline: 'engineer', summary: '', contract_md: '', visibility: 'private', adoptable: true, mine: true, skills: ['recall', 'retired-skill'], ...over });
-const theirs = (over = {}) => ({ id: 9, name: 'Economics', discipline: 'ideator', summary: '', contract_md: '', visibility: 'public', adoptable: true, mine: false, skills: ['recall'], ...over });
+const mine = (over = {}) => ({ id: 12, name: 'Pricing', discipline: 'artisan', summary: '', contract_md: '', visibility: 'private', adoptable: true, mine: true, skills: ['recall', 'retired-skill'], ...over });
+const theirs = (over = {}) => ({ id: 9, name: 'Economics', discipline: 'artist', summary: '', contract_md: '', visibility: 'public', adoptable: true, mine: false, skills: ['recall'], ...over });
 
 // The ticked boxes in rendered markup.
 const checkedIn = (html) => [...html.matchAll(/<input type="checkbox" name="skill" value="([^"]+)" checked/g)].map((m) => m[1]);
@@ -74,7 +74,7 @@ for (const page of SPECIALITY_PAGES) {
     const h = await boot(page);
     const form = h.el('speciality-create');
     assert.deepEqual(Object.keys(form.elements).sort(), ['contract_md', 'discipline', 'name', 'sellable', 'summary', 'visibility']);
-    assert.deepEqual(form.elements.discipline.querySelectorAll('option').map((o) => o.attrs.value), ['', 'engineer', 'ideator', 'artist', 'ui']);
+    assert.deepEqual(form.elements.discipline.querySelectorAll('option').map((o) => o.attrs.value), ['', 'artisan', 'artist', 'ui']);
     assert.deepEqual(form.elements.visibility.querySelectorAll('option').map((o) => o.attrs.value), ['private', 'project', 'public']);
     assert.ok(form.querySelector('details#speciality-create-offer'), 'the picker is inside the form');
     assert.ok(form.querySelector('#speciality-create-skills'), 'with the host its choices fill');
@@ -191,12 +191,12 @@ for (const page of SPECIALITY_PAGES) {
     assert.deepEqual(checkedIn(host.innerHTML), [], 'a new speciality starts offering nothing');
     const form = h.el('speciality-create');
     form.elements.name.value = 'New one';
-    form.elements.discipline.value = 'engineer';
+    form.elements.discipline.value = 'artisan';
     h.tick('#speciality-create-skills input[value="status"]');
     await h.submit('#speciality-create');
     const post = writes(h).find((r) => r.method === 'POST' && r.path === '/specialities');
     assert.ok(post, 'created');
-    assert.deepEqual(post.body, { name: 'New one', discipline: 'engineer', summary: '', contract_md: '', visibility: 'private', sellable: false, skills: ['status'] });
+    assert.deepEqual(post.body, { name: 'New one', discipline: 'artisan', summary: '', contract_md: '', visibility: 'private', sellable: false, skills: ['status'] });
     assert.ok(h.toasts.includes('Speciality created.'));
   });
 

package/tests/speciality_offered.mjs

@@ -25,7 +25,7 @@ const db = require(path.join(ROOT, 'modules', 'specialities', 'db.js'));
 
 const ME = '1000025';
 const spec = (over = {}) => ({
-  id: '1', name: 'Economics', discipline: 'ideator',
+  id: '1', name: 'Economics', discipline: 'artist',
   owner_kind: 'builder', owner_builder_id: '1000099',
   visibility: 'public', offered: true, ...over,
 });
@@ -55,13 +55,13 @@ test('a builder-owned speciality set to "project" is not suggested to others', (
 });
 
 test('a speciality you already hold is not suggested back to you', () => {
-  const adoptions = [{ id: '1', discipline: 'ideator', active: true }];
+  const adoptions = [{ id: '1', discipline: 'artist', active: true }];
   assert.deepEqual(S.offeredTo([spec()], viewer, adoptions), []);
 });
 
 test('an inactive past adoption still suppresses the suggestion', () => {
   // You have had it; re-suggesting something you dropped is nagging, not helping.
-  const adoptions = [{ id: '1', discipline: 'ideator', active: false }];
+  const adoptions = [{ id: '1', discipline: 'artist', active: false }];
   assert.deepEqual(S.offeredTo([spec()], viewer, adoptions), []);
 });
 
@@ -69,12 +69,13 @@ test('a craft you already have an ACTIVE speciality in yields no suggestion', ()
   // One active speciality per craft is a DB constraint (the partial unique index),
   // so offering a second in the same craft is offering something that would be
   // refused. Surfacing it as neither is the honest answer.
-  const adoptions = [{ id: '77', discipline: 'ideator', active: true }];
+  const adoptions = [{ id: '77', discipline: 'artist', active: true }];
   assert.deepEqual(S.offeredTo([spec()], viewer, adoptions), []);
 });
 
 test('a different craft is still suggested while one craft is taken', () => {
-  const adoptions = [{ id: '77', discipline: 'artist', active: true }];
+  // Since task 1005141 ideator folded into artist, so the "other" craft here is artisan.
+  const adoptions = [{ id: '77', discipline: 'artisan', active: true }];
   assert.deepEqual(S.offeredTo([spec()], viewer, adoptions).map((s) => s.id), ['1']);
 });
 

package/tests/speciality_session_skills.mjs

@@ -29,7 +29,7 @@ const { test, summary } = makeRunner();
 const LEAN = /chose to lean on these skills/;
 
 // ---- the pure line ----------------------------------------------------------
-const row = (over = {}) => ({ id: 9, slug: 'economics', name: 'Economics', discipline: 'ideator', summary: '', contract_md: '', skills: ['recall', 'status'], enabled_skills: [], active: true, ...over });
+const row = (over = {}) => ({ id: 9, slug: 'economics', name: 'Economics', discipline: 'artist', summary: '', contract_md: '', skills: ['recall', 'status'], enabled_skills: [], active: true, ...over });
 
 await test('enabled skills are named in the contract', () => {
   const d = S.describeForApi(row({ enabled_skills: ['recall', 'status'] }));
@@ -100,7 +100,7 @@ await test('the port is the one the router registered', () => {
 });
 
 await test('an adoption with enabled skills reaches the session in its craft', async () => {
-  const out = await sessionFor([row({ enabled_skills: ['recall'] })], [claim('ideator')]);
+  const out = await sessionFor([row({ enabled_skills: ['recall'] })], [claim('artist')]);
   const sp = specEntries(out);
   assert.equal(sp.length, 1);
   assert.match(sp[0].text, /Economics/);
@@ -108,19 +108,19 @@ await test('an adoption with enabled skills reaches the session in its craft', a
 });
 
 await test('with nothing enabled the session gets the contract and not a word more', async () => {
-  const out = await sessionFor([row({ enabled_skills: [] })], [claim('ideator')]);
+  const out = await sessionFor([row({ enabled_skills: [] })], [claim('artist')]);
   const sp = specEntries(out);
   assert.equal(sp.length, 1, 'the speciality itself is still there');
   assert.doesNotMatch(sp[0].text, LEAN);
 });
 
 await test('craft-scoped like the contract: an engineering session hears nothing of an ideator\'s skills', async () => {
-  const out = await sessionFor([row({ enabled_skills: ['recall'] })], [claim('engineer')]);
+  const out = await sessionFor([row({ enabled_skills: ['recall'] })], [claim('artisan')]);
   assert.equal(specEntries(out).length, 0);
 });
 
 await test('an inactive adoption relays nothing, skills included', async () => {
-  const out = await sessionFor([row({ active: false, enabled_skills: ['recall'] })], [claim('ideator')]);
+  const out = await sessionFor([row({ active: false, enabled_skills: ['recall'] })], [claim('artist')]);
   assert.equal(specEntries(out).length, 0);
 });
 
@@ -128,7 +128,7 @@ await test('a failed skills read degrades to the offered filter, never a lost co
   const saved = skills.installedSkillsCached;
   skills.installedSkillsCached = () => { throw new Error('disk gone'); };
   try {
-    const out = await sessionFor([row({ enabled_skills: ['recall'] })], [claim('ideator')]);
+    const out = await sessionFor([row({ enabled_skills: ['recall'] })], [claim('artist')]);
     assert.match(specEntries(out)[0].text, /\/recall/);
   } finally { skills.installedSkillsCached = saved; }
 });
@@ -165,7 +165,7 @@ await test('three active adoptions cost ONE training read, and each keeps its ow
   try {
     store.adoptions = [
       row({ id: 9, name: 'Economics', contract_md: 'Mine.' }),
-      row({ id: 10, name: 'Law', discipline: 'engineer', contract_md: 'Theirs.' }),
+      row({ id: 10, name: 'Law', discipline: 'artisan', contract_md: 'Theirs.' }),
       row({ id: 11, name: 'Music', discipline: 'artist', contract_md: 'Gone.' }),
       row({ id: 12, name: 'Old', discipline: 'ui', active: false }),
     ];

package/tests/speciality_skills.mjs

@@ -147,16 +147,16 @@ await test('an unreadable root contributes nothing rather than throwing', () =>
 
 // ---- 2. the pure rules ------------------------------------------------------
 const INSTALLED = new Set(['recall', 'status', 'costing']);
-const draft = (over = {}) => ({ name: 'Economics', discipline: 'ideator', owner_kind: 'builder', owner_builder_id: 1, ...over });
+const draft = (over = {}) => ({ name: 'Economics', discipline: 'artist', owner_kind: 'builder', owner_builder_id: 1, ...over });
 const codes = (r) => r.errors.map((e) => e.code);
 
 await test('a speciality may offer skills this instance has', () => {
-  const r = S.validateDraft(draft({ skills: ['recall', 'costing'] }), { disciplines: ['ideator'], installedSkills: INSTALLED });
+  const r = S.validateDraft(draft({ skills: ['recall', 'costing'] }), { disciplines: ['artist'], installedSkills: INSTALLED });
   assert.equal(r.ok, true, JSON.stringify(r.errors));
 });
 
 await test('a skill this instance does NOT have is refused, by name', () => {
-  const r = S.validateDraft(draft({ skills: ['recall', 'teleport'] }), { disciplines: ['ideator'], installedSkills: INSTALLED });
+  const r = S.validateDraft(draft({ skills: ['recall', 'teleport'] }), { disciplines: ['artist'], installedSkills: INSTALLED });
   assert.equal(r.ok, false);
   const e = r.errors.find((x) => x.code === 'unknown_skill');
   assert.ok(e, JSON.stringify(r.errors));
@@ -164,14 +164,14 @@ await test('a skill this instance does NOT have is refused, by name', () => {
 });
 
 await test('a non-empty offered set nothing could check is refused, never admitted', () => {
-  const r = S.validateDraft(draft({ skills: ['recall'] }), { disciplines: ['ideator'] });
+  const r = S.validateDraft(draft({ skills: ['recall'] }), { disciplines: ['artist'] });
   assert.ok(codes(r).includes('uncheckable'));
   // and an empty set needs no check
-  assert.equal(S.validateDraft(draft({ skills: [] }), { disciplines: ['ideator'] }).ok, true);
+  assert.equal(S.validateDraft(draft({ skills: [] }), { disciplines: ['artist'] }).ok, true);
 });
 
 await test('shape: not a list, a bad name, a duplicate, too many', () => {
-  const v = (skillsList) => codes(S.validateDraft(draft({ skills: skillsList }), { disciplines: ['ideator'], installedSkills: INSTALLED }));
+  const v = (skillsList) => codes(S.validateDraft(draft({ skills: skillsList }), { disciplines: ['artist'], installedSkills: INSTALLED }));
   assert.ok(v('recall').includes('invalid'));
   assert.ok(v(['Recall']).includes('invalid_name'));
   assert.ok(v(['recall', 'recall']).includes('duplicate'));
@@ -201,7 +201,7 @@ await test('the migration stores an EMPTY enabled set by default, not a UI defau
 await test('adopting never writes the enabled set, so every new adoption takes the empty default', async () => {
   const seen = [];
   const exec = async (text, params) => { seen.push({ text, params }); return { rows: [{ builder_id: 1, speciality_id: 9, enabled_skills: [] }], rowCount: 1 }; };
-  const row = await db.adopt({ builderId: 1, specialityId: 9, discipline: 'ideator' }, exec);
+  const row = await db.adopt({ builderId: 1, specialityId: 9, discipline: 'artist' }, exec);
   const insert = seen.find((q) => /INSERT INTO specialities_adoptions/.test(q.text));
   assert.ok(insert, 'the adopt INSERT ran');
   assert.ok(!/enabled_skills\s*[,)]/.test(insert.text.split('VALUES')[0]), 'the INSERT column list does not name enabled_skills');
@@ -220,7 +220,7 @@ await test('the enabled set is written only on the caller\'s own ACTIVE adoption
 
 // ---- 4. the real router -----------------------------------------------------
 const store = {
-  speciality: { id: 9, name: 'Economics', discipline: 'ideator', owner_kind: 'builder', owner_builder_id: 1, visibility: 'public', sellable: false, skills: ['recall', 'status'] },
+  speciality: { id: 9, name: 'Economics', discipline: 'artist', owner_kind: 'builder', owner_builder_id: 1, visibility: 'public', sellable: false, skills: ['recall', 'status'] },
   adoption: null, created: null, updated: null,
 };
 db.getSpeciality = async () => ({ ...store.speciality });
@@ -235,7 +235,7 @@ skills.installedSkillsCached = () => new Map([
 ]);
 db.listAdoptions = async () => (store.adoption ? [{ id: 9, active: store.adoption.active, enabled_skills: store.adoption.enabled_skills }] : []);
 api.requireBuilder = (req, res, next) => { req.builder = { id: 1, rank: 'metic' }; next(); };
-api.enabledDisciplines = () => ['ideator', 'engineer', 'artist'];
+api.enabledDisciplines = () => ['artist', 'artisan', 'artist'];
 
 const express = require('express');
 const app = express();
@@ -252,14 +252,14 @@ const call = async (method, url, body) => {
 
 try {
   await test('POST /specialities stores an offered set of installed skills', async () => {
-    const r = await call('POST', '/specialities', { name: 'Economics', discipline: 'ideator', skills: ['recall', 'costing'] });
+    const r = await call('POST', '/specialities', { name: 'Economics', discipline: 'artist', skills: ['recall', 'costing'] });
     assert.equal(r.status, 201, JSON.stringify(r.body));
     assert.deepEqual(store.created.skills, ['recall', 'costing']);
   });
 
   await test('POST /specialities refuses a skill the instance does not have', async () => {
     store.created = null;
-    const r = await call('POST', '/specialities', { name: 'Econ2', discipline: 'ideator', skills: ['teleport'] });
+    const r = await call('POST', '/specialities', { name: 'Econ2', discipline: 'artist', skills: ['teleport'] });
     assert.equal(r.status, 400);
     assert.ok(JSON.stringify(r.body).includes('unknown_skill'));
     assert.equal(store.created, null, 'nothing was written');

package/tests/speciality_walkthrough_ui.mjs

@@ -39,14 +39,14 @@ const explained = (name, extra = {}) => ({
 
 function speciality(over = {}) {
   return {
-    id: 9, name: 'Economics', discipline: 'ideator', summary: 'Markets.', contract_md: '',
+    id: 9, name: 'Economics', discipline: 'artist', summary: 'Markets.', contract_md: '',
     visibility: 'public', adoptable: true, mine: false, skills: ['recall', 'status', 'goal-review', 'gone'],
     ...over,
   };
 }
 
 const SKILLS_BODY = {
-  speciality: { id: 9, name: 'Economics', discipline: 'ideator' },
+  speciality: { id: 9, name: 'Economics', discipline: 'artist' },
   adopted: true,
   enabled: [],
   skills: [

package/tests/sso_checkin_identity_spoof.mjs

@@ -83,6 +83,7 @@ require.cache[moduleApiPath] = {
     resolveEnv: () => null,                    // no hub signing key ⇒ device legs 503
     userAgent: () => 'cloud-bongos-tests',
     LIVE_RANK_LADDER: ['xenos', 'thetes', 'metic', 'archon'],
+    crafts: require('../src/crafts.js'),       // the rollup normalizes reported disciplines (task 1005141)
   },
 };
 
@@ -163,7 +164,7 @@ const rollupBody = (over = {}) => ({
   karma: 999999,
   tasks_shipped: 9999,
   rank: 'archon',
-  disciplines: ['engineer'],
+  disciplines: ['artisan'],
   ...over,
 });
 

package/tests/task_classifier_vocab.mjs

@@ -93,3 +93,13 @@ test('no hall page carries its own copy of the kind list', () => {
       `${page} spells out the kind vocabulary — fill it from /me task_kinds via OTB.fillKindFilter instead`);
   }
 });
+
+// task 1005141 folded the ideator into the artist craft. The art cues and the
+// ideas cues are now ONE craft's score, so a task with one of each is an artist
+// task — scored as two lanes it read as a tie and fell to hand-triage.
+test('an even art/ideas task is the artist craft, not a tie', () => {
+  const { classifyTaskDiscipline } = classifier;
+  assert.equal(classifyTaskDiscipline('Sprites for the quest', '', []).discipline, 'artist');
+  // ui still competes as its own lane.
+  assert.equal(classifyTaskDiscipline('UI redesign wireframes for the landing page', '', []).discipline, 'ui');
+});

package/tests/task_cli.mjs

@@ -24,13 +24,13 @@ t('requires --title and --description', () => {
   assert.ok(errors.some((e) => /--description/.test(e)));
 });
 
-t('minimal valid: defaults kind=feature, discipline=engineer, status=backlog', () => {
+t('minimal valid: defaults kind=feature, discipline=artisan, status=backlog', () => {
   const { body, errors } = buildTaskBody(['--title', 'T', '--description', 'D']);
   assert.equal(errors.length, 0);
   assert.equal(body.title, 'T');
   assert.equal(body.description, 'D');
   assert.equal(body.kind, 'feature');
-  assert.equal(body.discipline, 'engineer');
+  assert.equal(body.discipline, 'artisan');
   assert.equal(body.status, 'backlog');
   assert.equal(body.source, 'bongos-task-cli');
   // optional fields absent unless provided
@@ -92,7 +92,15 @@ t('hallLink builds a hall URL from the API base origin, falls back cleanly', ()
 
 t('enum vocab is the expected shape', () => {
   assert.ok(VALID_KINDS.includes('feature') && VALID_KINDS.includes('bug'));
-  assert.deepEqual(VALID_DISCIPLINES, ['engineer', 'artist', 'ideator', 'ui']);
+  // task 1005141: engineer is 'artisan'; ideator folded into 'artist'.
+  assert.deepEqual(VALID_DISCIPLINES, ['artisan', 'artist', 'ui']);
+});
+
+t('the OLD --discipline spellings still work, mapped to the new craft (task 1005141)', () => {
+  assert.equal(buildTaskBody(['--title', 'T', '--description', 'D', '--discipline', 'engineer']).body.discipline, 'artisan');
+  assert.equal(buildTaskBody(['--title', 'T', '--description', 'D', '--discipline', 'ideator']).body.discipline, 'artist');
+  const { errors } = buildTaskBody(['--title', 'T', '--description', 'D', '--discipline', 'wizard']);
+  assert.ok(errors.some((e) => /--discipline/.test(e)), 'an unknown craft is still refused');
 });
 
 console.log(`\n${passed} passed, ${failed} failed`);

package/tests/task_criteria_unlink_db.mjs

@@ -70,8 +70,8 @@ try {
   await q(`INSERT INTO builders (id,github_id,github_login,display_name,rank) VALUES ($1,'unlink-s','unlink-signer','Unlink Signer','archon')`, [SIGNER]);
 
   const goal = await db.createGoal({ versionId: VER, title: 'Unlink goal', createdBy: SIGNER });
-  const shipped = await db.createTask({ versionId: VER, goalId: goal.id, title: 'The shipped half', kind: 'feature', discipline: 'engineer', creditsReward: 10 });
-  const open = await db.createTask({ versionId: VER, goalId: goal.id, title: 'The open half', kind: 'feature', discipline: 'engineer', creditsReward: 10 });
+  const shipped = await db.createTask({ versionId: VER, goalId: goal.id, title: 'The shipped half', kind: 'feature', discipline: 'artisan', creditsReward: 10 });
+  const open = await db.createTask({ versionId: VER, goalId: goal.id, title: 'The open half', kind: 'feature', discipline: 'artisan', creditsReward: 10 });
   await q(`UPDATE tasks SET status='shipped', shipped_at = now() - interval '1 hour' WHERE id=$1`, [shipped.id]);
 
   // Two criteria, the same two links on each. Only the first carries a sign-off.

package/tests/task_discipline_required.mjs

@@ -18,13 +18,16 @@ const { resolveWriteDiscipline, WRITABLE_DISCIPLINES, VALID_DISCIPLINES } = clas
 
 // --- the writable set -------------------------------------------------------
 
-test('the writable set is the four crafts — ui included, unclassified excluded', () => {
-  // FOUR, not three. The task was written 2026-08-16 naming three; ADR 0272
-  // (2026-09-09) keeps `ui` as a module-contributed discipline and the owner
-  // reconfirmed it on 2026-09-17 when abandoning task 1002987. Narrowing to three
-  // would break live ui rows — the backfill found 3 of them by classification alone.
-  assert.deepEqual([...WRITABLE_DISCIPLINES].sort(), ['artist', 'engineer', 'ideator', 'ui']);
+test('the writable set is the crafts — ui included, unclassified excluded', () => {
+  // ADR 0272 (2026-09-09) keeps `ui` as a module-contributed discipline and the owner
+  // reconfirmed it on 2026-09-17 when abandoning task 1002987; dropping it would
+  // break live ui rows. Task 1005141 (BONGOS-V3) renamed engineer → 'artisan' and
+  // folded ideator into 'artist', so the four became three: artisan, artist, ui.
+  assert.deepEqual([...WRITABLE_DISCIPLINES].sort(), ['artisan', 'artist', 'ui']);
   assert.ok(!WRITABLE_DISCIPLINES.has('unclassified'), 'unclassified is a triage state, not a craft');
+  for (const old of ['engineer', 'ideator']) {
+    assert.ok(!WRITABLE_DISCIPLINES.has(old), `'${old}' is an old spelling, not a writable craft`);
+  }
 });
 
 test('the READ set still carries unclassified, so old rows and filters resolve', () => {
@@ -41,9 +44,20 @@ test('an explicit valid discipline is honoured verbatim', () => {
   }
 });
 
+test('an OLD spelling is normalized to the new craft, not refused (task 1005141)', () => {
+  assert.deepEqual(resolveWriteDiscipline({ discipline: 'engineer', title: 'x' }), { discipline: 'artisan' });
+  assert.deepEqual(resolveWriteDiscipline({ discipline: 'ideator', title: 'x' }), { discipline: 'artist' });
+  assert.equal(classifier.normalizeDisciplineValue('engineer'), 'artisan');
+  assert.equal(classifier.normalizeDisciplineValue('ideator'), 'artist');
+  assert.equal(classifier.normalizeDisciplineValue('ui'), 'ui');
+  assert.equal(classifier.normalizeDisciplineValue(null), null, 'a non-string passes through for the caller to judge');
+  assert.deepEqual(resolveWriteDiscipline({ discipline: 'wizard', title: 'x' }), { error: 'bad_discipline' },
+    'normalizing does not turn an unknown word into a craft');
+});
+
 test('an omitted discipline is INFERRED, and reports that it was', () => {
   const r = resolveWriteDiscipline({ title: 'Refactor the database migration script' });
-  assert.equal(r.discipline, 'engineer');
+  assert.equal(r.discipline, 'artisan');
   assert.equal(r.inferred, true, 'the caller must be able to tell a guess from a statement');
   assert.ok(r.confidence >= 0.5);
 });
@@ -52,7 +66,7 @@ test('an explicit "unclassified" is treated as no answer at all, not as a value'
   // modules/ideas/inbox.js sent this literal string on every promotion. If it were
   // honoured as a value, the create path would still mint the rows this task removes.
   const r = resolveWriteDiscipline({ discipline: 'unclassified', title: 'Refactor the database migration script' });
-  assert.equal(r.discipline, 'engineer');
+  assert.equal(r.discipline, 'artisan');
   assert.equal(r.inferred, true);
 });
 
@@ -109,13 +123,14 @@ test('createTask no longer has an "unclassified" default to fall back on', () =>
 
 // --- the migration: the absence is the thing under test ---------------------
 
-test('core_247 narrows the CHECK to the four crafts and REJECTS unclassified', () => {
+test('core_247 narrowed the CHECK to the four crafts of its day and REJECTED unclassified', () => {
+  // core_247 is history: it predates task 1005141, so it names engineer/ideator.
+  // The live constraint is core_296's — see the next test.
   const sql = fs.readFileSync(path.join(ROOT, 'migrations', 'core_247_discipline_required.sql'), 'utf8');
   const m = sql.match(/CHECK \(discipline IN \(([^)]*)\)\)/);
   assert.ok(m, 'the migration must re-add a discipline CHECK constraint');
   const accepted = m[1].split(',').map((s) => s.trim().replace(/'/g, '')).sort();
-  assert.deepEqual(accepted, ['artist', 'engineer', 'ideator', 'ui'],
-    'the accepted set must match WRITABLE_DISCIPLINES exactly');
+  assert.deepEqual(accepted, ['artist', 'engineer', 'ideator', 'ui']);
   assert.ok(!accepted.includes('unclassified'), 'the whole point: the constraint rejects it');
   // The net that makes the migration safe on a checkout where nobody ran the script.
   assert.match(sql, /UPDATE tasks SET discipline = 'engineer'[\s\S]*?WHERE discipline = 'unclassified'/,
@@ -125,10 +140,17 @@ test('core_247 narrows the CHECK to the four crafts and REJECTS unclassified', (
 test('the migration constraint and the code agree on the accepted set', () => {
   // Two places state the vocabulary; a drift between them is a 500 at write time
   // (code accepts a value the DB rejects) or dead validation (the reverse).
-  const sql = fs.readFileSync(path.join(ROOT, 'migrations', 'core_247_discipline_required.sql'), 'utf8');
+  // The live CHECK is core_296's (task 1005141). It is a deliberate SUPERSET: it
+  // still admits the old 'engineer'/'ideator' because `bongos upgrade` rolls code
+  // back without rolling the DB back. So every writable craft is accepted, and the
+  // only extras are exactly those two old spellings — never 'unclassified'.
+  const sql = fs.readFileSync(path.join(ROOT, 'migrations', 'core_296_crafts_artisan_artist.sql'), 'utf8');
   const accepted = sql.match(/CHECK \(discipline IN \(([^)]*)\)\)/)[1]
     .split(',').map((s) => s.trim().replace(/'/g, '')).sort();
-  assert.deepEqual(accepted, [...WRITABLE_DISCIPLINES].sort());
+  for (const d of WRITABLE_DISCIPLINES) assert.ok(accepted.includes(d), `the DB must accept writable '${d}'`);
+  const extras = accepted.filter((d) => !WRITABLE_DISCIPLINES.has(d)).sort();
+  assert.deepEqual(extras, ['engineer', 'ideator'], 'only the rollback spellings may be extra');
+  assert.ok(!accepted.includes('unclassified'));
 });
 
 // --- the create vectors that must keep working ------------------------------
@@ -139,7 +161,7 @@ test('every direct createTask call site names a discipline or resolves one', ()
     ['modules/ideas/inbox.js', /discipline: \(lifecycle\.resolveWriteDiscipline/],
     ['modules/copy-desk/routes/copy-desk.js', /discipline: 'artist'/],
     ['modules/onboarding/newcomer-restock.js', /^\s*discipline,\s*$/m],
-    ['modules/lifecycle/kickoff-seed.js', /discipline: t\.discipline \|\| 'engineer'/],
+    ['modules/lifecycle/kickoff-seed.js', /discipline: t\.discipline \|\| 'artisan'/],
     ['modules/lifecycle/cascade.js', /discipline: rule\.discipline/],
     ['scripts/bongos/triage.js', /discipline: resolveWriteDiscipline\(/],
   ];
@@ -150,7 +172,7 @@ test('every direct createTask call site names a discipline or resolves one', ()
 });
 
 test('init.js no longer clobbers its own discipline default with undefined', () => {
-  // The spread ran AFTER `t.discipline || 'engineer'`, so `discipline: undefined` in
+  // The spread ran AFTER `t.discipline || 'artisan'`, so `discipline: undefined` in
   // the extras object reset it to nothing — which is why a freshly scaffolded
   // instance was born with role-less starter tasks.
   // Comment lines are stripped first: the fix's own explanation names the old
@@ -159,5 +181,5 @@ test('init.js no longer clobbers its own discipline default with undefined', ()
   const src = fs.readFileSync(path.join(ROOT, 'scripts', 'bongos', 'init.js'), 'utf8')
     .split('\n').filter((l) => !/^\s*(\/\/|\*|\/\*)/.test(l)).join('\n');
   assert.ok(!/discipline: undefined/.test(src), 'a later spread must not undo the default');
-  assert.match(src, /discipline: t\.discipline \|\| 'engineer'/);
+  assert.match(src, /discipline: t\.discipline \|\| 'artisan'/);
 });

package/tests/task_goal_required.mjs

@@ -47,13 +47,13 @@ const permissivePool = {
 
 test('a create with no goalId THROWS instead of quietly filing into a bucket', async () => {
   await assert.rejects(
-    () => createTask({ versionId: 'BONGOS-V1', title: 't', discipline: 'engineer' }, { pool: permissivePool }),
+    () => createTask({ versionId: 'BONGOS-V1', title: 't', discipline: 'artisan' }, { pool: permissivePool }),
     /goalId is required/,
     'the old behaviour was to succeed and say nothing');
 });
 
 test('the error tells the caller both ways out', async () => {
-  const err = await createTask({ versionId: 'BONGOS-V1', title: 't', discipline: 'engineer' }, { pool: permissivePool })
+  const err = await createTask({ versionId: 'BONGOS-V1', title: 't', discipline: 'artisan' }, { pool: permissivePool })
     .then(() => null, (e) => e);
   assert.ok(err, 'must reject');
   assert.match(err.message, /BV1\.R11/, 'names the rule, so the reason is findable');
@@ -63,7 +63,7 @@ test('the error tells the caller both ways out', async () => {
 test('only a literal true opts in — a truthy value still throws', async () => {
   for (const v of [1, 'yes', {}, 'true']) {
     await assert.rejects(
-      () => createTask({ versionId: 'BONGOS-V1', title: 't', discipline: 'engineer', allowCatchAll: v }, { pool: permissivePool }),
+      () => createTask({ versionId: 'BONGOS-V1', title: 't', discipline: 'artisan', allowCatchAll: v }, { pool: permissivePool }),
       /goalId is required/,
       `${JSON.stringify(v)} must not open the hatch`);
   }
@@ -73,7 +73,7 @@ test('naming a goal needs no flag at all', async () => {
   // The ordinary path must stay ordinary: a caller with a goal never learns this
   // parameter exists.
   await createTask(
-    { versionId: 'BONGOS-V1', title: 't', discipline: 'engineer', goalId: 77 },
+    { versionId: 'BONGOS-V1', title: 't', discipline: 'artisan', goalId: 77 },
     { pool: permissivePool, client: permissivePool },
   );
 });

package/tests/task_needs_db.mjs

@@ -58,7 +58,7 @@ try {
       [id, `tn-${id}`, `tn-${id}`, grants]);
   }
   for (const [id, needs] of [[T_NONE, '{}'], [T_OWNER, '{owner}'], [T_SERVER, '{server}']]) {
-    await q(`INSERT INTO tasks (id,version_id,title,status,credits_reward,kind,discipline,needs) VALUES ($1,$2,$3,'ready',10,'feature','engineer',$4::text[])`,
+    await q(`INSERT INTO tasks (id,version_id,title,status,credits_reward,kind,discipline,needs) VALUES ($1,$2,$3,'ready',10,'feature','artisan',$4::text[])`,
       [id, VER, `tn ${id}`, needs]);
   }
 

package/tests/tweak_replaces_artist_review.mjs

@@ -38,7 +38,7 @@ const api = require('../src/module-api.js');
 // used: a hall-ui module ship that changed a page file.
 const SHIP = {
   id: '555', title: 'Reword the studio greeting', status: 'shipped',
-  discipline: 'engineer', kind: 'feature', source: 'manual', module_key: 'hall-ui',
+  discipline: 'artisan', kind: 'feature', source: 'manual', module_key: 'hall-ui',
   version_id: 'BONGOS-V2', goal_id: '1000095',
   touches: ['modules/hall-ui/public/studio.html'],
   shipped_at: new Date('2026-09-22T09:00:00Z'),