@bongos/core 1.24.79 → 1.24.80

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/);
 });