@bongos/core 1.24.78 → 1.24.80

package/tests/craft_mode_nav.mjs

@@ -127,15 +127,16 @@ function boot({ session = {}, local = {}, perms = { 'board.vote.cast': true } }
   };
 }
 
-const CRAFTS = ['building', 'artistry', 'ideating', 'governing'];
+const CRAFTS = ['artisan', 'artist', 'patron'];
 
 test('THE ALWAYS-PRESENT LIST: one shared list, Builders first, then Collab and Profile, inside every mode', () => {
   const { craft } = boot();
   // task 1004685 (the living-city prototype): My agents joins as a PROPOSAL for the
   // owner — every craft has agents, and round-3 board 6 pairs it with the city.
   // task 1005071 (owner, 2026-11-04): Help — the old Docs group — joins, so every craft has the Primer.
-  assert.deepEqual([...craft.ALWAYS_TABS], ['roster', 'collab', 'profile', 'my-agents', 'primer', 'commands', 'atlas', 'modules', 'apidocs'],
-    'Builders (NAV id roster) heads the list (owner, 2026-10-01); Collab and Profile join it (owner, 2026-10-03); My agents (prototype, task 1004685); Help (task 1005071)');
+  // task 1005144 (ADR 0401): My agents and Modules left the sidebar for the one options menu.
+  assert.deepEqual([...craft.ALWAYS_TABS], ['roster', 'collab', 'profile', 'primer', 'commands', 'atlas', 'apidocs'],
+    'Builders (NAV id roster) heads the list (owner, 2026-10-01); Collab and Profile join it (owner, 2026-10-03); Help (task 1005071)');
   for (const m of CRAFTS) {
     const tabs = craft.tabsFor(m);
     assert.ok(Array.isArray(tabs), `${m} has a named tab list`);
@@ -147,8 +148,8 @@ test('THE ALWAYS-PRESENT LIST: one shared list, Builders first, then Collab and
 
 test('every tab a mode names is a real NAV item, and every NAV item lives in some mode', () => {
   const { craft } = boot();
-  // 24 since task 1005051 folded the Roadmap into Goals (a sanity floor, not a count).
-  assert.ok(NAV_IDS.length >= 24, `read ${NAV_IDS.length} NAV ids from shell.js`);
+  // 20 since task 1005144 moved four settings pages into the options menu (a sanity floor, not a count).
+  assert.ok(NAV_IDS.length >= 20, `read ${NAV_IDS.length} NAV ids from shell.js`);
   const named = new Set(CRAFTS.flatMap((m) => craft.tabsFor(m)));
   for (const id of named) assert.ok(NAV_IDS.includes(id), `${id} is a NAV id`);
   // Home is the one exception: in a mode the craft plate IS the Home button
@@ -167,14 +168,14 @@ test('ONE HOME: no mode shows the Home tab, because the plate is Home in every m
   assert.ok(none.showing().includes('home'), 'with no mode there is no plate, so the Home tab shows');
 });
 
-test('Government shows only in Governing, and Governing is the shortest list', () => {
+test('Government shows only in Patron, and Patron is the shortest list', () => {
   const { craft } = boot();
-  assert.ok(GOV_IDS.length >= 5, `read ${GOV_IDS.length} Government ids`);
+  assert.ok(GOV_IDS.length >= 3, `read ${GOV_IDS.length} Government ids`);
   for (const m of CRAFTS) {
-    for (const id of GOV_IDS) assert.equal(craft.tabsFor(m).includes(id), m === 'governing', `${id} in ${m}`);
+    for (const id of GOV_IDS) assert.equal(craft.tabsFor(m).includes(id), m === 'patron', `${id} in ${m}`);
   }
   const lengths = CRAFTS.map((m) => craft.tabsFor(m).filter((id) => !GOV_IDS.includes(id)).length);
-  assert.equal(Math.min(...lengths), lengths[CRAFTS.indexOf('governing')], 'outside its own Government group, Governing shows the fewest tabs');
+  assert.equal(Math.min(...lengths), lengths[CRAFTS.indexOf('patron')], 'outside its own Government group, Patron shows the fewest tabs');
 });
 
 test('NO MODE IS TODAY\'S NAV: every tab the gate allows, nothing marked — and a stored Legacy is no mode', () => {
@@ -196,19 +197,19 @@ test('each mode shows its own tabs, and switching updates the nav live', () => {
     assert.equal(p.root.dataset.craft, m);
     assert.deepEqual(new Set(p.showing()), new Set(p.craft.tabsFor(m)), `${m} shows exactly its list`);
     for (const id of ['roster', 'collab', 'profile']) assert.ok(p.showing().includes(id), `${id} stays in ${m}`);
-    assert.equal(p.headShowing('run-the-project'), m === 'governing', `the Government head shows only where its tabs do (${m})`);
+    assert.equal(p.headShowing('run-the-project'), m === 'patron', `the Government head shows only where its tabs do (${m})`);
   }
-  p.craft.choose('building');
-  assert.deepEqual(new Set(p.showing()), new Set(p.craft.tabsFor('building')), 'back to Building, its tabs return without a reload');
+  p.craft.choose('artisan');
+  assert.deepEqual(new Set(p.showing()), new Set(p.craft.tabsFor('artisan')), 'back to Artisan, its tabs return without a reload');
 });
 
 test('a mode never shows a tab the gate hid, and a later gate pass keeps the mode', () => {
-  const p = boot({ session: { 'hall-craft': 'governing' } });
+  const p = boot({ session: { 'hall-craft': 'patron' } });
   p.signIn('thetes');
-  assert.ok(!p.showing().includes('watch'), 'a thetes in Governing does not get the metic-floored Watch tab');
+  assert.ok(!p.showing().includes('watch'), 'a thetes in Patron does not get the metic-floored Watch tab');
   assert.ok(!p.headShowing('run-the-project'), 'nor its group head');
   // task 1005071: sidebar order — Work, Community, You, Govern, then Help (every craft).
-  assert.deepEqual(p.showing(), ['blockers', 'collab', 'roster', 'profile', 'my-agents', 'city', 'board-room', 'primer', 'commands', 'atlas', 'modules', 'apidocs'], 'what a thetes board member in Governing sees');
+  assert.deepEqual(p.showing(), ['blockers', 'collab', 'roster', 'profile', 'city', 'board-room', 'primer', 'commands', 'atlas', 'apidocs'], 'what a thetes board member in Patron sees');
   p.signIn('archon');
   assert.ok(p.showing().includes('watch'), 'promoted, the gate lets it through and the mode keeps it');
   assert.ok(p.headShowing('run-the-project'), 'and its group head comes back with it, which only a mode pass after the gate can know');
@@ -224,8 +225,8 @@ test('shell.js applies the mode AFTER its gate loop, and style.css hides what th
   assert.doesNotMatch(CRAFT, /\.hidden\s*=/, 'the mode never writes `hidden`, which the gate owns');
 });
 
-// ---------- the Governing fold (owner, 2026-10-08) ----------
-// Governing leads with the City and folds its other own tabs into one dropdown
+// ---------- the Patron fold (owner, 2026-10-08; Governing until task 1005141) ----------
+// Patron leads with the City and folds its other own tabs into one dropdown
 // under it. The fold MOVES nodes, which the parsed sidebar above cannot model, so
 // these cases run the real craft-mode.js against a small working tree: nodes with
 // parents, insertBefore and comments, laid out as shell.js's NAV groups are.
@@ -309,35 +310,36 @@ function bootTree({ mode = null, activeId = null } = {}) {
   return { craft, sidebar, fold, ids, order, byId };
 }
 
-test('GOVERNING LEADS WITH THE CITY: its other tabs fold into one dropdown right under it', () => {
+test('PATRON LEADS WITH THE CITY: its other tabs fold into one dropdown right under it', () => {
   const before = bootTree().order();
-  const p = bootTree({ mode: 'governing' });
+  const p = bootTree({ mode: 'patron' });
   const fold = p.fold();
-  assert.ok(fold, 'the dropdown exists in Governing');
+  assert.ok(fold, 'the dropdown exists in Patron');
   assert.equal(p.byId('nav-city').nextSibling, fold, 'directly under the City tab');
-  const own = p.craft.tabsFor('governing').filter((id) => !p.craft.ALWAYS_TABS.includes(id) && id !== 'city');
-  assert.deepEqual(JSON.parse(JSON.stringify(p.ids(fold))), JSON.parse(JSON.stringify(own)), 'every other Governing tab is in it, in the mode\'s order');
+  const own = p.craft.tabsFor('patron').filter((id) => !p.craft.ALWAYS_TABS.includes(id) && id !== 'city');
+  assert.deepEqual(JSON.parse(JSON.stringify(p.ids(fold))), JSON.parse(JSON.stringify(own)), 'every other Patron tab is in it, in the mode\'s order');
   assert.ok(fold.classList.contains('nav-group--collapsed'), 'a dropdown starts closed');
   const head = fold.querySelector('.nav-group__head');
   assert.equal(head.getAttribute('aria-expanded'), 'false');
   assert.equal(head.getAttribute('aria-controls'), 'nav-items-craft-fold', 'the head names the region it opens');
-  assert.match(head.innerHTML, /More governing/);
+  // "More governing" until task 1005141; "More patron" does not read, so the label is plain "More".
+  assert.match(head.innerHTML, /<span class="nav-group__head-label">More<\/span>/);
   assert.ok(head.hasAttribute('data-craft-off') === false, 'its head shows while a tab inside does');
   assert.ok(p.sidebar.querySelectorAll('.nav-group__head').find((h) => h.dataset.group === 'run-the-project').hasAttribute('data-craft-off'),
     'the emptied Government head hides, so no label sits over nothing');
-  p.craft.choose('building');
-  assert.equal(p.fold(), null, 'leaving Governing removes the dropdown');
+  p.craft.choose('artisan');
+  assert.equal(p.fold(), null, 'leaving Patron removes the dropdown');
   assert.deepEqual(p.order(), before, 'and puts every tab back exactly where it was');
-  p.craft.choose('governing');
-  p.craft.choose('governing');
+  p.craft.choose('patron');
+  p.craft.choose('patron');
   assert.equal(p.sidebar.querySelectorAll('.craft-fold').length, 1, 'choosing it again builds no second dropdown');
 });
 
 test('the dropdown opens on its own when the page you are on is inside it', () => {
-  const p = bootTree({ mode: 'governing', activeId: 'watch' });
+  const p = bootTree({ mode: 'patron', activeId: 'watch' });
   assert.ok(!p.fold().classList.contains('nav-group--collapsed'), 'on Watch, the dropdown is open');
   assert.equal(p.fold().querySelector('.nav-group__head').getAttribute('aria-expanded'), 'true');
-  assert.equal(bootTree({ mode: 'artistry' }).fold(), null, 'no other mode folds anything');
+  assert.equal(bootTree({ mode: 'artist' }).fold(), null, 'no other mode folds anything');
   assert.equal(bootTree().fold(), null, 'nor does no mode');
 });
 

package/tests/craft_review_mode.mjs

@@ -1,7 +1,7 @@
 // tests/craft_review_mode.mjs — artist review mode (task 1004686, goal 1000095).
 //
-// Owner ask, 2026-10-09: the artist picks one of the four experiences (Ideator,
-// Governing, Building, Artistry) and reviews the hall in that mode's view, with
+// Owner ask, 2026-10-09: the artist picks one of the experiences (since task 1005141
+// the three: Patron, Artisan, Artist — Ideator folded into Artist) and reviews the hall in that mode's view, with
 // graffiti across the top bar's empty space while it lasts. Since task 1004771
 // the choice lives in the docked review panel's own Review mode row
 // (page-notes.js; tests/page_notes_panel.mjs runs that row), not a top-bar menu. These cases run the REAL
@@ -97,30 +97,30 @@ function boot({ session = {}, store = {}, narrow = false } = {}) {
     tools: () => all(side).filter((n) => n.hasAttribute('data-craft-tool')).map((n) => n.id.replace('craft-tool-', '')),
   };
 }
-const artist = () => ({ 'hall-craft': 'artistry', 'hall-craft-asked': '1' });
+const artist = () => ({ 'hall-craft': 'artist', 'hall-craft-asked': '1' });
 
-test('NO TOP-BAR REVIEW BUTTON: in Artistry the bar holds Edit words alone, and no review-mode menu', async () => {
+test('NO TOP-BAR REVIEW BUTTON: in Artist the bar holds Edit words and Ideas, and no review-mode menu', async () => {
   const p = boot({ session: artist() });
   await flush();
-  assert.deepEqual(p.tools(), ['paintbrush'], 'the review panel docks at the edge instead (task 1004771)');
+  assert.deepEqual(p.tools(), ['paintbrush', 'lightbulb'], 'the review panel docks at the edge instead (task 1004771); the lightbulb joined from Ideating (task 1005141)');
   assert.equal(p.byId('craft-review'), null, 'no split pill');
   assert.equal(p.byId('craft-review-menu'), null, 'no menu');
   assert.deepEqual(p.opened, ['dock']);
   assert.equal(p.byId('craft-graffiti'), null, 'no wall until a review starts');
   assert.equal(p.root.getAttribute('data-craft-review'), null);
-  assert.deepEqual(JSON.parse(JSON.stringify(p.craft.experiences().map((x) => x.label))), ['Ideator experience', 'Governing experience', 'Building experience', 'Artistry experience'], 'the four, in the owner\'s order and words, for the review panel row');
+  assert.deepEqual(JSON.parse(JSON.stringify(p.craft.experiences().map((x) => x.label))), ['Patron experience', 'Artisan experience', 'Artist experience'], 'the three, in the owner\'s order (Ideator folded into Artist), for the review panel row');
 });
 
 test('PICKING an experience: the hall wears that mode, the artist keeps the Review tools, and the wall goes up', async () => {
   const p = boot({ session: artist() });
-  p.craft.review('governing');
-  assert.equal(p.root.dataset.craft, 'governing', 'the hall wears Governing: its tabs, look and tallies follow');
-  assert.equal(p.root.getAttribute('data-craft-review'), 'governing');
-  assert.equal(p.craft.current(), 'governing');
-  assert.equal(p.craft.reviewing(), 'governing');
-  assert.equal(p.session['hall-craft'], 'artistry', 'the artist\'s own mode stays Artistry');
-  assert.equal(p.session['hall-craft-review'], 'governing', 'the review lasts the session');
-  assert.deepEqual(p.tools(), ['paintbrush'], 'Edit words stays in the bar');
+  p.craft.review('patron');
+  assert.equal(p.root.dataset.craft, 'patron', 'the hall wears Patron: its tabs, look and tallies follow');
+  assert.equal(p.root.getAttribute('data-craft-review'), 'patron');
+  assert.equal(p.craft.current(), 'patron');
+  assert.equal(p.craft.reviewing(), 'patron');
+  assert.equal(p.session['hall-craft'], 'artist', 'the artist\'s own mode stays Artist');
+  assert.equal(p.session['hall-craft-review'], 'patron', 'the review lasts the session');
+  assert.deepEqual(p.tools(), ['paintbrush', 'lightbulb'], 'the artist\'s tools stay in the bar');
   await flush();
   assert.ok(p.opened.filter((x) => x === 'dock').length >= 2, 'the docked panel is told again, so its mode row repaints');
   const wall = p.byId('craft-graffiti');
@@ -135,50 +135,55 @@ test('PICKING an experience: the hall wears that mode, the artist keeps the Revi
 });
 
 test('IT LASTS THE SESSION: a reload keeps the review; a new session starts without one', () => {
-  const session = { ...artist(), 'hall-craft-review': 'ideating' };
+  const session = { ...artist(), 'hall-craft-review': 'artisan' };
   const p = boot({ session });
-  assert.equal(p.root.dataset.craft, 'ideating', 'a reload wears the experience under review');
-  assert.match(p.side.innerHTML, /data-craft-opt="ideating" aria-pressed="true"/, 'the switch shows the experience being worn');
+  assert.equal(p.root.dataset.craft, 'artisan', 'a reload wears the experience under review');
+  assert.match(p.side.innerHTML, /data-craft-opt="artisan" aria-pressed="true"/, 'the switch shows the experience being worn');
   assert.ok(p.byId('craft-graffiti'), 'the wall goes straight back up');
-  const fresh = boot({ session: {}, store: { 'hall-craft-keep': 'artistry' } });
-  assert.equal(fresh.root.dataset.craft, 'artistry', 'a new session is the artist\'s own Artistry');
+  const fresh = boot({ session: {}, store: { 'hall-craft-keep': 'artist' } });
+  assert.equal(fresh.root.dataset.craft, 'artist', 'a new session is the artist\'s own Artist');
   assert.equal(fresh.byId('craft-graffiti'), null);
-  const notArtist = boot({ session: { 'hall-craft': 'building', 'hall-craft-asked': '1', 'hall-craft-review': 'governing' } });
-  assert.equal(notArtist.root.dataset.craft, 'building', 'a stored review outside Artistry is ignored: only an artist reviews');
+  const notArtist = boot({ session: { 'hall-craft': 'artisan', 'hall-craft-asked': '1', 'hall-craft-review': 'patron' } });
+  assert.equal(notArtist.root.dataset.craft, 'artisan', 'a stored review outside Artist is ignored: only an artist reviews');
   assert.equal(notArtist.craft.reviewing(), null);
   const junk = boot({ session: { ...artist(), 'hall-craft-review': 'legacy' } });
-  assert.equal(junk.root.dataset.craft, 'artistry', 'a review that is not one of the four reads as none');
+  assert.equal(junk.root.dataset.craft, 'artist', 'a review that is not one of the three reads as none');
 });
 
-test('REVIEWING Ideating shows its own tool too, marked a guest so a tiny phone can fold it away', () => {
+// Ideating folded into Artist (task 1005141): the lightbulb is the artist's OWN tool now,
+// so reviewing another experience brings no guest — Patron and Artisan carry no tool.
+test('REVIEWING another experience keeps the artist\'s own tools, the lightbulb among them, and none is a guest', () => {
   const p = boot({ session: artist() });
-  p.craft.review('ideating');
-  assert.deepEqual(p.tools(), ['paintbrush', 'lightbulb'], 'the artist\'s tool, then the experience\'s own, in order');
-  assert.ok(p.byId('craft-tool-lightbulb').classList.contains('craft-tool--guest'));
-  assert.ok(!p.byId('craft-tool-paintbrush').classList.contains('craft-tool--guest'));
-  p.craft.choose('ideating');
-  assert.deepEqual(p.tools(), ['lightbulb'], 'choosing Ideating for real drops the artist\'s tools');
-  assert.ok(!p.byId('craft-tool-lightbulb').classList.contains('craft-tool--guest'), 'and the lightbulb is no guest any more');
+  for (const x of ['patron', 'artisan']) {
+    p.craft.review(x);
+    assert.deepEqual(p.tools(), ['paintbrush', 'lightbulb'], `reviewing ${x}: the artist's tools, in order`);
+    for (const t of ['paintbrush', 'lightbulb']) assert.ok(!p.byId('craft-tool-' + t).classList.contains('craft-tool--guest'), `${t} is the artist's own, never a guest`);
+  }
+  p.craft.choose('artisan');
+  assert.deepEqual(p.tools(), [], 'choosing Artisan for real drops the artist\'s tools');
+  p.craft.choose('artist');
+  assert.deepEqual(p.tools(), ['paintbrush', 'lightbulb'], 'and Artist brings both back');
+  assert.ok(!p.byId('craft-tool-lightbulb').classList.contains('craft-tool--guest'));
 });
 
 test('ENDING it: Stop reviewing, or any mode from the switch, puts the artist back and takes the wall down', () => {
   const p = boot({ session: artist() });
-  p.craft.review('building');
-  assert.equal(p.root.dataset.craft, 'building');
+  p.craft.review('artisan');
+  assert.equal(p.root.dataset.craft, 'artisan');
   p.craft.stopReview();
-  assert.equal(p.root.dataset.craft, 'artistry', 'Stop reviewing is back in Artistry');
+  assert.equal(p.root.dataset.craft, 'artist', 'Stop reviewing is back in Artist');
   assert.equal(p.root.getAttribute('data-craft-review'), null);
   assert.equal(p.byId('craft-graffiti'), null, 'the wall comes down');
   assert.equal(p.session['hall-craft-review'], undefined, 'and the session forgets it');
-  p.craft.review('governing');
-  p.craft.choose('artistry');
-  assert.equal(p.craft.reviewing(), null, 'choosing a mode from the switch, even Artistry, ends a review');
+  p.craft.review('patron');
+  p.craft.choose('artist');
+  assert.equal(p.craft.reviewing(), null, 'choosing a mode from the switch, even Artist, ends a review');
   assert.equal(p.byId('craft-graffiti'), null);
-  p.craft.review('governing');
-  p.craft.choose('governing');
-  assert.equal(p.root.dataset.craft, 'governing');
-  assert.equal(p.root.getAttribute('data-craft-review'), null, 'Governing chosen for real is not a review');
-  assert.ok(p.opened.includes('close'), 'and the review panel leaves with Artistry');
+  p.craft.review('patron');
+  p.craft.choose('patron');
+  assert.equal(p.root.dataset.craft, 'patron');
+  assert.equal(p.root.getAttribute('data-craft-review'), null, 'Patron chosen for real is not a review');
+  assert.ok(p.opened.includes('close'), 'and the review panel leaves with Artist');
 });
 
 test('THE WALL is scribbled in CSS only, in ink alone, and stands still under reduced motion', () => {

package/tests/crafts_vocabulary.mjs

@@ -0,0 +1,70 @@
+// tests/crafts_vocabulary.mjs
+//
+// Unit test for src/crafts.js (task 1005141, BONGOS-V3 C1) — the ONE place the
+// craft vocabulary lives: artisan (was engineer), artist (absorbed ideator) and
+// patron, plus normalizeCraft() that every input boundary runs an old spelling
+// through. Pure, no database. Run: node tests/crafts_vocabulary.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const crafts = require('../src/crafts.js');
+const { normalizeCraft, normalizeCrafts } = crafts;
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.message}`); }
+}
+
+test('the module exports only the two functions callers use (knip ratchet)', () => {
+  assert.deepEqual(Object.keys(crafts).sort(), ['normalizeCraft', 'normalizeCrafts']);
+});
+
+test('normalizeCraft maps every old spelling to today\'s', () => {
+  assert.equal(normalizeCraft('engineer'), 'artisan');
+  assert.equal(normalizeCraft('builder'), 'artisan', 'the old help-request spelling');
+  assert.equal(normalizeCraft('building'), 'artisan', 'the old hall craft-mode id');
+  assert.equal(normalizeCraft('ideator'), 'artist', 'ideation folded into artist');
+  assert.equal(normalizeCraft('ideating'), 'artist');
+  assert.equal(normalizeCraft('artistry'), 'artist');
+  assert.equal(normalizeCraft('governing'), 'patron');
+});
+
+test('normalizeCraft leaves today\'s words alone and is case/space tolerant', () => {
+  for (const c of ['artisan', 'artist', 'patron', 'ui']) assert.equal(normalizeCraft(c), c);
+  assert.equal(normalizeCraft('  Engineer '), 'artisan');
+  assert.equal(normalizeCraft('IDEATOR'), 'artist');
+});
+
+test('an unknown word passes through, so a module-contributed craft is never eaten', () => {
+  assert.equal(normalizeCraft('wizard'), 'wizard');
+  assert.equal(normalizeCraft('sound-design'), 'sound-design');
+  // Inherited Object keys are not legacy spellings.
+  assert.equal(normalizeCraft('constructor'), 'constructor');
+  assert.equal(normalizeCraft('toString'), 'tostring');
+});
+
+test('non-strings pass through untouched for the caller to validate', () => {
+  assert.equal(normalizeCraft(null), null);
+  assert.equal(normalizeCraft(undefined), undefined);
+  assert.equal(normalizeCraft(7), 7);
+});
+
+test('normalizeCrafts dedupes the fold in first-seen order', () => {
+  assert.deepEqual(normalizeCrafts(['artist', 'ideator']), ['artist'], 'one craft now, not two');
+  assert.deepEqual(normalizeCrafts(['ideator', 'engineer', 'artist']), ['artist', 'artisan']);
+  assert.deepEqual(normalizeCrafts(['engineer', 'ui', 'artisan']), ['artisan', 'ui']);
+  assert.deepEqual(normalizeCrafts([]), []);
+  assert.equal(normalizeCrafts(null), null, 'a non-array passes through');
+});
+
+test('the doorway exposes the same module', () => {
+  const api = require('../src/module-api.js');
+  assert.equal(api.crafts, crafts);
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);

package/tests/cross_discipline_priority_direction.mjs

@@ -40,13 +40,13 @@ const eachImpl = (rows, prefs, limit, check) => {
   for (const [name, out] of bothRank(rows, prefs, limit)) check(out, name);
 };
 
-// A claimable row. discipline defaults OUTSIDE the caller's prefs (['engineer'])
+// A claimable row. discipline defaults OUTSIDE the caller's prefs (['artisan'])
 // so the partition step never eats the fixture; credits/minutes are equal by
 // default so priority is the only live sort key unless a test says otherwise.
 const row = (id, priority, extra = {}) => ({
   id, priority, discipline: 'design', credits_reward: 10, est_minutes: 10, ...extra,
 });
-const PREFS = ['engineer'];
+const PREFS = ['artisan'];
 const ids = (out) => out.map((t) => t.id);
 
 const { test, summary } = makeRunner();
@@ -129,7 +129,7 @@ await test('shorter est_minutes, then id, break the remaining ties', () => {
 
 await test('partitioning is unchanged: outside-prefs only, no unclassified, empty prefs → []', () => {
   const rows = [
-    row('mine', 1, { discipline: 'engineer' }),
+    row('mine', 1, { discipline: 'artisan' }),
     row('untriaged', 1, { discipline: 'unclassified' }),
     row('theirs', 4, { discipline: 'design' }),
   ];
@@ -142,7 +142,7 @@ await test('partitioning is unchanged: outside-prefs only, no unclassified, empt
 });
 
 await test('the two copies agree row-for-row on a mixed corpus', () => {
-  const disciplines = ['design', 'ops', 'research', 'engineer', 'unclassified'];
+  const disciplines = ['design', 'ops', 'research', 'artisan', 'unclassified'];
   const priorities = [1, 2, 3, 4, 5, null, undefined, '', '2', 'junk'];
   const rows = [];
   for (let i = 0; i < 60; i++) {
@@ -152,7 +152,7 @@ await test('the two copies agree row-for-row on a mixed corpus', () => {
       est_minutes: (i % 4) * 15,
     }));
   }
-  const [[, fromCanonical], [, fromMirror]] = bothRank(rows, ['engineer'], 25);
+  const [[, fromCanonical], [, fromMirror]] = bothRank(rows, ['artisan'], 25);
   assert.ok(fromCanonical.length > 5, 'fixture must actually exercise the ranking');
   assert.deepEqual(ids(fromMirror), ids(fromCanonical),
     'start.js is a hand-copied mirror — it must produce the identical order');

package/tests/fitness.mjs

@@ -150,18 +150,16 @@ test('role pack guard actually CATCHES a missing pack, a pointerless entry, and
 
   // (1) the silent runtime failure: a pack path that resolves to nothing.
   const missing = rolePacks.checkRolePacks(withRegistry({
-    engineer: { pack: 'docs/packs/__gone__.md', directive: 'x' },
+    artisan: { pack: 'docs/packs/__gone__.md', directive: 'x' },
     artist: { pack: 'docs/packs/artist.md', directive: 'x' },
-    ideator: { pack: 'docs/packs/ideator.md', directive: 'x' },
   }));
   assert.equal(missing.hardFail, true, 'a pack that is not in the tree must hard-fail');
   assert.ok(missing.violations.some((v) => /__gone__/.test(v) && /not in the tree/.test(v)), 'the violation must name the unresolvable path');
 
   // (2) an entry routing a claim to no playbook at all.
   const pointerless = rolePacks.checkRolePacks(withRegistry({
-    engineer: { pack: 'docs/packs/engineer.md', directive: 'x' },
+    artisan: { pack: 'docs/packs/artisan.md', directive: 'x' },
     artist: { pack: 'docs/packs/artist.md', directive: 'x' },
-    ideator: { pack: 'docs/packs/ideator.md', directive: 'x' },
     ui: { directive: 'x' },
   }));
   assert.equal(pointerless.hardFail, true, 'an entry with neither pack nor skill must hard-fail');
@@ -169,21 +167,19 @@ test('role pack guard actually CATCHES a missing pack, a pointerless entry, and
 
   // (3) a craft quietly dropped back into the kernel — the split's own shape.
   const short = rolePacks.checkRolePacks(withRegistry({
-    engineer: { pack: 'docs/packs/engineer.md', directive: 'x' },
-    artist: { pack: 'docs/packs/artist.md', directive: 'x' },
-    ideator: { skill: 'ideate', directive: 'x' },
+    artisan: { pack: 'docs/packs/artisan.md', directive: 'x' },
+    artist: { skill: 'ideate', directive: 'x' },
   }));
-  assert.equal(short.hardFail, true, 'fewer than three packs must hard-fail');
-  assert.ok(short.violations.some((v) => /only 2 craft/.test(v)));
+  assert.equal(short.hardFail, true, 'fewer than two packs must hard-fail (task 1005141: Artisan + Artist)');
+  assert.ok(short.violations.some((v) => /only 1 craft/.test(v)));
 
   // (4) an over-budget pack — the "CI budgets each pack" half of the criterion.
   const fat = rolePacks.checkRolePacks({
     readFileSync: (p, e) => {
       if (String(p).includes('discipline-modes.json')) {
         return JSON.stringify({ modes: {
-          engineer: { pack: 'docs/packs/engineer.md', directive: 'x' },
+          artisan: { pack: 'docs/packs/artisan.md', directive: 'x' },
           artist: { pack: 'docs/packs/artist.md', directive: 'x' },
-          ideator: { pack: 'docs/packs/ideator.md', directive: 'x' },
         } });
       }
       return 'x'.repeat(rolePacks.PACK_CHAR_HARD_MAX + 1);

package/tests/funded_project_pays_proof_db.mjs

@@ -89,7 +89,7 @@ try {
   await q(`INSERT INTO builders (id,github_id,github_login,display_name,rank) VALUES ($1,$2,$3,'M07 Owner','archon'), ($4,$5,$6,'Ada','archon')`,
     [OWNER, `m07-o-${RUN}`, `m07-owner-${RUN}`, ADA, `m07-a-${RUN}`, `m07-ada-${RUN}`]);
   for (const [id, title] of [[TASK_A, 'Build the paid thing'], [TASK_B, 'Build the second thing'], [TASK_C, 'Build the last thing']]) {
-    await q(`INSERT INTO tasks (id,version_id,title,status,credits_reward,kind,discipline) VALUES ($1,$2,$3,'ready',10,'feature','engineer')`, [id, VER, title]);
+    await q(`INSERT INTO tasks (id,version_id,title,status,credits_reward,kind,discipline) VALUES ($1,$2,$3,'ready',10,'feature','artisan')`, [id, VER, title]);
   }
   await cash(TASK_A, '100'); await cash(TASK_B, '80'); await cash(TASK_C, '40');
   await settings.setSetting(WALL_KEY, 'hold_at_claim', OWNER);

package/tests/genesis_home.mjs

@@ -37,7 +37,7 @@ test('genesis files a task per stage, keyed by a ref that names the step, not it
     assert.equal(plain[s].length, 1);
     assert.equal(plain[s][0].ref, `genesis:${s}`);
     assert.equal(plain[s][0].kind, 'decision');
-    assert.equal(plain[s][0].discipline, 'ideator');
+    assert.equal(plain[s][0].discipline, 'artist');
   }
   const existing = genesisChecklist({ existing: true });
   assert.deepEqual(existing.scope.map((t) => t.ref), ['genesis:scope:existing', 'genesis:scope'],
@@ -229,6 +229,26 @@ test('decide → five stages through the Board Room → alive, and the hall open
   assert.equal((await gh.startFounding(1, w.deps())).reason, 'already_alive', 'genesis happens once');
 });
 
+test('the owner can skip genesis from any stage: no sitting, hall opens, recorded once', async () => {
+  const w = world();
+  assert.equal((await gh.skipGenesis(1, w.deps())).reason, 'not_founding', 'nothing to skip on a project that is not founding');
+  await gh.startFounding(1, w.deps());
+  const r = await gh.skipGenesis(1, w.deps());
+  assert.deepEqual(r, { ok: true, skipped: true, from_stage: 'decide' }, 'skippable while still deciding, no plan needed');
+  assert.equal(await gh.readGenesis(w.deps()), null, 'founding mode is off: the full hall opens');
+  assert.ok(w.store.get(fm.KEYS.ENDED_AT), 'the founding window closed');
+  assert.equal(JSON.parse(w.store.get(fm.KEYS.SKIPPED_AT)).stage, 'decide', 'the record says it was skipped, and from where');
+  assert.equal(w.opened.length, 0, 'the Board Room was never asked');
+  assert.equal((await gh.skipGenesis(1, w.deps())).reason, 'already_alive', 'genesis happens once');
+  assert.equal((await gh.startFounding(1, w.deps())).reason, 'already_alive');
+
+  const mid = world();
+  await gh.startFounding(1, mid.deps());
+  await gh.savePlan({}, 1, mid.deps());
+  assert.equal((await gh.skipGenesis(1, mid.deps())).from_stage, 'scope', 'skippable mid-stage with unfinished tasks');
+  assert.equal(await gh.readGenesis(mid.deps()), null);
+});
+
 test('only the stage in progress can be put to the board', async () => {
   const w = world();
   await gh.startFounding(1, w.deps());

package/tests/github_chip.mjs

@@ -29,8 +29,8 @@ const BAR = read(path.join(LANDING, 'assets', 'hub-bar.js'));
 const HUB = read(path.join(LANDING, 'projects.html'));
 const SHELL = read(path.join(HALL, 'shell.js'));
 const chip = require(path.join(HALL, 'github-chip.js'));
-// the engineer's glyph IS the Building craft's (craft-mode.js ICONS.building)
-const BUILDING = /building: '<path d="([^"]+)"\/>'/.exec(read(path.join(HALL, 'craft-mode.js')))[1];
+// the artisan's glyph IS the Artisan craft's (craft-mode.js ICONS.artisan; Building until task 1005141)
+const BUILDING = /artisan: '<path d="([^"]+)"\/>'/.exec(read(path.join(HALL, 'craft-mode.js')))[1];
 
 // ── a DOM just big enough for the three copies ──────────────────────────────
 class El {
@@ -104,7 +104,7 @@ test('the hall, executed: Google only draws one small link with the engineer gly
   assert.equal(a.href, 'https://example.com/api/bongos/auth/link/github/start');
   assert.equal(a.className, 'gh-chip');
   assert.equal(labelOf(a), 'Link GitHub');
-  assert.equal(svgPath(a), BUILDING, 'the engineer craft’s own glyph');
+  assert.equal(svgPath(a), BUILDING, 'the artisan craft’s own glyph');
   assert.match(a.attrs['aria-label'], /coding/);
 });