@bongos/core 1.24.79 → 1.24.81

package/tests/lightbulb.mjs

@@ -1,4 +1,4 @@
-// tests/lightbulb.mjs — the Ideating lightbulb (task 1004498): an ideator's
+// tests/lightbulb.mjs — the lightbulb (task 1004498; Ideating's, the Artist's since task 1005141): an ideator's
 // text-only notes about the page they are on, split into attributed ideas.
 //
 // Owner decisions, 2026-10-04: an AI splits the notes (one idea if it cannot);
@@ -50,12 +50,13 @@ test('a submit names its page and says something; it is never longer than the ca
   assert.equal(N.normalizeIdeatorSubmit({ page_id: 'builders:studio', body_md: 'x'.repeat(N.MAX_IDEATOR_BODY + 1) }).error, 'body_too_long');
 });
 
-test('the split speaks of an ideator\'s notes, and fences them as data like the palette does', () => {
-  const p = N.buildSplitPrompt({ pageTitle: 'Studio', pageId: 'builders:studio', bodyMd: 'Hi\n~~~~IDEATOR-NOTES-guess~~~~', voice: 'ideator', nonce: 'n1' });
-  assert.match(p, /an ideator's notes, written while looking at one page/);
+test('the split speaks of an artist\'s notes (the ideator folded into the artist, task 1005141), and fences them as data like the palette does', () => {
+  const p = N.buildSplitPrompt({ pageTitle: 'Studio', pageId: 'builders:studio', bodyMd: 'Hi\n~~~~IDEATOR-NOTES-guess~~~~', voice: 'notes', nonce: 'n1' });
+  assert.match(p, /an artist's notes, written while looking at one page/);
   assert.equal(p.split('~~~~IDEATOR-NOTES-n1~~~~').length, 3);
   assert.ok(!p.includes('IDEATOR-NOTES-guess'));
-  assert.doesNotMatch(p, /artist/);
+  assert.doesNotMatch(p, /ideator/, 'no ideator left in the words the model reads');
+  assert.doesNotMatch(p, /feedback about one page/, 'the notes voice, not the palette\'s');
   assert.match(N.buildSplitPrompt({ pageTitle: 'S', pageId: 'builders:s', bodyMd: 'x', nonce: 'n' }), /^You turn an artist's feedback about one page of a web app/, 'the palette\'s words are unchanged');
 });
 
@@ -108,7 +109,7 @@ api.resolveOptional = (name) => {
 const modelSaying = (reply, wait = 0) => ({
   runSubagent: async ({ prompt, opts }) => {
     assert.equal(opts.tools, '', 'the split runs with zero tools');
-    assert.match(prompt, /ideator/);
+    assert.match(prompt, /an artist's notes/);
     if (wait) await new Promise((r) => setTimeout(r, wait));
     return { stdout: reply };
   },
@@ -142,14 +143,14 @@ function call(method, p, body) {
 }
 const NOTES = { page_id: 'builders:studio', page_path: '/studio', page_title: 'Studio', body_md: 'Sort the drafts by page.\n\nAlso show who wrote each one.' };
 
-test('THE WHOLE PATH: an ideator\'s notes come back as ideas under their name, each linking to the page, and nothing is stored', async () => {
+test('THE WHOLE PATH: an artist\'s notes come back as ideas under their name, each linking to the page, and nothing is stored', async () => {
   viewer = { id: 9, rank: 'thetes', display_name: 'Ana', github_login: 'ana' };
   captured = []; captureFails = false; captureOn = true;
   grade = modelSaying('{"ideas":[{"title":"Sort drafts by page","body":"Group them."},{"title":"Show each draft\'s writer","body":"Name them."}]}');
   const r = await call('POST', '/page-notes/ideas', NOTES);
   assert.equal(r.status, 201);
   assert.deepEqual(r.body, { ideas: [{ id: '701', title: 'Sort drafts by page' }, { id: '702', title: 'Show each draft\'s writer' }], split_by: 'ai' });
-  assert.deepEqual(captured.map((c) => [c.capturedBy, c.filedVia]), [[9, 'hall'], [9, 'hall']], 'attributed to the ideator, filed through the hall');
+  assert.deepEqual(captured.map((c) => [c.capturedBy, c.filedVia]), [[9, 'hall'], [9, 'hall']], 'attributed to the artist, filed through the hall');
   for (const c of captured) assert.ok(c.bodyMd.endsWith("From Ana's ideas on Studio. Page: [Studio](/studio)"), 'each idea links back to the page');
 });
 
@@ -372,11 +373,14 @@ test('storage that throws keeps nothing, and the panel still files', async () =>
   assert.match(p.q('#lb-body').innerHTML, /Filed as 2 ideas/);
 });
 
-test('craft-mode.js gives the tool its OWN icon, so it is never read as the Ideating pill beside it (owner, 2026-10-04)', () => {
+test('craft-mode.js gives the tool its OWN icon, and makes it the artist\'s since Ideating folded in (owner, 2026-10-04; task 1005141)', () => {
   const craft = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/craft-mode.js'), 'utf8');
   assert.match(craft, /\{ id: 'lightbulb', icon: 'note', short: 'Ideas', label: 'Write ideas about this page', script: 'lightbulb\.js', api: 'OTBLightbulb' \}/);
   assert.match(craft, /^ {4}note: '<path /m, 'the note glyph is drawn');
-  assert.doesNotMatch(/ideating: \[([\s\S]*?)\]/.exec(/var TOOLS = \{([\s\S]*?)\n {2}\};/.exec(craft)[1])[1], /icon: 'ideating'/);
+  const tools = /var TOOLS = \{([\s\S]*?)\n {2}\};/.exec(craft)[1];
+  assert.doesNotMatch(tools, /ideating:/, 'no Ideating tool list: the mode is gone');
+  assert.match(/artist: \[([\s\S]*?)\n {4}\]/.exec(tools)[1], /id: 'lightbulb'/, 'the lightbulb is one of the artist\'s tools');
+  assert.doesNotMatch(tools, /icon: 'ideating'/, 'never the old Ideating pill glyph');
 });
 
 test('the only route it calls is the lightbulb\'s own, and it rides the palette\'s styles', () => {

package/tests/main_discipline.mjs

@@ -38,33 +38,33 @@ const offered = enabledDisciplines();
 const last = () => calls[calls.length - 1];
 
 await t('the write goes through the one exported statement', async () => {
-  await db.updateBuilderDisciplines(7, ['engineer']);
+  await db.updateBuilderDisciplines(7, ['artisan']);
   assert.equal(last().sql, db.UPDATE_BUILDER_DISCIPLINES_SQL);
   assert.match(db.UPDATE_BUILDER_DISCIPLINES_SQL, /main_discipline = CASE WHEN \$3::boolean THEN \$4::text/);
   assert.match(db.UPDATE_BUILDER_DISCIPLINES_SQL, /WHEN main_discipline = ANY\(\$2::text\[\]\) THEN main_discipline\s+ELSE NULL END/);
 });
 
 await t('not mentioned: the flag is false, so the stored main role is left to the statement to keep or clear', async () => {
-  await db.updateBuilderDisciplines(7, ['engineer', 'ideator']);
+  await db.updateBuilderDisciplines(7, ['artisan', 'artist']);
   assert.deepEqual(last().params.slice(2), [false, null]);
 });
 
 await t('named: the flag is true and the role travels', async () => {
-  await db.updateBuilderDisciplines(7, ['ideator', 'engineer'], { mainDiscipline: 'ideator' });
-  assert.deepEqual(last().params.slice(2), [true, 'ideator']);
-  assert.deepEqual(last().params[1], offered.filter((d) => ['ideator', 'engineer'].includes(d)),
+  await db.updateBuilderDisciplines(7, ['artist', 'artisan'], { mainDiscipline: 'artist' });
+  assert.deepEqual(last().params.slice(2), [true, 'artist']);
+  assert.deepEqual(last().params[1], offered.filter((d) => ['artist', 'artisan'].includes(d)),
     'the set is still stored in canonical order: the main role is what carries the choice');
 });
 
 await t('null clears it on purpose', async () => {
-  await db.updateBuilderDisciplines(7, ['engineer'], { mainDiscipline: null });
+  await db.updateBuilderDisciplines(7, ['artisan'], { mainDiscipline: null });
   assert.deepEqual(last().params.slice(2), [true, null]);
 });
 
 await t('a main role that is not one of the chosen crafts is refused, and nothing is written', async () => {
   const before = calls.length;
-  await assert.rejects(() => db.updateBuilderDisciplines(7, ['engineer'], { mainDiscipline: 'ideator' }),
-    (err) => err.code === 'invalid_main_discipline' && err.bad[0] === 'ideator');
+  await assert.rejects(() => db.updateBuilderDisciplines(7, ['artisan'], { mainDiscipline: 'artist' }),
+    (err) => err.code === 'invalid_main_discipline' && err.bad[0] === 'artist');
   assert.equal(calls.length, before);
 });
 

package/tests/markdown_line_endings.mjs

@@ -41,7 +41,7 @@ test('every tracked .md resolves to eol=lf, at any depth', () => {
     'README.md',
     'CLAUDE.md',
     'docs/architecture.md',
-    'docs/packs/engineer.md',
+    'docs/packs/artisan.md',
     'docs/adr/README.md',
     '.claude/skills/merge-mode/SKILL.md',
     'modules/hall-ui/CLAUDE.md',

package/tests/market_watch_pages.mjs

@@ -442,28 +442,29 @@ test('MARKET WATCH OFF: both pages show the quiet off line, not an error, and as
   }
 });
 
-// ---- the owner's Settings tab (task 1005045) ---------------------------------------
+// ---- the owner's settings, an options menu entry (task 1005144; before it task 1005045) ----
 //
-// Owner decision 2026-11-03 (idea 1001310): one sidebar item. The settings that had their
-// own page at /market-watch-settings are a Settings tab on this page, shown to the owner
-// (archon, cosmetic — the four settings routes keep their own wall, ADR 0016) and to
-// nobody else. These boot the real market-watch.js with the kit and the settings script
-// stood in, so what is asserted is which tabs the page builds for which viewer.
-
-function bootDesk({ rank, homeStatus = 200, modules = { enabled: { 'market-watch': true } }, meStatus = 200, shared } = {}) {
+// BONGOS-V3 R04 (ADR 0401): every setting is reached from the ONE options menu. The
+// settings that had their own page (task 1004938) and then an owner-only Settings tab here
+// (task 1005045) are the menu's "Market Watch settings" entry: the menu opens this page in
+// its frame (?embed=1, which shell-game.js reads), and the page then shows the settings
+// panel ALONE. A plain visit is the watch, with no tab strip and no settings read, and an
+// old #settings link goes on to the menu. These boot the real market-watch.js with the
+// settings script stood in. The four settings routes stay the wall (ADR 0016).
+
+function bootDesk({ rank = 'archon', homeStatus = 200, modules = { enabled: { 'market-watch': true } }, embed = false, hash = '' } = {}) {
   const els = {};
   const el = (id) => (els[id] = els[id] || { id, hidden: true, innerHTML: '', textContent: '', style: {}, value: '', dataset: {}, title: '', addEventListener() {}, querySelectorAll: () => [], setAttribute() {} });
   const listeners = {};
   const fetches = [];
-  const tabsMade = [];
   const settingsLoads = [];
+  const replaced = [];
   const window = {
     __MODULES__: modules,
     OTBMarketWatch: MW,
-    OTBKit: { makeTabs: (opts) => { tabsMade.push(opts); return { activate() {}, active: () => opts.initial || opts.tabs[0].id }; } },
     OTBMarketWatchSettings: { load: () => { settingsLoads.push(1); } },
-    __hallReads: shared === undefined ? undefined : { '/me': shared },
-    location: { pathname: '/market-watch', search: '', hash: '', assign() {} },
+    OTBShellGame: { embedded: () => embed, menuPath: () => '/settings' },
+    location: { pathname: '/market-watch', search: embed ? '?embed=1' : '', hash, assign() {}, replace(u) { replaced.push(u); } },
     localStorage: { getItem: () => null, setItem() {} },
   };
   const document = {
@@ -477,61 +478,61 @@ function bootDesk({ rank, homeStatus = 200, modules = { enabled: { 'market-watch
     window, document, URLSearchParams, console,
     fetch: async (url) => {
       fetches.push(url);
-      if (/\/me$/.test(url)) return answer(meStatus, { builder: { id: '1', rank } });
+      if (/\/me$/.test(url)) return answer(200, { builder: { id: '1', rank } });
       if (/market-watch\/home$/.test(url)) return answer(homeStatus, homeStatus === 200 ? home() : { error: { code: 'not_found' } });
       return answer(404, {});
     },
   });
   vm.runInContext(readFileSync(new URL('../modules/hall-ui/public/market-watch.js', import.meta.url), 'utf8'), ctx);
-  return { els: new Proxy(els, { get: (_, id) => el(id) }), fetches, tabsMade, settingsLoads, ready: () => listeners.DOMContentLoaded() };
+  return { els: new Proxy(els, { get: (_, id) => el(id) }), fetches, settingsLoads, replaced, ready: () => listeners.DOMContentLoaded() };
 }
 
-test('SETTINGS TAB: the owner gets a Watch tab and a Settings tab, linked by #settings, and the settings load', async () => {
-  const p = bootDesk({ rank: 'archon' });
+test('SETTINGS IN THE MENU: inside the options menu frame the page is the settings panel alone', async () => {
+  const p = bootDesk({ embed: true });
   await p.ready();
-  assert.equal(p.els['mw-desk'].hidden, false, 'the desk still draws');
-  assert.equal(p.tabsMade.length, 1, 'one tab strip');
-  const t = JSON.parse(JSON.stringify(p.tabsMade[0]));
-  assert.deepEqual(t.tabs.map((x) => [x.id, x.label, x.panel]), [['watch', 'Watch', 'mw-panel-watch'], ['settings', 'Settings', 'mw-panel-settings']]);
-  assert.equal(t.hash, true, '#settings is the address the old URL redirects to');
-  assert.equal(t.initial, 'watch', 'the owner lands on the watch, like everyone else');
-  assert.equal(p.els['mw-tabs'].hidden, false, 'the strip shows');
+  assert.equal(p.els['mw-panel-settings'].hidden, false, 'the settings panel shows');
+  assert.equal(p.els['mw-panel-watch'].hidden, true, 'the watch does not');
   assert.equal(p.settingsLoads.length, 1, 'the settings read is made once');
+  assert.deepEqual(p.fetches, [], 'no watch read and no /me: the settings routes answer who may see them');
+  // even when the watch would fail to read, the switch and key stay reachable
+  const failing = bootDesk({ embed: true, homeStatus: 500 });
+  await failing.ready();
+  assert.equal(failing.settingsLoads.length, 1);
 });
 
-test('SETTINGS TAB: a non-owner sees no tab strip and no settings, and the settings are never read', async () => {
-  for (const rank of ['metic', 'thetes', 'xenos', null]) {
+test('SETTINGS IN THE MENU: a plain visit is the watch, with no tab strip and no settings read, for every rank', async () => {
+  for (const rank of ['archon', 'metic', 'thetes', 'xenos', null]) {
     const p = bootDesk({ rank });
     await p.ready();
     assert.equal(p.els['mw-desk'].hidden, false, `${rank}: the desk draws`);
-    assert.equal(p.tabsMade.length, 0, `${rank}: no tab strip`);
-    assert.equal(p.els['mw-tabs'].hidden, true, `${rank}: the strip stays hidden`);
     assert.equal(p.els['mw-panel-settings'].hidden, true, `${rank}: the settings panel stays hidden`);
-    assert.equal(p.settingsLoads.length, 0, `${rank}: the owner-only read is not made`);
+    assert.equal(p.settingsLoads.length, 0, `${rank}: the settings are not read`);
+    assert.ok(!p.fetches.some((u) => /\/me$/.test(u)), `${rank}: and nobody is asked who they are`);
   }
-  // An unreadable /me is not an owner.
-  const blind = bootDesk({ rank: 'archon', meStatus: 500 });
-  await blind.ready();
-  assert.equal(blind.tabsMade.length, 0, 'an unreadable identity builds no settings tab');
 });
 
-test('SETTINGS TAB: where Market Watch is off there is nothing to set, so no tab (and still nothing asked)', async () => {
-  const off = bootDesk({ rank: 'archon', modules: { enabled: { 'market-watch': false } } });
+test('SETTINGS IN THE MENU: an old #settings link opens the menu entry instead, and reads nothing', async () => {
+  const p = bootDesk({ hash: '#settings' });
+  await p.ready();
+  assert.deepEqual(p.replaced, ['/settings?open=market-watch'], 'a replace, so Back does not bounce through the watch');
+  assert.deepEqual(p.fetches, []);
+  assert.equal(p.settingsLoads.length, 0);
+});
+
+test('SETTINGS IN THE MENU: where Market Watch is off there is nothing to set (and nothing asked)', async () => {
+  const off = bootDesk({ embed: true, modules: { enabled: { 'market-watch': false } } });
   await off.ready();
-  assert.equal(off.tabsMade.length, 0);
-  assert.equal(off.fetches.length, 0, 'an off module is not asked, and neither is /me');
-  const unmounted = bootDesk({ rank: 'archon', modules: undefined, homeStatus: 404 });
-  await unmounted.ready();
-  assert.equal(unmounted.els['mw-off'].hidden, false);
-  assert.equal(unmounted.tabsMade.length, 0, 'unmounted routes have no settings either');
+  assert.equal(off.els['mw-off'].hidden, false, 'the off state shows in the frame');
+  assert.equal(off.settingsLoads.length, 0);
+  assert.equal(off.fetches.length, 0);
 });
 
-test('SETTINGS TAB: the page carries every setting the old page did, in a hidden owner panel, and the old page is gone', () => {
+test('SETTINGS PANEL: the page carries every setting the old page did, in a hidden panel, and the old page is gone', () => {
   const pub = (f) => new URL(`../modules/hall-ui/public/${f}`, import.meta.url);
   const html = readFileSync(pub('market-watch.html'), 'utf8');
   const panel = html.match(/<section[^>]*id="mw-panel-settings"[^>]*>[\s\S]*?<\/section>\s*<!-- \/mw-panel-settings -->/);
   assert.ok(panel, 'one settings panel, closed by its marker comment');
-  assert.match(panel[0].split('>')[0], /\bhidden\b/, 'the panel starts hidden: nobody sees it until the owner check passes');
+  assert.match(panel[0].split('>')[0], /\bhidden\b/, 'the panel starts hidden: only the options menu frame shows it');
   for (const id of ['mws-power', 'mws-cap', 'mws-cad', 'mws-weeks', 'mws-key-in', 'mws-key-save', 'mws-key-clear', 'mws-sealed', 'mws-off', 'mws-error']) {
     assert.match(panel[0], new RegExp(`id="${id}"`), `${id} is on the tab`);
   }
@@ -539,12 +540,12 @@ test('SETTINGS TAB: the page carries every setting the old page did, in a hidden
   // While GET /market-watch/settings is in flight every section below is [hidden], so the
   // panel opens on the self-hiding page loader (records/loader.md) rather than a blank tab.
   const inner = panel[0].slice(panel[0].indexOf('>') + 1).replace(/^\s*(<!--[\s\S]*?-->\s*)*/, '');
-  assert.match(inner, /^<p class="hall-loading hall-loading--page hall-loading--wait" role="status">Loading…<\/p>/, 'the settings tab opens on the page loader');
+  assert.match(inner, /^<p class="hall-loading hall-loading--page hall-loading--wait" role="status">Loading…<\/p>/, 'the settings panel opens on the page loader');
   const after = inner.slice(inner.indexOf('</p>') + 4);
   const kids = [...after.matchAll(/^ {10}<(section|div|p)\b([^>]*)>/gm)];
   assert.ok(kids.length >= 4, `the loader's siblings were read (${kids.length})`);
   for (const [, tag, attrs] of kids) assert.match(attrs, /\bhidden\b/, `a <${tag}> after the loader starts hidden, or the loader would never show`);
-  assert.match(html, /<div[^>]*id="mw-tabs"[^>]*hidden/, 'the tab strip starts hidden');
+  assert.doesNotMatch(html, /id="mw-tabs"/, 'no tab strip: the settings are an options menu entry (task 1005144)');
   assert.match(html, /<div[^>]*id="mw-panel-watch"/, 'the watch is its own panel');
   assert.match(html, /market-watch-settings\.css/);
   assert.match(html, /<script src="\/builders\/market-watch-settings\.js"><\/script>\s*<script src="\/builders\/market-watch\.js"><\/script>/,
@@ -558,48 +559,25 @@ test('SETTINGS TAB: the page carries every setting the old page did, in a hidden
   assert.match(js, /window\.OTBMarketWatchSettings = \{ load \}/);
 });
 
-test('SETTINGS TAB: the old settings URL redirects to the tab, and no gate dispatches to it', () => {
+test('SETTINGS IN THE MENU: the old settings URL opens the menu entry, even framed, and no gate dispatches to it', () => {
   const serve = readFileSync(new URL('../src/bongos/serve-internal.js', import.meta.url), 'utf8');
-  const decl = 'const RETIRED_MW_SETTINGS_RE = ';
+  const decl = 'const RETIRED_OPTIONS_RE = ';
   const i = serve.indexOf(decl);
   assert.ok(i > 0, 'the old URL keeps a matcher, so a bookmark still lands');
-  const block = serve.slice(i, i + 700);
-  assert.ok(block.includes('res.redirect(302,'), 'a temporary redirect, never cached past a re-point');
-  assert.ok(block.includes('/market-watch${qs}#settings'), 'landing on the Settings tab, query string kept');
   const rx = eval(serve.slice(i + decl.length, serve.indexOf(';', i))); // eslint-disable-line no-eval
   for (const p of ['/builders/market-watch-settings', '/builders/market-watch-settings/', '/builders/market-watch-settings.html']) {
     assert.ok(rx.test(p), `${p} reaches the redirect`);
   }
-  for (const p of ['/builders/market-watch', '/builders/market-watch-rules', '/api/bongos/market-watch/settings', '/builders/market-watch-settingsx']) {
+  for (const p of ['/builders/market-watch', '/builders/market-watch-item', '/api/bongos/market-watch/settings', '/builders/market-watch-settingsx']) {
     assert.ok(!rx.test(p), `${p} is not redirected`);
   }
+  const block = serve.slice(i, i + 900);
+  assert.ok(block.includes("embed === '1' && m[1] !== 'market-watch-settings'"), 'the retired page has no page left, so even a framed request is sent to the menu');
+  assert.ok(block.includes('res.redirect(302,'), 'a temporary redirect, never cached past a re-point');
+  assert.match(serve, /'market-watch-settings': 'market-watch'/, 'it opens the Market Watch settings entry');
   const mwRe = serve.match(/const MARKET_WATCH_PAGE_RE = (\/[^\n]*?\/);/);
   assert.ok(mwRe, 'the Market Watch page gate is still a literal');
   const gate = eval(mwRe[1]); // eslint-disable-line no-eval
   assert.ok(!gate.test('/builders/market-watch-settings'), 'the page gate no longer names the retired page');
   for (const p of ['/builders/market-watch', '/builders/market-watch-item', '/builders/market-watch-rules']) assert.ok(gate.test(p), p);
 });
-
-test('SETTINGS TAB: the page adopts the shell\'s one /me read instead of asking again', async () => {
-  const owner = bootDesk({ rank: 'archon', shared: Promise.resolve({ builder: { id: '1', rank: 'archon' } }) });
-  await owner.ready();
-  assert.equal(owner.tabsMade.length, 1, 'the shared answer is enough to know the owner');
-  assert.ok(!owner.fetches.some((u) => /\/me$/.test(u)), 'no second /me request');
-  for (const answer of [{ builder: { id: '2', rank: 'metic' } }, false, null]) {
-    const p = bootDesk({ rank: 'archon', shared: Promise.resolve(answer) });
-    await p.ready();
-    assert.equal(p.tabsMade.length, 0, `${JSON.stringify(answer)}: no tab`);
-    assert.ok(!p.fetches.some((u) => /\/me$/.test(u)), 'and no fallback request either');
-  }
-});
-
-test('SETTINGS TAB: a watch that fails to read keeps the owner\'s tab, so the switch and key stay reachable', async () => {
-  const p = bootDesk({ rank: 'archon', homeStatus: 500 });
-  await p.ready();
-  assert.equal(p.els['mw-fail'].hidden, false, 'the failure line shows on the Watch tab');
-  assert.equal(p.tabsMade.length, 1, 'the settings are their own read, so the owner still gets them');
-  assert.equal(p.settingsLoads.length, 1);
-  const member = bootDesk({ rank: 'metic', homeStatus: 500 });
-  await member.ready();
-  assert.equal(member.tabsMade.length, 0, 'and a non-owner still gets none');
-});

package/tests/me_streak_leaderboard_queries.mjs

@@ -64,7 +64,7 @@ const TASKS = {
   104: { kind: 'refactor', est_minutes: 90 },
   105: { kind: 'bug', est_minutes: 20 },
 };
-const claimsFor = (ids) => ids.map((id) => ({ task_id: String(id), discipline: 'engineer' }));
+const claimsFor = (ids) => ids.map((id) => ({ task_id: String(id), discipline: 'artisan' }));
 
 await test('/me sends the same number of streak queries for 1 claim as for 5', async () => {
   const counts = [];
@@ -117,7 +117,7 @@ await test('each streak_preview is exactly what wouldExtendStreak returns, in ev
 await test('the claim keeps its own fields and gains craft_mode beside the preview', async () => {
   const db = fakeDb({ tasks: TASKS });
   const cur = await streak.computeStreak(1, db);
-  const [c] = await claimsWithStreakPreview(rewardOn(db), 1, [{ task_id: '101', discipline: 'engineer', id: 7 }], cur, null);
+  const [c] = await claimsWithStreakPreview(rewardOn(db), 1, [{ task_id: '101', discipline: 'artisan', id: 7 }], cur, null);
   assert.equal(c.id, 7);
   assert.equal(c.task_id, '101');
   assert.ok('craft_mode' in c);
@@ -149,7 +149,7 @@ await test('two leaderboard reads within the window hit the database once', asyn
 await test('a caller editing its rows does not edit the cached answer', async () => {
   achievements.clearLeaderboardCache();
   const a = await achievements.getLeaderboardWithAchievements(100, 5);
-  a[0].roles = ['engineer'];
+  a[0].roles = ['artisan'];
   const b = await achievements.getLeaderboardWithAchievements(100, 5);
   assert.equal(b[0].roles, undefined);
 });

package/tests/migration_allocation.mjs

@@ -266,7 +266,7 @@ function shouldReserveMigrationNumber(task) {
       const db = require('../modules/lifecycle/db.js');
       const setters = [
         [() => db.updateTaskKind(1, 'bug'), 'kind'],
-        [() => db.updateTaskDiscipline(1, 'engineer'), 'discipline'],
+        [() => db.updateTaskDiscipline(1, 'artisan'), 'discipline'],
         [() => db.updateTaskNewcomerFriendly(1, true), 'newcomer_friendly'],
         [() => db.updateTaskParallelSafe(1, true), 'parallel_safe'],
         [() => db.updateTaskAutomationTag(1, 'live-only'), 'automation_tag'],

package/tests/mingle.mjs

@@ -76,13 +76,28 @@ const off = () => async () => null;
 // ── 1. A PAIR IS ONLY EVER CROSS-CRAFT ──────────────────────────────────────
 
 test('THE RULE: crafts must be DISJOINT, not merely different', () => {
-  assert.equal(mingle.isCrossCraft(['builder'], ['artist']), true);
-  assert.equal(mingle.isCrossCraft(['builder'], ['builder']), false);
+  assert.equal(mingle.isCrossCraft(['artisan'], ['artist']), true);
+  assert.equal(mingle.isCrossCraft(['artisan'], ['artisan']), false);
   // The case a "different primary craft" rule would get wrong: someone who is
-  // both shares a craft with a pure engineer, so pairing them puts two of the
+  // both shares a craft with a pure artisan, so pairing them puts two of the
   // same in a room and calls it cross-craft.
-  assert.equal(mingle.isCrossCraft(['artist', 'builder'], ['builder']), false);
-  assert.equal(mingle.isCrossCraft(['artist', 'builder'], ['ideator']), true);
+  assert.equal(mingle.isCrossCraft(['artist', 'artisan'], ['artisan']), false);
+  assert.equal(mingle.isCrossCraft(['artist', 'artisan'], ['artist']), false);
+  assert.equal(mingle.isCrossCraft(['artist', 'artisan'], ['ui']), true);
+});
+
+test('since task 1005141 an artist and an (old) ideator are the SAME craft, so never a pair', () => {
+  // The fold: a builder still carrying 'ideator' in preferred_disciplines maps to
+  // the artist craft through help-requests' map, so artist × ideator is no longer
+  // cross-craft.
+  const help = require(path.join(ROOT, 'modules', 'lifecycle', 'help-requests.js'));
+  const ideator = [help.craftForDiscipline('ideator')];
+  const artist = [help.craftForDiscipline('artist')];
+  assert.deepEqual(ideator, ['artist']);
+  assert.equal(mingle.isCrossCraft(artist, ideator), false);
+  const engineer = [help.craftForDiscipline('engineer')];
+  assert.deepEqual(engineer, ['artisan'], 'a stored engineer discipline is the artisan craft');
+  assert.equal(mingle.isCrossCraft(engineer, artist), true);
 });
 
 test('a builder with NO craft is never pairable', () => {
@@ -99,11 +114,11 @@ test('a builder with NO craft is never pairable', () => {
 
 test('EVERY pair the planner emits is cross-craft', () => {
   const eligible = [
-    { builder_id: '10', crafts: ['builder'] },
-    { builder_id: '20', crafts: ['builder'] },
+    { builder_id: '10', crafts: ['artisan'] },
+    { builder_id: '20', crafts: ['artisan'] },
     { builder_id: '30', crafts: ['artist'] },
-    { builder_id: '40', crafts: ['ideator'] },
-    { builder_id: '50', crafts: ['artist', 'builder'] },
+    { builder_id: '40', crafts: ['artist'] },
+    { builder_id: '50', crafts: ['artist', 'artisan'] },
   ];
   const byId = new Map(eligible.map((b) => [b.builder_id, b.crafts]));
   const pairs = mingle.planPairs(eligible);
@@ -117,9 +132,9 @@ test('EVERY pair the planner emits is cross-craft', () => {
 
 test('nobody is put in two pairs in one round', () => {
   const pairs = mingle.planPairs([
-    { builder_id: '1', crafts: ['builder'] },
+    { builder_id: '1', crafts: ['artisan'] },
     { builder_id: '2', crafts: ['artist'] },
-    { builder_id: '3', crafts: ['ideator'] },
+    { builder_id: '3', crafts: ['artist'] },
     { builder_id: '4', crafts: ['ui'] },
   ]);
   const seen = new Set();
@@ -154,7 +169,7 @@ test('the matching rule is RECORDED, and the route serves it verbatim', () => {
 
 test('SWITCH 1 OFF: the project disabled means no pairing, and no write at all', async () => {
   const pool = recordingPool({ eligible: [
-    { builder_id: '1', crafts: ['builder'] },
+    { builder_id: '1', crafts: ['artisan'] },
     { builder_id: '2', crafts: ['artist'] },
   ] });
   const out = await mingle.runMingleRound({}, { pool, getSetting: off() });
@@ -174,7 +189,7 @@ test('SWITCH 2 OFF: eligibility is opted-in only, enforced in SQL', async () =>
 
 test('BOTH ON is the only state that pairs', async () => {
   const pool = recordingPool({ eligible: [
-    { builder_id: '1', crafts: ['builder'] },
+    { builder_id: '1', crafts: ['artisan'] },
     { builder_id: '2', crafts: ['artist'] },
   ] });
   const out = await mingle.runMingleRound({}, { pool, getSetting: on() });
@@ -185,9 +200,9 @@ test('BOTH ON is the only state that pairs', async () => {
 
 test('a round is ONE insert, so a partial round cannot be written', () => {
   const pool = recordingPool({ eligible: [
-    { builder_id: '1', crafts: ['builder'] },
+    { builder_id: '1', crafts: ['artisan'] },
     { builder_id: '2', crafts: ['artist'] },
-    { builder_id: '3', crafts: ['ideator'] },
+    { builder_id: '3', crafts: ['artist'] },
     { builder_id: '4', crafts: ['ui'] },
   ] });
   return mingle.runMingleRound({}, { pool, getSetting: on() }).then((out) => {
@@ -202,8 +217,8 @@ test('an empty plan writes nothing at all', async () => {
   // Two builders of the SAME craft are not a pair, so there is nothing to insert
   // — and no empty INSERT should be issued to discover that.
   const pool = recordingPool({ eligible: [
-    { builder_id: '1', crafts: ['builder'] },
-    { builder_id: '2', crafts: ['builder'] },
+    { builder_id: '1', crafts: ['artisan'] },
+    { builder_id: '2', crafts: ['artisan'] },
   ] });
   const out = await mingle.runMingleRound({}, { pool, getSetting: on() });
   assert.deepEqual(out.paired, []);
@@ -243,7 +258,7 @@ test('the two switches are reported SEPARATELY, so a builder can see which is of
 const PENALTY_SURFACES = /credit|karma|rank|streak|achievement|reward|score|penalt|cooldown|strike/i;
 
 test('THE NO-PENALTY PROPERTY: a decline writes ONE row in ONE table', async () => {
-  const pool = recordingPool({ pairRow: { id: 5, builder_lo: '1', builder_hi: '2', craft_lo: 'builder', craft_hi: 'artist', status: 'declined', decided_by: '1', decided_at: 'now' } });
+  const pool = recordingPool({ pairRow: { id: 5, builder_lo: '1', builder_hi: '2', craft_lo: 'artisan', craft_hi: 'artist', status: 'declined', decided_by: '1', decided_at: 'now' } });
   const out = await mingle.decidePair(5, 1, 'declined', { pool });
   assert.equal(out.pair.status, 'declined');
 
@@ -274,7 +289,7 @@ test('a declined pair may be introduced again — a decline is not a permanent s
   // is free.
   assert.match(MIGRATION, /CREATE UNIQUE INDEX[\s\S]{0,200}lifecycle_mingle_pairs_open_uniq[\s\S]{0,120}WHERE status = 'proposed'/);
   const eligible = [
-    { builder_id: '1', crafts: ['builder'] },
+    { builder_id: '1', crafts: ['artisan'] },
     { builder_id: '2', crafts: ['artist'] },
   ];
   // With the pair already OPEN, it is skipped...
@@ -388,8 +403,8 @@ test('the route is registered in the module manifest', () => {
 });
 
 test('the craft vocabulary is CONSUMED from help-requests, never redefined', () => {
-  // Two spellings of the same craft ('builder' the craft is 'engineer' the
-  // discipline) would silently match nobody.
+  // Two spellings of the same craft (before task 1005141, 'builder' the craft was
+  // 'engineer' the discipline) would silently match nobody.
   assert.match(SRC, /require\('\.\/help-requests'\)/);
   assert.ok(!/CRAFT_TO_DISCIPLINE\s*=|DISCIPLINE_TO_CRAFT\s*=/.test(SRC),
     'mingle must not declare its own craft map');

package/tests/module-scope-map.mjs

@@ -407,9 +407,9 @@ test('methodology joined the roster (task 1002989) — the instruction surfaces
   const covers = (touch) => gsc.scopeSubset(['methodology'], [touch]).ok;
   for (const touch of [
     'CLAUDE.md',                              // the kernel half of the split (1002990)
-    'docs/packs/engineer.md',                 // the three role packs the split authored (1002990)
+    'docs/packs/artisan.md',                 // the three role packs the split authored (1002990)
+    'docs/packs/artist.md',
     'docs/packs/artist.md',
-    'docs/packs/ideator.md',
     '.claude/skills/status/SKILL.md',         // the skills floor no module claims
     '.claude/rules/content-charter.md',       // pre-carved for task 1003687
     'docs/adr/0264-the-ten-working-areas.md', // the ADR library
@@ -767,3 +767,23 @@ test('every file under src/bongos/routes/ is protected by the blanket prefix AND
     );
   }
 });
+
+// Task 1004793: the module store's code (src/bongos/module-*.js + its scripts/bongos/
+// module-*.js CLIs) was owned by no key, so no goal could author a change to it. Every
+// such file must resolve to a key, and the store files to the 'module-store' key. The
+// directory is read live, so a NEW store file added without an owner fails here.
+test('every module-* store file resolves to a key, the store files to module-store', () => {
+  const all = Object.values(scope.MODULE_GLOBS);
+  const files = [
+    ...fs.readdirSync(path.join(ROOT, 'src', 'bongos')).filter((f) => /^module-.*\.js$/.test(f)).map((f) => 'src/bongos/' + f),
+    ...fs.readdirSync(path.join(ROOT, 'scripts', 'bongos')).filter((f) => /^module-.*\.js$/.test(f)).map((f) => 'scripts/bongos/' + f),
+  ];
+  assert.ok(files.length >= 20, 'expected the store files to still exist, saw ' + files.length);
+  const store = scope.MODULE_GLOBS['module-store'];
+  for (const f of files) {
+    assert.ok(all.some((g) => matchOne(f, g)), f + ' is owned by no key in MODULE_GLOBS');
+    if (f === 'src/bongos/module-scope-map.js') assert.ok(matchOne(f, scope.MODULE_GLOBS.kernel), f + ' stays kernel');
+    else assert.ok(matchOne(f, store), f + ' should be owned by module-store');
+  }
+  assert.equal(gsc.scopeSubset(['module-store'], ['src/bongos/module-store.js']).ok, true, 'a module-store goal may touch module-store.js');
+});

package/tests/module_api.mjs

@@ -65,6 +65,7 @@ const PUBLISHED_SURFACE = [
   'buildInfo', 'validateOrRespond', 'LIMITS', 'parseId', 'asyncHandler', 'corsPublicGet', // parseId added 1.8.0 (BV1.R78); asyncHandler + corsPublicGet added 1.12.0 (BV1.R86; lifecycle routes)
   'parsePagination', 'pageMeta', 'PAGINATION', // R14 (#2001, 1.17.0): shared pagination contract for module list routes (ADR 0119)
   'responsibilityFor', 'ROLE_RESPONSIBILITIES', // added by task 1003732 (ADR 0275; criterion wa6-written-responsibilities): the ONE source for the sentence each craft is answerable for. It rides the doorway because two modules need the same text — grading judges role-shaped work against it, the hall shows it to the person being judged — and modules never import each other. Declared here deliberately: this list is what makes adding to the doorway a decision rather than a side effect
+  'crafts', // added by task 1005141 (BONGOS-V3 C1): the craft vocabulary (src/crafts.js) — artisan · artist · patron and normalizeCraft() for the old spellings (engineer/ideator/builder). On the doorway because every module input boundary that takes a craft (help requests, task discipline, specialities) must read an old word as today's the same way, and modules never import each other
   'readPackageRegistry', // added by task 1004296 (ADR 0340 D5): the npm registry reader moved into the core, because Settings → Software update needs it in every hall; the module that publishes a package reads the same answer and cache through here rather than keeping a second copy
   'logger',
 ];

package/tests/module_contributions.mjs

@@ -169,26 +169,26 @@ test('craft picker options: OTB.disciplines() mirrors the server list, and falls
   const OTB = global.window.OTB;
 
   // the server's list wins, in the server's order
-  global.window.__MODULES__ = { enabled: {}, disciplines: ['engineer', 'ideator', 'ui'] };
-  assert.deepEqual(OTB.disciplines(), ['engineer', 'ideator', 'ui']);
+  global.window.__MODULES__ = { enabled: {}, disciplines: ['artisan', 'artist', 'ui'] };
+  assert.deepEqual(OTB.disciplines(), ['artisan', 'artist', 'ui']);
   // a module-contributed craft is offered without any per-craft moduleOn() branch
-  global.window.__MODULES__ = { enabled: { 'art-pipeline': true }, disciplines: ['engineer', 'ideator', 'artist', 'ui'] };
+  global.window.__MODULES__ = { enabled: { 'art-pipeline': true }, disciplines: ['artisan', 'artist', 'artist', 'ui'] };
   assert.ok(OTB.disciplines().includes('ui') && OTB.disciplines().includes('artist'));
   // withdrawn with its module
-  global.window.__MODULES__ = { enabled: {}, disciplines: ['engineer', 'ideator'] };
-  assert.deepEqual(OTB.disciplines(), ['engineer', 'ideator']);
+  global.window.__MODULES__ = { enabled: {}, disciplines: ['artisan', 'artist'] };
+  assert.deepEqual(OTB.disciplines(), ['artisan', 'artist']);
 
   // an older server that sends no list degrades to the core two, never to an
   // empty picker (which would strand a builder with no way to pick a craft)
   for (const m of [undefined, {}, { enabled: {} }, { disciplines: [] }, { disciplines: 'nope' }]) {
     global.window.__MODULES__ = m;
-    assert.deepEqual(OTB.disciplines(), ['engineer', 'ideator'], `fallback for ${JSON.stringify(m)}`);
+    assert.deepEqual(OTB.disciplines(), ['artisan', 'artist'], `fallback for ${JSON.stringify(m)}`);
   }
 
   // returns a COPY — a picker mutating its options cannot corrupt the global
-  global.window.__MODULES__ = { disciplines: ['engineer', 'ideator', 'ui'] };
+  global.window.__MODULES__ = { disciplines: ['artisan', 'artist', 'ui'] };
   OTB.disciplines().push('bogus');
-  assert.deepEqual(OTB.disciplines(), ['engineer', 'ideator', 'ui']);
+  assert.deepEqual(OTB.disciplines(), ['artisan', 'artist', 'ui']);
 });
 
 test('craft picker options: roleLabel names an acronym correctly', () => {
@@ -199,9 +199,9 @@ test('craft picker options: roleLabel names an acronym correctly', () => {
   require(domUtils);
   const OTB = global.window.OTB;
   assert.equal(OTB.roleLabel('ui'), 'UI', 'not "Ui"');
-  assert.equal(OTB.roleLabel('engineer'), 'Engineer');
+  assert.equal(OTB.roleLabel('artisan'), 'Artisan');
+  assert.equal(OTB.roleLabel('artist'), 'Artist');
   assert.equal(OTB.roleLabel('artist'), 'Artist');
-  assert.equal(OTB.roleLabel('ideator'), 'Ideator');
   // a craft a module adds later needs no new entry here
   assert.equal(OTB.roleLabel('archivist'), 'Archivist');
   for (const bad of ['', null, undefined]) assert.equal(OTB.roleLabel(bad), '');
@@ -253,7 +253,7 @@ test('an unset role is never shown to a person as the database default', () => {
   assert.equal(OTB.ROLE_UNSET, 'unclassified', 'the stored value is unchanged');
   assert.equal(OTB.roleLabel('unclassified'), 'No role yet');
   assert.ok(OTB.roleIsUnset('unclassified') && OTB.roleIsUnset(null) && OTB.roleIsUnset(''));
-  assert.ok(!OTB.roleIsUnset('engineer'));
+  assert.ok(!OTB.roleIsUnset('artisan'));
 
   const readSrc = (p) => readFileSync(path.join(ROOT, p), 'utf8');
   // The role-bearing render sites must not interpolate the raw default into markup.
@@ -271,8 +271,8 @@ test('craft picker options: neither picker hardcodes the craft list any more', (
   for (const p of ['modules/hall-ui/public/settings.js', 'modules/hall-ui/public/setup-gate.js']) {
     const src = read(p);
     assert.ok(/OTB\.disciplines\(\)/.test(src), `${p} builds its options from OTB.disciplines()`);
-    assert.ok(!/\['engineer',\s*'artist',\s*'ideator'\]/.test(src), `${p} no longer hardcodes the craft triple`);
-    assert.ok(!/discBtn\('engineer'/.test(src), `${p} no longer names a craft literally`);
+    assert.ok(!/\['artisan',\s*'artist',\s*'artist'\]/.test(src), `${p} no longer hardcodes the craft triple`);
+    assert.ok(!/discBtn\('artisan'/.test(src), `${p} no longer names a craft literally`);
   }
 });