@bongos/core 1.24.79 → 1.24.80

package/tests/conductor.mjs

@@ -681,7 +681,7 @@ test('selectAutonomousDispatch: GO + feed → picks rows[0] and shapes the claim
   const r = dispatch.selectAutonomousDispatch(
     { decision: 'go', reason: 'signal' },
     [
-      { id: 458, title: 'MAS Phase 4.5', version_id: 'GDS-V4', est_minutes: 120, discipline: 'engineer' },
+      { id: 458, title: 'MAS Phase 4.5', version_id: 'GDS-V4', est_minutes: 120, discipline: 'artisan' },
       { id: 999, title: 'lower priority' },
     ],
   );

package/tests/conductor_main_e2e.mjs

@@ -33,14 +33,14 @@ const SPECIALITY = 'SPECIALITY-CONTRACT: the engineer expert contract.';
 const ARTIST_SPECIALITY = 'ARTIST-CONTRACT: must not appear in an engineering session.';
 
 // The /me payload the hook consumes, in the route's own shape.
-function mePayload({ discipline = 'engineer' } = {}) {
+function mePayload({ discipline = 'artisan' } = {}) {
   return {
     builder: { id: 4242, rank: 'metic' },
     active_claims: [{ task_id: 77, title: 'a claimed task', touches: [], worktree_name: 'task-77', discipline }],
     wandering: { effective_level: 'normal', inject: false, contract: '' },
     interaction: { inject: true, contract: INTERACTION },
     specialities: [
-      { discipline: 'engineer', inject: true, contract: SPECIALITY },
+      { discipline: 'artisan', inject: true, contract: SPECIALITY },
       { discipline: 'artist', inject: true, contract: ARTIST_SPECIALITY },
     ],
   };
@@ -99,7 +99,7 @@ await test('the hook, run as settings.json runs it, injects the interaction prof
 });
 
 await test('the speciality contract for the CLAIMED craft reaches the session, and no other craft\'s', async () => {
-  const r = await runHook(mePayload({ discipline: 'engineer' }));
+  const r = await runHook(mePayload({ discipline: 'artisan' }));
   assert.ok(r.out.includes(SPECIALITY), 'the engineer speciality is injected for an engineering claim');
   assert.ok(!r.out.includes(ARTIST_SPECIALITY), 'the artist contract is not');
 });
@@ -116,17 +116,17 @@ const craftMode = require('../src/bongos/craft-mode.js');
 const MODES = craftMode.readModes();
 function twoTreePayload() {
   const claim = (id, discipline) => ({ task_id: id, title: 't', touches: [], worktree_name: `task-${id}`, discipline, craft_mode: craftMode.describeCraftMode(discipline, MODES) });
-  return { ...mePayload(), specialities: [], active_claims: [claim(77, 'engineer'), claim(88, 'ideator')] };
+  return { ...mePayload(), specialities: [], active_claims: [claim(77, 'artisan'), claim(88, 'artist')] };
 }
 
 await test('a session in a claimed worktree is told its craft\'s pack on the first prompt, and not the other tree\'s', async () => {
   const r = await runHook(twoTreePayload(), { worktree: 'task-77' });
   assert.equal(r.code, 0);
-  assert.ok(r.out.includes('docs/packs/engineer.md'), `the engineer pack pointer reaches the session; stdout was: ${JSON.stringify(r.out.slice(0, 400))}`);
-  assert.ok(!r.out.includes('docs/packs/ideator.md'), 'worktree task-88\'s ideator craft does not');
+  assert.ok(r.out.includes('docs/packs/artisan.md'), `the engineer pack pointer reaches the session; stdout was: ${JSON.stringify(r.out.slice(0, 400))}`);
+  assert.ok(!r.out.includes('docs/packs/artist.md'), 'worktree task-88\'s ideator craft does not');
   const other = await runHook(twoTreePayload(), { worktree: 'task-88' });
-  assert.ok(other.out.includes('docs/packs/ideator.md'));
-  assert.ok(!other.out.includes('docs/packs/engineer.md'));
+  assert.ok(other.out.includes('docs/packs/artist.md'));
+  assert.ok(!other.out.includes('docs/packs/artisan.md'));
 });
 
 await test('outside any claimed worktree no craft is guessed', async () => {

package/tests/copy_desk_flags_db.mjs

@@ -72,7 +72,7 @@ await insertTestBuilders(pool, [
 // 'building': the seeds own the one 'planning' version the partial index allows.
 const VER = 'ZZZ-CDF';
 await pool.query("INSERT INTO versions (id, name, status) VALUES ($1, 'copy desk fixture', 'building') ON CONFLICT (id) DO NOTHING", [VER]);
-await pool.query("INSERT INTO tasks (id, version_id, title, discipline) VALUES ($1, $2, 'copy desk fixture', 'engineer') ON CONFLICT (id) DO NOTHING", [T, VER]);
+await pool.query("INSERT INTO tasks (id, version_id, title, discipline) VALUES ($1, $2, 'copy desk fixture', 'artisan') ON CONFLICT (id) DO NOTHING", [T, VER]);
 
 // Apply the migration verbatim — this also proves it is idempotent, since a
 // migrated DB has already run it.

package/tests/copy_desk_page_approve.mjs

@@ -33,8 +33,8 @@ const { db } = installPageLedger(api, {
   builders: [
     { id: ALICE, github_login: 'alice', display_name: 'Alice', preferred_disciplines: ['artist'] },
     { id: BOB, github_login: 'bob', display_name: 'Bob', preferred_disciplines: ['artist'] },
-    { id: CARL, github_login: 'carl', display_name: 'Carl', preferred_disciplines: ['engineer'] },
-    { id: DAN, github_login: 'dan', display_name: 'Dan', preferred_disciplines: ['engineer'] },
+    { id: CARL, github_login: 'carl', display_name: 'Carl', preferred_disciplines: ['artisan'] },
+    { id: DAN, github_login: 'dan', display_name: 'Dan', preferred_disciplines: ['artisan'] },
   ],
 });
 

package/tests/copy_desk_page_claim.mjs

@@ -29,8 +29,8 @@ const api = require('../src/module-api.js');
 const { db, seen } = installPageLedger(api, {
   builders: [
     { id: '7', github_login: 'alice', display_name: 'Alice', preferred_disciplines: ['artist'] },
-    { id: '8', github_login: 'bob', display_name: 'Bob', preferred_disciplines: ['engineer', 'artist'] },
-    { id: '9', github_login: 'carol', display_name: 'Carol', preferred_disciplines: ['engineer'] },
+    { id: '8', github_login: 'bob', display_name: 'Bob', preferred_disciplines: ['artisan', 'artist'] },
+    { id: '9', github_login: 'carol', display_name: 'Carol', preferred_disciplines: ['artisan'] },
   ],
 });
 const ALICE = '7';

package/tests/copy_desk_page_next.mjs

@@ -30,7 +30,7 @@ const { db } = installPageLedger(api, {
   builders: [
     { id: '7', github_login: 'alice', display_name: 'Alice', preferred_disciplines: ['artist'] },
     { id: '8', github_login: 'bob', display_name: 'Bob', preferred_disciplines: ['artist'] },
-    { id: '9', github_login: 'carol', display_name: 'Carol', preferred_disciplines: ['engineer'] },
+    { id: '9', github_login: 'carol', display_name: 'Carol', preferred_disciplines: ['artisan'] },
   ],
 });
 const ALICE = '7';

package/tests/copy_desk_page_release.mjs

@@ -29,7 +29,7 @@ const CARL = '9';  // the applier, Metic
 const { db } = installPageLedger(api, {
   builders: [
     { id: ALICE, github_login: 'alice', display_name: 'Alice', preferred_disciplines: ['artist'] },
-    { id: CARL, github_login: 'carl', display_name: 'Carl', preferred_disciplines: ['engineer'] },
+    { id: CARL, github_login: 'carl', display_name: 'Carl', preferred_disciplines: ['artisan'] },
   ],
 });
 

package/tests/copy_desk_page_submit.mjs

@@ -208,7 +208,7 @@ try {
       `page-tweak-unplaced/${studioTask().id}/L0005`,
     ]);
     for (const t of eng) {
-      assert.deepEqual([t.status, t.discipline, t.kind, t.version_id, t.goal_id, t.created_by], ['backlog', 'engineer', 'feature', 'V9', '88', ALICE], 'an unplaced line lands in the artist review goal (task 1004819)');
+      assert.deepEqual([t.status, t.discipline, t.kind, t.version_id, t.goal_id, t.created_by], ['backlog', 'artisan', 'feature', 'V9', '88', ALICE], 'an unplaced line lands in the artist review goal (task 1004819)');
       assert.match(t.description, /builders:studio/);
     }
     const quiet = eng.find((t) => t.source_ref.endsWith('/L0005'));
@@ -316,7 +316,7 @@ try {
     assert.equal(eng.title, 'Remove "Every project on this instance, newest first" (landing:projects)');
     assert.match(eng.description, /stop showing a line/);
     assert.match(eng.description, /take it out/);
-    assert.deepEqual([eng.status, eng.discipline], ['backlog', 'engineer']);
+    assert.deepEqual([eng.status, eng.discipline], ['backlog', 'artisan']);
   });
   // Task 1004776: a line that must keep its meaning. The real editor read marks
   // it and says what it must still say; the real submit WARNS (never refuses)

package/tests/core_258_box_session_claims_db.mjs

@@ -102,7 +102,7 @@ async function fixture() {
   const claimFrom = async (source) => {
     const session = await insertRow('builder_sessions', { builder_id: builder.id, token_hash: `${tag}-${source}`, source });
     // discipline + kind: core_247's CHECK refuses the column default (task 1004363).
-    const task = await insertRow('tasks', { title: `${tag} ${source} task`, status: 'shipped', version_id: version.id, discipline: 'engineer', kind: 'feature' });
+    const task = await insertRow('tasks', { title: `${tag} ${source} task`, status: 'shipped', version_id: version.id, discipline: 'artisan', kind: 'feature' });
     const claim = await insertRow('claims', {
       task_id: task.id, builder_id: builder.id, creator_session_id: session.id,
       worktree_name: `${tag}-${source}`, released_at: new Date(), outcome: 'shipped',

package/tests/craft_mode.mjs

@@ -1,7 +1,7 @@
 // tests/craft_mode.mjs — the hall's craft mode picker (task 1004492, goal 1000095 WA6).
 //
 // On entering the hall a picker asks once per session "What are you doing
-// now?" (Building, Artistry, Ideating or Governing); the answer is
+// now?" (Artisan, Artist or Patron — task 1005141); the answer is
 // html[data-craft], and a switch in the top bar changes it without a reload.
 // These cases boot the REAL shell-trail.js + craft-mode.js + shell.js in a DOM
 // stub, in the order every hall page loads them, and drive them the way a
@@ -163,7 +163,7 @@ function boot({ craft = true, session = {}, store = {}, throws = false, optOut =
   };
 }
 
-const MODES = ['building', 'artistry', 'ideating', 'governing'];
+const MODES = ['artisan', 'artist', 'patron'];
 const noSwitch = (html) => html.replace(/<div class="craft-switch[\s\S]*?<\/div>/, '');
 
 test('NO MODE IS THE HALL AS TODAY: with no mode chosen, nothing but the switch differs from a hall without craft modes', () => {
@@ -185,9 +185,10 @@ test('a signed-in builder is asked ONCE per session, and a reload does not ask a
   const html = p.picker().innerHTML;
   assert.match(html, /role="dialog" aria-modal="true"/);
   assert.match(html, /What are you doing now\?/);
-  for (const m of ['building', 'artistry', 'ideating', 'governing']) assert.match(html, new RegExp(`data-craft-pick="${m}"`), `a ${m} door`);
-  assert.equal([...html.matchAll(/data-craft-pick="/g)].length, 4, 'four doors and nothing else to pick');
-  assert.doesNotMatch(html, /legacy/i, 'Legacy mode is gone (owner, 2026-10-04: Building has all those tabs anyway)');
+  for (const m of MODES) assert.match(html, new RegExp(`data-craft-pick="${m}"`), `a ${m} door`);
+  assert.equal([...html.matchAll(/data-craft-pick="/g)].length, 3, 'three doors and nothing else to pick');
+  assert.doesNotMatch(html, /data-craft-pick="ideating"/, 'Ideating folded into Artist (task 1005141): no door of its own');
+  assert.doesNotMatch(html, /legacy/i, 'Legacy mode is gone (owner, 2026-10-04: Building — now Artisan — has all those tabs anyway)');
   p.escape();
   assert.equal(p.picker(), null, 'Escape closes it without choosing');
   assert.equal(p.mode(), undefined, 'and leaves the hall with no mode');
@@ -206,13 +207,13 @@ test('choosing a door sets html[data-craft] for every page of the session, and s
   const session = {}, store = {};
   const p = boot({ session, store });
   p.signIn();
-  p.pick('data-craft-pick', 'ideating');
+  p.pick('data-craft-pick', 'artist');
   assert.equal(p.picker(), null, 'the picker closes');
-  assert.equal(p.mode(), 'ideating');
-  assert.ok(p.events.some((e) => e.type === 'otb:craft' && e.detail.mode === 'ideating'), 'otb:craft fires with the mode');
-  assert.deepEqual(p.pressed(), ['ideating'], 'the switch lights the chosen mode');
+  assert.equal(p.mode(), 'artist');
+  assert.ok(p.events.some((e) => e.type === 'otb:craft' && e.detail.mode === 'artist'), 'otb:craft fires with the mode');
+  assert.deepEqual(p.pressed(), ['artist'], 'the switch lights the chosen mode');
   const next = boot({ session, store });
-  assert.equal(next.mode(), 'ideating', 'the next page of the session reads it before /me answers');
+  assert.equal(next.mode(), 'artist', 'the next page of the session reads it before /me answers');
   assert.equal(store['hall-craft-keep'], undefined, '"Ask me again next session" was ticked, so nothing outlives the session');
   const tomorrow = boot({ store });
   tomorrow.signIn();
@@ -224,25 +225,25 @@ test('unticking "Ask me again next session" keeps the mode for later sessions',
   const store = {};
   const p = boot({ store });
   p.signIn();
-  p.pick('data-craft-pick', 'governing', { askAgain: false });
-  assert.equal(store['hall-craft-keep'], 'governing');
+  p.pick('data-craft-pick', 'patron', { askAgain: false });
+  assert.equal(store['hall-craft-keep'], 'patron');
   const tomorrow = boot({ store });
   tomorrow.signIn();
-  assert.equal(tomorrow.mode(), 'governing', 'the kept mode applies');
+  assert.equal(tomorrow.mode(), 'patron', 'the kept mode applies');
   assert.equal(tomorrow.picker(), null, 'and nobody is asked');
 });
 
-test('THE HEADER SWITCH changes the mode without a reload, and offers the four crafts', () => {
+test('THE HEADER SWITCH changes the mode without a reload, and offers the three crafts', () => {
   const p = boot();
   const opts = [...p.topbar.innerHTML.matchAll(/data-craft-opt="([a-z]+)"/g)].map((m) => m[1]);
-  assert.deepEqual(opts, MODES, 'the four crafts, and no Legacy');
-  p.press('artistry');
-  assert.equal(p.mode(), 'artistry');
-  p.press('building');
-  assert.equal(p.mode(), 'building', 'anyone can switch at any time');
-  assert.deepEqual(p.pressed(), ['building']);
+  assert.deepEqual(opts, MODES, 'the three crafts, and no Legacy or Ideating');
+  p.press('artist');
+  assert.equal(p.mode(), 'artist');
+  p.press('artisan');
+  assert.equal(p.mode(), 'artisan', 'anyone can switch at any time');
+  assert.deepEqual(p.pressed(), ['artisan']);
   assert.equal(p.location.reloads, 0, 'no navigation happened');
-  assert.equal(p.session['hall-craft'], 'building', 'and the session remembers it');
+  assert.equal(p.session['hall-craft'], 'artisan', 'and the session remembers it');
 });
 
 test('a browser that still has Legacy stored falls back to NO MODE (task 1004567)', () => {
@@ -256,31 +257,31 @@ test('a browser that still has Legacy stored falls back to NO MODE (task 1004567
   const kept = boot({ store });
   kept.signIn();
   assert.equal(kept.mode(), undefined, 'a kept Legacy from an earlier session is no mode too');
-  assert.ok(kept.picker(), 'and a new session is asked to pick one of the four');
-  p.press('building');
-  assert.equal(p.mode(), 'building', 'and any of the four can be chosen from there');
+  assert.ok(kept.picker(), 'and a new session is asked to pick one of the three');
+  p.press('artisan');
+  assert.equal(p.mode(), 'artisan', 'and any of the three can be chosen from there');
 });
 
 test('on a phone the switch shows only the current mode, and tapping it opens the picker', () => {
-  const session = { 'hall-craft': 'building' };
+  const session = { 'hall-craft': 'artisan' };
   const p = boot({ session, narrow: true });
-  p.press('building');
+  p.press('artisan');
   assert.ok(p.picker(), 'the current mode opens the picker');
-  assert.equal(p.mode(), 'building', 'without changing the mode');
+  assert.equal(p.mode(), 'artisan', 'without changing the mode');
 });
 
-test('artists start on Artistry: the door is pre-selected and the picker says why', () => {
+test('artists start on Artist: the door is pre-selected and the picker says why', () => {
   const p = boot();
-  p.signIn({ id: 3, rank: 'thetes', main_discipline: 'artist', preferred_disciplines: ['engineer', 'artist'] });
+  p.signIn({ id: 3, rank: 'thetes', main_discipline: 'artist', preferred_disciplines: ['artisan', 'artist'] });
   const html = p.picker().innerHTML;
-  assert.match(html, /craft-door--artistry craft-door--pre"/);
-  assert.match(html, /Artists start on Artistry\./);
+  assert.match(html, /craft-door--artist craft-door--pre"/);
+  assert.match(html, /Artists start here\./);
   const eng = boot();
-  eng.signIn({ id: 4, rank: 'thetes', main_discipline: 'engineer', preferred_disciplines: ['artist'] });
+  eng.signIn({ id: 4, rank: 'thetes', main_discipline: 'artisan', preferred_disciplines: ['artist'] });
   assert.doesNotMatch(eng.picker().innerHTML, /craft-door--pre/, 'a main role that is not artist pre-selects nothing');
   const unset = boot();
   unset.signIn({ id: 5, rank: 'thetes', main_discipline: null, preferred_disciplines: ['artist'] });
-  assert.match(unset.picker().innerHTML, /craft-door--artistry craft-door--pre"/, 'with no main role, the first craft decides');
+  assert.match(unset.picker().innerHTML, /craft-door--artist craft-door--pre"/, 'with no main role, the first craft decides');
 });
 
 test('storage that throws is never asked and never wears a mode', () => {
@@ -291,13 +292,26 @@ test('storage that throws is never asked and never wears a mode', () => {
 });
 
 test('a page can opt out with <body data-craft-mode="off">', () => {
-  const p = boot({ optOut: true, session: { 'hall-craft': 'artistry' } });
+  const p = boot({ optOut: true, session: { 'hall-craft': 'artist' } });
   p.signIn();
   assert.doesNotMatch(p.topbar.innerHTML, /craft-switch/, 'no switch');
   assert.equal(p.picker(), null, 'no picker');
   assert.equal(p.mode(), undefined, 'no mode');
 });
 
+test('a mode stored under its pre-rename id reads as the new craft (task 1005141), this session or kept', () => {
+  const map = { building: 'artisan', artistry: 'artist', ideating: 'artist', governing: 'patron' };
+  for (const [old, now] of Object.entries(map)) {
+    const p = boot({ session: { 'hall-craft': old, 'hall-craft-asked': '1' } });
+    assert.equal(p.mode(), now, `a session's stored ${old} wears ${now}`);
+    p.signIn();
+    assert.equal(p.picker(), null, `${old}: nobody loses their choice to the rename`);
+    assert.deepEqual(p.pressed(), [now]);
+    const kept = boot({ store: { 'hall-craft-keep': old } });
+    assert.equal(kept.mode(), now, `a kept ${old} wears ${now}`);
+  }
+});
+
 test('a stored value that is not a mode is ignored, not trusted', () => {
   const p = boot({ session: { 'hall-craft': '"><img src=x>' }, store: { 'hall-craft-keep': 'admin' } });
   assert.equal(p.mode(), undefined);

package/tests/craft_mode_home.mjs

@@ -1,9 +1,9 @@
 // tests/craft_mode_home.mjs — choosing a craft leaves another craft's page for Home
 // (task 1005067, goal 1000095).
 //
-// Owner, 2026-11-04: a governor on the city who picked Artistry, Ideating or Building
+// Owner, 2026-11-04: a governor on the city who picked Artistry, Ideating or Building (now Artist or Artisan, task 1005141)
 // stayed in the governor's city. Each craft's home is its own dashboard (Home draws it;
-// the street is Governing's for now), so a page that belongs ONLY to other crafts is
+// the street is Patron's, Governing until task 1005141), so a page that belongs ONLY to other crafts is
 // left for Home, while a shared page, a page no craft owns, and Home itself stay put.
 // These cases run the REAL craft-mode.js and drive its own choose(), recording where
 // the hop would go instead of navigating.
@@ -61,58 +61,58 @@ function boot({ page, active = null, govCity = false }) {
 }
 
 test('leaving the governor\'s city for any other craft goes to Home', () => {
-  for (const mode of ['building', 'artistry', 'ideating']) {
+  for (const mode of ['artisan', 'artist']) {
     const { CM, hops } = boot({ page: 'city', active: 'city' });
     CM.choose(mode);
     assert.deepEqual(hops, ['/'], `${mode} from the city goes Home`);
   }
 });
 
-test('the street is Governing\'s own page, so other crafts leave it too', () => {
+test('the street is Patron\'s own page, so other crafts leave it too', () => {
   const { CM, hops } = boot({ page: 'street' });
-  assert.equal(CM.strandedBy('governing'), false);
-  CM.choose('ideating');
+  assert.equal(CM.strandedBy('patron'), false);
+  CM.choose('artist');
   assert.deepEqual(hops, ['/']);
 });
 
-test('choosing Governing on another craft\'s page lands on the street', () => {
+test('choosing Patron on another craft\'s page lands on the street', () => {
   const { CM, hops } = boot({ page: 'studio', active: 'studio', govCity: true });
-  CM.choose('governing');
+  CM.choose('patron');
   assert.deepEqual(hops, ['/builders/street']);
   // without the street's script on the page, Home itself hops to the street
-  assert.equal(boot({ page: 'studio' }).CM.homeHref('governing'), '/');
+  assert.equal(boot({ page: 'studio' }).CM.homeHref('patron'), '/');
 });
 
 test('a page the chosen craft also shows stays put', () => {
-  // goals is in Building, Artistry and Ideating alike
+  // goals is in Artisan and Artist alike
   const { CM, hops } = boot({ page: 'goals', active: 'goals' });
-  CM.choose('ideating');
-  CM.choose('artistry');
+  CM.choose('artist');
+  CM.choose('artisan');
   assert.deepEqual(hops, []);
 });
 
 test('a page every craft keeps, and a page no craft owns, stay put', () => {
   for (const [page, active] of [['roster', 'roster'], ['my-agents', 'my-agents'], ['task', null], ['idea', null]]) {
     const { CM, hops } = boot({ page, active });
-    CM.choose('governing');
-    CM.choose('artistry');
+    CM.choose('patron');
+    CM.choose('artist');
     assert.deepEqual(hops, [], `${page} stays`);
   }
 });
 
 test('Home redraws itself for the craft, so it never hops from here', () => {
   const { CM, hops } = boot({ page: 'home', active: 'home' });
-  CM.choose('artistry');
-  CM.choose('governing');
+  CM.choose('artist');
+  CM.choose('patron');
   assert.deepEqual(hops, []);
 });
 
 // The Economy page (drachmae.html, nav item 'economy') was this case's real example
 // until task 1005046 folded it into the Primer; the rule it pins is unchanged, so a
-// made-up pairing keeps it: the marked nav item (Tasks, Building's alone) is read
-// before the page name (Studio, which Artistry also shows).
+// made-up pairing keeps it: the marked nav item (Tasks, Artisan's alone) is read
+// before the page name (Studio, which Artist also shows).
 test('the nav item wins over the page name', () => {
   const { CM } = boot({ page: 'studio', active: 'work' });
-  assert.equal(CM.strandedBy('artistry'), true);
-  assert.equal(CM.strandedBy('building'), false);
+  assert.equal(CM.strandedBy('artist'), true);
+  assert.equal(CM.strandedBy('artisan'), false);
 });

package/tests/craft_mode_looks.mjs

@@ -1,11 +1,12 @@
 // tests/craft_mode_looks.mjs — each craft mode's look (task 1004495, goal 1000095
 // WA6; direction docs/design/craft-mode-direction.md).
 //
-// Artistry, Ideating and Governing each wear a look: --craft / --craft-on tokens
+// Artist and Patron each wear a look (task 1005141: Artistry and Ideating became Artist,
+// Governing became Patron, Building became Artisan): --craft / --craft-on tokens
 // (light + dark twins) in style.css, the header eyebrow beside the page title and
-// the door's scene framed under the brand. Building and no mode wear
+// the door's scene framed under the brand. Artisan and no mode wear
 // NOTHING — the hall as it always was. These cases run the REAL craft-mode.js over
-// a small DOM and read the REAL style.css, so a look that leaks into Building, a
+// a small DOM and read the REAL style.css, so a look that leaks into Artisan, a
 // plate that is a second copy of the art, or a colour that loses its contrast reds.
 import assert from 'node:assert/strict';
 import { test } from 'node:test';
@@ -19,8 +20,8 @@ const HALL = path.join(ROOT, 'modules/hall-ui/public');
 const CRAFT = fs.readFileSync(path.join(HALL, 'craft-mode.js'), 'utf8');
 const CSS = fs.readFileSync(path.join(HALL, 'style.css'), 'utf8');
 
-const LOOKED = ['artistry', 'ideating', 'governing'];
-const WORDS = { artistry: 'the studio · night', ideating: 'the sky', governing: 'the city' };
+const LOOKED = ['artist', 'patron'];
+const WORDS = { artist: 'the studio · night', patron: 'the city' };
 
 // A small DOM: enough tree for insertBefore / removeChild / nextSibling to be real.
 function node(tag, id, cls) {
@@ -97,24 +98,24 @@ test('each looked mode frames its own door scene under the brand, and names itse
   }
 });
 
-test('BUILDING AND NO MODE WEAR NO LOOK: no eyebrow; Building keeps only the Home plate, showing the city', () => {
+test('ARTISAN AND NO MODE WEAR NO LOOK: no eyebrow; Artisan keeps only the Home plate, showing the city', () => {
   const none = boot();
   assert.equal(none.root.dataset.craft, undefined);
   assert.equal(none.plates().length + none.marks().length, 0, 'no mode draws nothing');
-  for (const m of ['building']) {
+  for (const m of ['artisan']) {
     const p = boot({ 'hall-craft': m });
     assert.equal(p.marks().length, 0, `${m} at boot names no look`);
     assert.equal(p.plates().length, 1, `${m}: the Home plate is there too (task 1005065)`);
     assert.equal(p.plates()[0].getAttribute('data-plate'), m);
-    assert.ok(p.plates()[0].innerHTML.startsWith(p.craft.artHtml('governing')), `${m}: its plate shows the city`);
-    p.craft.choose('governing');
+    assert.ok(p.plates()[0].innerHTML.startsWith(p.craft.artHtml('patron')), `${m}: its plate shows the city`);
+    p.craft.choose('patron');
     assert.equal(p.plates().length, 1);
-    assert.equal(p.plates()[0].getAttribute('data-plate'), 'governing', 'switching mode swaps the plate');
+    assert.equal(p.plates()[0].getAttribute('data-plate'), 'patron', 'switching mode swaps the plate');
     p.craft.choose(m);
     assert.equal(p.marks().length, 0, `switching to ${m} removes the eyebrow`);
     assert.equal(p.plates()[0].getAttribute('data-plate'), m, 'and swaps the plate back');
   }
-  assert.deepEqual(Object.keys(none.craft.LOOKS).sort(), [...LOOKED].sort(), 'only the three crafts have a look');
+  assert.deepEqual(Object.keys(none.craft.LOOKS).sort(), [...LOOKED].sort(), 'only the two looked crafts have a look');
 });
 
 test('the art is drawn once: craft-mode.js has one artHtml and exports it', () => {
@@ -126,11 +127,11 @@ test('the art is drawn once: craft-mode.js has one artHtml and exports it', () =
 // Every selector in style.css that names a craft mode.
 const CRAFT_SELECTORS = [...CSS.matchAll(/data-craft="([a-z]+)"/g)].map((m) => m[1]);
 
-test('style.css names only the three looked modes — Building has no rule at all', () => {
+test('style.css names only the two looked modes — Artisan has no rule at all', () => {
   assert.ok(CRAFT_SELECTORS.length >= 12, `found ${CRAFT_SELECTORS.length} craft selectors`);
   for (const m of CRAFT_SELECTORS) assert.ok(LOOKED.includes(m), `a rule names data-craft="${m}"`);
-  assert.doesNotMatch(CSS, /data-craft="building"/);
-  assert.doesNotMatch(CSS, /data-craft\]/, 'no rule matches ANY mode, which would dress Building too');
+  assert.doesNotMatch(CSS, /data-craft="(building|artisan|artistry|ideating|governing)"/, 'no rule for Artisan, and none left under a pre-rename id');
+  assert.doesNotMatch(CSS, /data-craft\]/, 'no rule matches ANY mode, which would dress Artisan too');
 });
 
 // The token values, light and dark, read from the stylesheet itself.
@@ -165,7 +166,7 @@ test('every mode colour has a light and a dark twin that keep their contrast', (
 });
 
 test('the shared treatment, the eyebrow and the plate are written as the direction says', () => {
-  const looked = 'html:is([data-craft="artistry"], [data-craft="ideating"], [data-craft="governing"])';
+  const looked = 'html:is([data-craft="artist"], [data-craft="patron"])';
   for (const target of ['.craft-switch__opt[aria-pressed="true"]', '.nav-item--active', '.nav-item--active::before', '.app-topbar']) {
     assert.ok(CSS.includes(`${looked} ${target}`), `the looked modes restyle ${target}`);
   }

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