@bongos/core 1.24.79 → 1.24.81

package/tests/update_pill.mjs

@@ -129,7 +129,7 @@ function boot({
   permissions = { 'core.pin.move': true }, update = BEHIND, held = null, status = 200, coreFails = false,
   sw = SW({ kind: 'local', url: '/deploy' }), preview = { instance_id: '41', recommended_version: '1.19.871' },
   post = { ok: true, status: 200, data: { ok: true } }, run = null, version = () => '1.19.861',
-  pathname = '/goals', hash = '', openResult = 'popup',
+  pathname = '/goals', hash = '', openResult = 'popup', dialog = null, later = null, handoff = false,
 } = {}) {
   const ids = new Map();
   const inserted = [];
@@ -138,6 +138,7 @@ function boot({
   const posted = [];
   const store = new Map();
   if (run) store.set('bongos.update.run', JSON.stringify(run));
+  if (later) store.set('bongos.update.later', JSON.stringify(later));
   let pillLoads = 0;
   const listeners = {};
 
@@ -181,7 +182,7 @@ function boot({
         if (tag.onload) tag.onload();
       },
     },
-    documentElement: { dataset: {}, style: {}, setAttribute() {}, classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } } },
+    documentElement: { dataset: handoff ? { handoff: 'on' } : {}, style: {}, setAttribute() {}, classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } } },
     getElementById(id) { if (!ids.has(id)) ids.set(id, el('div')); return ids.get(id); },
     querySelector(sel) { return sel === '#app-topbar .topbar-side' ? side : null; },
     querySelectorAll() { return []; },
@@ -214,6 +215,7 @@ function boot({
     matchMedia: () => ({ matches: false, addEventListener() {} }),
     localStorage: { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, String(v)), removeItem: (k) => store.delete(k) },
     requestAnimationFrame() {}, scrollTo() {}, location, innerWidth: 1280,
+    ...(dialog ? { OTBDialog: dialog } : {}),
     ...timers,
   };
   windowObj.document = documentObj;
@@ -433,3 +435,152 @@ test('a run whose version this page already runs has landed: nothing to say', as
   assert.equal(b.pill(), undefined);
   assert.equal(b.store.has('bongos.update.run'), false);
 });
+
+// ── the pop-up (task 1005191) ─────────────────────────────────────────────────
+// The owner, 2026-11-10: the pill alone was not seen (game mode opens every page without its
+// bars), so an update that is ready also asks, once, in the hall's own dialog.
+
+// A stand-in for OTBDialog.open that keeps what it was handed and lets a case press a button
+// or dismiss it. The real one is run by tests/hall_dialog.mjs.
+function fakeDialog() {
+  const opens = [];
+  return {
+    opens,
+    open(opts) {
+      let resolve;
+      const result = new Promise((r) => { resolve = r; });
+      const on = {};
+      const d = { opts, el: { addEventListener(ev, fn) { (on[ev] ||= []).push(fn); } }, result, close: (v) => resolve(v === undefined ? null : v) };
+      d.press = (i) => {
+        const btn = { getAttribute: (k) => (k === 'data-dialog-value' ? String(i) : null) };
+        for (const fn of on.click || []) fn({ target: { closest: () => btn } });
+        resolve(opts.actions[i].value);
+      };
+      opens.push(d);
+      return d;
+    },
+  };
+}
+
+test('the pop-up is due for a ready update, and not for a version said "later" to inside a day', () => {
+  const now = 10 * P.LATER_MS;
+  assert.equal(P.askDue({ face: 'ready', offered: '1.19.871', later: null, now }), true);
+  assert.equal(P.askDue({ face: 'ready', offered: '1.19.871', later: { v: '1.19.871', at: now - 1000 }, now }), false);
+  assert.equal(P.askDue({ face: 'ready', offered: '1.19.871', later: { v: '1.19.871', at: now - P.LATER_MS }, now }), true, 'a day later it asks again');
+  assert.equal(P.askDue({ face: 'ready', offered: '1.19.872', later: { v: '1.19.871', at: now - 1000 }, now }), true, 'a newer version asks at once');
+  assert.equal(P.askDue({ face: 'ready', offered: '1.19.871', later: { v: '1.19.871', at: now + 5000 }, now }), true, 'a clock that went backwards does not silence it');
+  for (const face of ['held', 'running', 'done', 'none']) assert.equal(P.askDue({ face, offered: '1.19.871', later: null, now }), false, face);
+  assert.equal(P.askDue({ face: 'ready', offered: 'next', later: null, now }), false);
+  const box = new Map();
+  const storage = { getItem: (k) => (box.has(k) ? box.get(k) : null), setItem: (k, v) => box.set(k, v) };
+  P.keepLater(storage, '1.19.871', 5);
+  assert.deepEqual(P.readLater(storage), { v: '1.19.871', at: 5 });
+  box.set(P.LATER_KEY, '{"v":"soon","at":1}');
+  assert.equal(P.readLater(storage), null);
+  assert.doesNotThrow(() => P.keepLater({ setItem() { throw new Error('private'); } }, '1.0.0', 1));
+});
+
+test('an owner who is behind is asked, unprompted, in the hall dialog: what it brings, both versions, two buttons', async () => {
+  const dialog = fakeDialog();
+  const b = boot({ dialog });
+  await settle();
+  assert.equal(dialog.opens.length, 1, 'asked once, without a press');
+  const { opts } = dialog.opens[0];
+  assert.equal(opts.title, 'Update the builders hall?');
+  assert.deepEqual(plain(opts.actions.map((a) => a.label)), ['Later', 'Update now']);
+  const html = opts.body.innerHTML;
+  assert.match(html, /latest changes and bug fixes/);
+  assert.match(html, /Faster boards, and fewer clicks/);
+  assert.match(html, /1\.19\.861<\/span> → <span class="upd-ver">1\.19\.871/);
+  assert.ok(b.pill(), 'the pill is still there');
+  assert.equal(b.requests.filter((r) => r.path === '/api/bongos/software-update').length, 1);
+});
+
+test('Later is remembered for that version, and the next page does not ask again', async () => {
+  const dialog = fakeDialog();
+  const b = boot({ dialog });
+  await settle();
+  dialog.opens[0].press(0);
+  await settle();
+  const kept = JSON.parse(b.store.get('bongos.update.later'));
+  assert.equal(kept.v, '1.19.871');
+  assert.equal(b.requests.some((r) => /core-upgrade$/.test(r.path)), false, 'Later moves nothing');
+  const again = fakeDialog();
+  const next = boot({ dialog: again, later: kept });
+  await settle();
+  assert.equal(again.opens.length, 0);
+  assert.ok(next.pill(), 'the pill still offers it');
+  assert.equal(next.requests.some((r) => r.path === '/api/bongos/software-update'), false, 'and nothing is read for a pop-up that will not open');
+});
+
+test('closing the pop-up any other way is "later" too', async () => {
+  const dialog = fakeDialog();
+  const b = boot({ dialog });
+  await settle();
+  dialog.opens[0].close();
+  await settle();
+  assert.equal(JSON.parse(b.store.get('bongos.update.later')).v, '1.19.871');
+});
+
+test('Update now in the pop-up starts the same update as the card, with the version it showed', async () => {
+  const dialog = fakeDialog();
+  const b = boot({ dialog });
+  await settle();
+  dialog.opens[0].press(1);
+  await settle(5);
+  const post = b.requests.find((r) => /core-upgrade$/.test(r.path));
+  assert.ok(post, 'the platform door was called');
+  assert.deepEqual(plain(post.body), { to: '1.19.871' });
+  assert.equal(b.store.has('bongos.update.later'), false, 'an update taken is not snoozed');
+  assert.match(b.card().innerHTML, /Updating Bongos/, 'and the card opens to say where it has got to');
+});
+
+test('a hosted project: Update now in the pop-up opens the hub window inside the press', async () => {
+  const dialog = fakeDialog();
+  const b = boot({ dialog, sw: SW({ kind: 'hub', url: HUB }) });
+  await settle();
+  assert.equal(b.opened.length, 0);
+  dialog.opens[0].press(1);
+  assert.equal(b.opened.length, 1, 'opened synchronously, so the browser allows it');
+  assert.match(b.opened[0].url, /handoff=1$/);
+});
+
+test('who is not asked: a viewer the door would refuse, the handoff window, the door page, a hall with no dialog', async () => {
+  const refused = fakeDialog();
+  boot({ dialog: refused, sw: SW({ kind: 'local', url: '/deploy' }, { can_update: false }) });
+  const handoff = fakeDialog();
+  boot({ dialog: handoff, handoff: true });
+  const door = fakeDialog();
+  boot({ dialog: door, pathname: '/deploy' });
+  const b = boot();
+  await settle();
+  assert.equal(refused.opens.length, 0);
+  assert.equal(handoff.opens.length, 0);
+  assert.equal(door.opens.length, 0);
+  assert.ok(b.pill(), 'no dialog script: the pill alone, as before');
+});
+
+test('a self-hosted project is told the command, with one button and no Update now', async () => {
+  const dialog = fakeDialog();
+  boot({ dialog, sw: SW({ kind: 'cli' }) });
+  await settle();
+  assert.equal(dialog.opens.length, 1);
+  assert.deepEqual(plain(dialog.opens[0].opts.actions.map((a) => a.label)), ['Close']);
+  assert.match(dialog.opens[0].opts.body.innerHTML, /bongos upgrade/);
+});
+
+test('a held version, or an update already running, is not asked about', async () => {
+  const held = fakeDialog();
+  boot({ dialog: held, held: { version: '1.19.871', message: 'rolled back' } });
+  const running = fakeDialog();
+  boot({ dialog: running, run: { to: '1.19.871', from: '1.19.861', at: Date.now(), via: 'local' } });
+  await settle();
+  assert.equal(held.opens.length, 0);
+  assert.equal(running.opens.length, 0);
+});
+
+test('with the bars away the pill stays on screen and can be pressed', () => {
+  const css = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/style.css'), 'utf8');
+  assert.match(css, /html\[data-fullscreen="on"\] \.topbar-side > :not\(\.fullscreen-toggle\):not\(\.upd-pill\) \{ display: none; \}/);
+  assert.match(css, /html\[data-fullscreen="on"\] \.upd-pill \{\s*pointer-events: auto;/);
+});

package/tests/upkeep_home.mjs

@@ -102,7 +102,7 @@ function loadRoute({ versionStatus = 'building', maintenance = { id: '900', vers
   return { call, created, ensured };
 }
 
-const UPGRADE = { version_id: 'V2', title: 'Upgrade the Bongos core to 1.21.70', description: 'Platform upkeep.', discipline: 'engineer' };
+const UPGRADE = { version_id: 'V2', title: 'Upgrade the Bongos core to 1.21.70', description: 'Platform upkeep.', discipline: 'artisan' };
 
 test('an upgrade filed with kind infra and NO goal lands in the maintenance goal', async () => {
   const { call, created, ensured } = loadRoute();

package/tests/v3_c1_options_proof.mjs

@@ -0,0 +1,145 @@
+// tests/v3_c1_options_proof.mjs — the proof for BONGOS-V3 criterion C1
+// `game-opens-not-navigates` (task 1005145, R05; docs/specs/bongos-v3-game-conversion.md;
+// ADR 0401).
+//
+// The criterion's proof: "a builder signs in, never sees a sidebar, and changes a sound
+// preference, a CLI token and a module toggle without leaving the options menu. A build
+// that kept any old settings page fails this."
+//
+// The walk itself was done by hand in the hall preview on 2026-11-11 (recorded in task
+// 1005145's ship notes). This file pins the parts of that walk a later change could
+// quietly undo, each against the REAL code that does it:
+//   1. The old settings pages are gone: the real server (serve-internal.js, mounted on a
+//      throwaway express app and hit over loopback) answers every old address with a 302
+//      into the menu, and only the menu's own frame (?embed=1) still reaches the old file.
+//   2. No sidebar: the start screen's Start turns game mode on, and every hall page loads
+//      the game-mode file and none opts out of the full-screen switch.
+//   3. The three settings are inside the one menu, each a control on the menu's own screen
+//      or in its frame: the CLI token's button, the module toggle, and the Sound entry.
+//      Sounds are switched off (task 1004554), so Sound shows its note, not a toggle;
+//      ADR 0401 accepted that for this proof until sounds come back.
+//
+// Run:  node --test tests/v3_c1_options_proof.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const read = (f) => fs.readFileSync(path.join(HALL, f), 'utf8');
+const Menu = require(path.join(HALL, 'options-menu.js'));
+
+// The six screens that were pages of their own, and the menu entry each now opens.
+const OLD_TO_ENTRY = {
+  'my-agents': 'my-agents',
+  'project-settings': 'project-settings',
+  modules: 'modules',
+  government: 'permissions',
+  'market-watch-rules': 'market-watch-rules',
+  'market-watch-settings': 'market-watch',
+};
+
+// GET over loopback as the hall's own host (the tests/hall_asset_cache.mjs pattern).
+function get(base, urlPath) {
+  const { port } = new URL(base);
+  return new Promise((resolve, reject) => {
+    const req = http.request(
+      { host: '127.0.0.1', port, path: urlPath, method: 'GET', headers: { host: 'builders.example.test' } },
+      (res) => { res.resume(); res.on('end', () => resolve({ status: res.statusCode, location: res.headers.location || '' })); },
+    );
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+async function withServer(fn) {
+  const express = require('express');
+  const { mountInternalSurfaces } = require('../src/bongos/serve-internal.js');
+  const app = express();
+  mountInternalSurfaces(app);
+  const server = await new Promise((resolve) => { const s = app.listen(0, () => resolve(s)); });
+  try { return await fn(`http://127.0.0.1:${server.address().port}`); }
+  finally { await new Promise((resolve) => server.close(resolve)); }
+}
+
+test('PROOF 1 — no old settings page survives: every old address is sent into the menu by the real server', async () => {
+  await withServer(async (base) => {
+    for (const [old, entry] of Object.entries(OLD_TO_ENTRY)) {
+      for (const p of [`/${old}`, `/${old}.html`]) {
+        const r = await get(base, p);
+        assert.equal(r.status, 302, `${p} must redirect, got ${r.status}`);
+        assert.equal(r.location, `/settings?open=${entry}`, `${p} must open the "${entry}" entry of the menu`);
+      }
+      // the menu's own frame still reaches the screen — except Market Watch settings, which has no page left
+      const framed = await get(base, `/${old}?embed=1`);
+      if (old === 'market-watch-settings') {
+        assert.equal(framed.location, `/settings?open=${entry}`, 'Market Watch settings has no page to frame');
+      } else {
+        assert.ok(!framed.location.startsWith('/settings?open='), `${old}?embed=1 is the menu's frame and must not bounce back to the menu`);
+      }
+    }
+  });
+});
+
+test('PROOF 1 — every one of those entries is a line in the menu an Archon sees, opening that same screen in a frame', () => {
+  const visible = Menu.visibleMenu({ authed: true, rank: 'archon' }, { moduleOn: () => true })
+    .flatMap((g) => g.items);
+  for (const [old, entry] of Object.entries(OLD_TO_ENTRY)) {
+    const line = visible.find((i) => i.id === entry);
+    assert.ok(line, `the menu lists "${entry}" (was /${old})`);
+    if (old !== 'market-watch-settings') assert.equal(line.embed, `/${old}`, `"${entry}" frames /${old}`);
+  }
+});
+
+test('PROOF 2 — no sidebar: Start turns game mode on, and every hall page is in it with no way to opt out', () => {
+  const game = read('shell-game.js');
+  assert.match(game, /set\(true\)/, 'the start screen\'s Start turns game mode on');
+  const pages = fs.readdirSync(HALL).filter((f) => f.endsWith('.html'));
+  const shelled = pages.filter((f) => read(f).includes('id="app-sidebar"') || read(f).includes('id="app-topbar"'));
+  assert.ok(shelled.length >= 25, `expected the hall's shelled pages, saw ${shelled.length}`);
+  for (const f of shelled) {
+    const html = read(f);
+    assert.ok(html.includes('shell-game.js'), `${f} must load shell-game.js, or it never enters game mode and keeps its sidebar`);
+    assert.ok(!/data-fullscreen-switch="off"/.test(html), `${f} opts out of the full-screen switch, so it would keep its sidebar in game mode`);
+  }
+});
+
+test('PROOF 3 — the CLI token: its button is on the menu\'s own Access and keys screen', () => {
+  const menu = Menu.visibleMenu({ authed: true, rank: 'xenos' });
+  const [hit] = Menu.search('cli token', menu);
+  assert.deepEqual([hit.id, hit.anchor], ['access', 'cli'], 'searching "cli token" lands on Access and keys, CLI access');
+  const access = Menu.entries().find((e) => e.id === 'access');
+  assert.equal(access.native, true, 'Access and keys is one of the menu\'s own screens, not a frame of another page');
+  const html = read('settings.html');
+  const section = html.slice(html.indexOf('id="cli-scroll"'), html.indexOf('</section>', html.indexOf('id="cli-scroll"')));
+  assert.match(section, /data-group="access"/, 'the CLI section belongs to the Access and keys group');
+  assert.match(section, /id="cli-reissue-btn"/, 'the re-issue button is in it');
+});
+
+test('PROOF 3 — the module toggle: the Modules entry frames /modules, whose catalogue draws an enable/disable toggle', () => {
+  const thetes = Menu.visibleMenu({ authed: true, rank: 'thetes' });
+  assert.equal(Menu.search('module toggle', thetes)[0].id, 'modules');
+  assert.equal(Menu.entries().find((e) => e.id === 'modules').embed, '/modules');
+  const js = read('modules.js');
+  assert.match(js, /class="ov-toggle mod-toggle" aria-pressed=/, 'the catalogue draws a pressable toggle per module');
+});
+
+test('PROOF 3 — sound: the Sound entry is in the menu, and while sounds are off it says so (ADR 0401)', () => {
+  const menu = Menu.visibleMenu({ authed: true, rank: 'xenos' });
+  assert.equal(Menu.search('sound', menu)[0].id, 'sound');
+  assert.equal(Menu.entries().find((e) => e.id === 'sound').native, true);
+  const html = read('settings.html');
+  for (const id of ['sounds-off-scroll', 'sounds-scroll']) {
+    const at = html.indexOf(`id="${id}"`);
+    assert.ok(at > 0, `#${id} is on the Settings page`);
+    assert.match(html.slice(at, at + 200), /data-group="sound"/, `#${id} is in the Sound group`);
+  }
+  // The toggles come back in the same place: when task 1004554 is undone, #sounds-scroll is
+  // what shows, and it is already inside the menu's Sound entry.
+});

package/tests/visual_review.mjs

@@ -64,7 +64,7 @@ await test('the CLI writes the page and prints its path; a missing image is an e
 
 // ---- the claim-time nudge ----------------------------------------------------
 
-const task = (over = {}) => ({ id: '1', discipline: 'engineer', module_key: null, source: 'manual', touches: [], description: '', ...over });
+const task = (over = {}) => ({ id: '1', discipline: 'artisan', module_key: null, source: 'manual', touches: [], description: '', ...over });
 
 await test('a task that names a page file in its description is told to use /design and get an OK', () => {
   const t = task({ description: 'Where: modules/hall-ui/public/goal-forest-lib.js — NODE_W = 168. Drawing is modules/hall-ui/public/goal-forest-render.js.' });
@@ -102,12 +102,12 @@ await test('claim.js prints the nudge after the craft role line, and cannot fail
 // ---- the rule, where every builder's session reads it ------------------------
 
 await test('all three playbooks carry the rule and the way to show a CLI user the shots', () => {
-  for (const rel of ['docs/packs/engineer.md', 'docs/packs/artist.md', '.claude/skills/design/SKILL.md']) {
+  for (const rel of ['docs/packs/artisan.md', 'docs/packs/artist.md', '.claude/skills/design/SKILL.md']) {
     const doc = read(rel);
     assert.match(doc, /review-sheet\.js/, `${rel} names the helper`);
     assert.match(doc, /2026-09-23/, `${rel} dates the owner decision`);
   }
-  assert.doesNotMatch(read('docs/packs/engineer.md'), /rather than asking a human to look/, 'the old contrary instruction is gone');
+  assert.doesNotMatch(read('docs/packs/artisan.md'), /rather than asking a human to look/, 'the old contrary instruction is gone');
 });
 
 summary();

package/tests/watch_applications_queue.mjs

@@ -167,7 +167,7 @@ async function boot(opts = {}) {
       // the same reason categoryChip is: an undefined helper throws mid-render.
       roleAxisLabel: () => 'Role',
       roleLabel: (d) => (!d ? '' : d === 'unclassified' ? 'No role yet' : d === 'ui' ? 'UI' : d.charAt(0).toUpperCase() + d.slice(1)),
-      roleOptions: () => [{ value: '', label: '— any —' }, { value: 'engineer', label: 'Engineer' }, { value: 'artist', label: 'Artist' }],
+      roleOptions: () => [{ value: '', label: '— any —' }, { value: 'artisan', label: 'Artisan' }, { value: 'artist', label: 'Artist' }],
       roleIsUnset: (d) => !d || d === 'unclassified',
       ROLE_UNSET: 'unclassified',
       escapeHtml,
@@ -196,6 +196,9 @@ async function boot(opts = {}) {
   };
   sandbox.globalThis = sandbox;
   vm.createContext(sandbox);
+  // The GitHub-repository half of the invite box is its own file, loaded before watch.js
+  // exactly as watch.html does.
+  vm.runInContext(fs.readFileSync(path.join(HALL, 'watch-repo-invite.js'), 'utf8'), sandbox, { filename: 'watch-repo-invite.js' });
   vm.runInContext(SRC, sandbox, { filename: 'watch.js' });
   await settle();
 
@@ -421,13 +424,13 @@ const PUBLIC_PROFILE = {
   },
   cross_project: {
     totals: { projects: 3, credits: 4200, works_shipped: 41, karma: 7 },
-    disciplines: ['engineer', 'artist'], last_active: '2026-08-30T00:00:00Z',
+    disciplines: ['artisan', 'artist'], last_active: '2026-08-30T00:00:00Z',
     projects: [], more_projects: 0,
   },
 };
 const SLIVER_PROFILE = {
   view: 'sliver',
-  sliver: { handle: 'quiet', display_name: 'Quiet Person', avatar_url: null, disciplines: ['engineer'], active_recently: true },
+  sliver: { handle: 'quiet', display_name: 'Quiet Person', avatar_url: null, disciplines: ['artisan'], active_recently: true },
 };
 const withProfile = (profile, over = {}) => [{ ...WAITING[0], profile, ...over }];
 
@@ -439,7 +442,7 @@ await test('a PUBLIC applicant renders their record beside the ask', async () =>
   assert.match(text, /I draw maps\./, 'the bio is part of what the public page already shows');
   assert.match(text, /3 projects/);
   assert.match(text, /41 shipped/);
-  assert.match(text, /engineer/);
+  assert.match(text, /artisan/);
 });
 
 await test('a PRIVATE applicant renders the sliver AND says why it is thin', async () => {
@@ -449,7 +452,7 @@ await test('a PRIVATE applicant renders the sliver AND says why it is thin', asy
   const text = block_.textContent;
   assert.match(text, /Private account/,
     'a reviewer must not read the thinness as a poor record — it is a boundary, and applying is what opened even this much');
-  assert.match(text, /engineer/);
+  assert.match(text, /artisan/);
   assert.match(text, /Active recently/);
 });
 

package/tests/watch_sealed_floor.mjs

@@ -119,7 +119,7 @@ async function boot({ answers = {}, fallback = ok({}) } = {}) {
       // the same reason categoryChip is: an undefined helper throws mid-render.
       roleAxisLabel: () => 'Role',
       roleLabel: (d) => (!d ? '' : d === 'unclassified' ? 'No role yet' : d === 'ui' ? 'UI' : d.charAt(0).toUpperCase() + d.slice(1)),
-      roleOptions: () => [{ value: '', label: '— any —' }, { value: 'engineer', label: 'Engineer' }, { value: 'artist', label: 'Artist' }],
+      roleOptions: () => [{ value: '', label: '— any —' }, { value: 'artisan', label: 'Artisan' }, { value: 'artist', label: 'Artist' }],
       roleIsUnset: (d) => !d || d === 'unclassified',
       ROLE_UNSET: 'unclassified',
       escapeHtml,
@@ -147,6 +147,8 @@ async function boot({ answers = {}, fallback = ok({}) } = {}) {
   };
   sandbox.globalThis = sandbox;
   vm.createContext(sandbox);
+  // watch-repo-invite.js loads before watch.js, as watch.html has it.
+  vm.runInContext(fs.readFileSync(path.join(HALL, 'watch-repo-invite.js'), 'utf8'), sandbox, { filename: 'watch-repo-invite.js' });
   vm.runInContext(SRC, sandbox, { filename: 'watch.js' });
   await settle();
 

package/tests/welcome_boot.mjs

@@ -98,23 +98,25 @@ test('the credit links to cloudbongos.com (task 1004953)', () => {
 });
 
 test('the owner\'s role mapping: destination and craft mode', () => {
+  // task 1005141: the game's three characters — Owner became Patron, and the ideator's
+  // door folded into the artist's (one Artist door, to the studio).
+  assert.equal(W.ROLES.length, 3, 'three doors, no separate ideator door');
   const map = Object.fromEntries(W.ROLES.map((r) => [r.id, [r.label, r.room, r.href, r.mode]]));
   assert.deepEqual(map, {
-    owner: ['Owner', 'City', '/city', 'governing'],
-    ideator: ['Ideator', 'Your thinking', '/thinking', 'ideating'],
-    artist: ['Artist', 'Studio', '/studio', 'artistry'],
-    engineer: ['Engineer', 'Home', null, 'building'],
+    patron: ['Patron', 'City', '/city', 'patron'],
+    artist: ['Artist', 'Studio', '/studio', 'artist'],
+    artisan: ['Artisan', 'Home', null, 'artisan'],
   });
   // Every mode is one craft-mode.js knows, so OTBCraftMode.choose can never be handed a stranger.
   const craft = fs.readFileSync(path.join(HALL, 'craft-mode.js'), 'utf8');
   for (const r of W.ROLES) assert.match(craft, new RegExp(`id: '${r.mode}'`), r.mode);
 });
 
-test('the Owner role shows only where Governing is offered', () => {
+test('the Patron role shows only where the Patron mode is offered', () => {
   const ids = (c) => W.rolesFor(c).map((r) => r.id);
-  assert.deepEqual(ids({ offered: (m) => m !== 'governing' }), ['ideator', 'artist', 'engineer'], 'no seat: no Owner');
-  assert.deepEqual(ids({ offered: () => true }), ['owner', 'ideator', 'artist', 'engineer']);
-  assert.deepEqual(ids(null), ['owner', 'ideator', 'artist', 'engineer'], 'no craft mode at all: the four, the pages gate themselves');
+  assert.deepEqual(ids({ offered: (m) => m !== 'patron' }), ['artist', 'artisan'], 'no seat: no Patron');
+  assert.deepEqual(ids({ offered: () => true }), ['patron', 'artist', 'artisan']);
+  assert.deepEqual(ids(null), ['patron', 'artist', 'artisan'], 'no craft mode at all: the three, the pages gate themselves');
 });
 
 test('Home loads the welcome before the shell, and the shell asks it before the craft picker', () => {
@@ -126,6 +128,7 @@ test('Home loads the welcome before the shell, and the shell asks it before the
   assert.ok(at('welcome-boot.css') > 0, 'and its sheet');
   const shell = fs.readFileSync(path.join(HALL, 'shell.js'), 'utf8');
   // task 1005076: and neither is asked while the setup screen holds the builder (tests/setup_flow.mjs).
-  assert.match(shell, /if \(!holdForSetup\(state && state\.builder\) && !\(window\.OTBWelcome && window\.OTBWelcome\.onAccess\(access, state && state\.builder\)\) && CRAFT\) CRAFT\.onAccess\(/,
+  // task 1005147: character creation comes first of all — a builder with no character picks one.
+  assert.match(shell, /if \(!holdForSetup\(state && state\.builder\) && !\(CRAFT && CRAFT\.characterGate && CRAFT\.characterGate\(access, state\)\) && !\(window\.OTBWelcome && window\.OTBWelcome\.onAccess\(access, state && state\.builder\)\) && CRAFT\) CRAFT\.onAccess\(/,
     'the picker is asked only when setup is done and the welcome did not show');
 });

package/tests/welcome_boot_browser.mjs

@@ -1,6 +1,6 @@
 // tests/welcome_boot_browser.mjs — the welcome in a real browser (tasks 1004785, 1004818).
 //
-// WHY. "Once a day", "Skip", "the craft picker does not also open", "Owner only with a seat", the day
+// WHY. "Once a day", "Skip", "the craft picker does not also open", "Patron only with a seat", the day
 // and night paintings and the slow way out are behaviour across the real shell.js, craft-mode.js and
 // welcome-boot.js together — the shell is what decides which of the two greets a builder — so this
 // serves the REAL Home markup, the REAL hall scripts and the REAL paintings from a routed origin
@@ -44,7 +44,7 @@ async function hall({ art = true, reducedMotion = 'no-preference', time = null }
     const p = new URL(route.request().url()).pathname;
     if (p === '/' || p === '/index.html') return route.fulfill({ contentType: 'text/html', body: PAGE });
     if (p === '/api/bongos/auth/web/start') return route.fulfill({ contentType: 'text/html', body: '<!doctype html><title>github</title><p id="auth">sign in</p>' });
-    if (p === '/thinking' || p === '/city') return route.fulfill({ contentType: 'text/html', body: '<!doctype html><title>room</title><p id="room">' + p + '</p>' });
+    if (p === '/studio' || p === '/city') return route.fulfill({ contentType: 'text/html', body: '<!doctype html><title>room</title><p id="room">' + p + '</p>' });
     const ext = path.extname(p);
     if (ext === '.webp' && !art) return route.fulfill({ status: 404, body: '' });
     const f = path.join(HALL, p.replace(/^\/builders\//, ''));
@@ -70,9 +70,9 @@ const signIn = (page, positions) => page.evaluate((pos) => {
   window.OTBShell.applyAccess(me);
   window.OTBShell.applyAccess(me);
 }, positions || null);
-// The seats are settled once the top bar's Governing option says so (hidden, or named by the seat).
+// The seats are settled once the top bar's Patron option (Governing until task 1005141) says so (hidden, or named by the seat).
 const seatsSettled = (page, want) => page.waitForFunction((w) => {
-  const opt = document.querySelector('#craft-switch [data-craft-opt="governing"]');
+  const opt = document.querySelector('#craft-switch [data-craft-opt="patron"]');
   return !!opt && (w === null ? opt.hidden : !opt.hidden && opt.textContent.indexOf(w) !== -1);
 }, want);
 const state = (page) => page.evaluate(() => ({
@@ -190,7 +190,7 @@ test('Escape leaves the welcome at any point', { skip }, async () => {
   await ctx.close();
 });
 
-test('roles: no seat hides Owner; Ideator sets the mode and goes to Your thinking', { skip }, async () => {
+test('roles: no seat hides Patron; Artist sets the mode and goes to the Studio', { skip }, async () => {
   const ctx = await hall();
   const { page } = await open(ctx);
   await signIn(page, { held: [] });
@@ -200,16 +200,16 @@ test('roles: no seat hides Owner; Ideator sets the mode and goes to Your thinkin
   await page.click('[data-wb-roles]');
   await page.waitForSelector('#wb-roles:not([hidden]) [data-wb-role]');
   const roles = await page.evaluate(() => [...document.querySelectorAll('[data-wb-role]')].map((b) => b.getAttribute('data-wb-role')));
-  assert.deepEqual(roles, ['ideator', 'artist', 'engineer']);
+  assert.deepEqual(roles, ['artist', 'artisan'], 'the ideator door folded into Artist (task 1005141)');
   const stored = await Promise.all([
-    page.waitForURL(ORIGIN + '/thinking'),
-    page.click('[data-wb-role="ideator"]'),
+    page.waitForURL(ORIGIN + '/studio'),
+    page.click('[data-wb-role="artist"]'),
   ]).then(() => page.evaluate(() => sessionStorage.getItem('hall-craft')));
-  assert.equal(stored, 'ideating', 'the hall wears Ideating on arrival');
+  assert.equal(stored, 'artist', 'the hall wears Artist on arrival');
   await ctx.close();
 });
 
-test('roles: a seat holder sees Owner; Engineer stays on Home in Building', { skip }, async () => {
+test('roles: a seat holder sees Patron; Artisan stays on Home in Artisan', { skip }, async () => {
   const ctx = await hall();
   const { page } = await open(ctx);
   await signIn(page, { held: [{ kind: 'lead', seat: 'planning', title: 'Planning Lead' }] });
@@ -219,10 +219,10 @@ test('roles: a seat holder sees Owner; Engineer stays on Home in Building', { sk
   await page.click('[data-wb-roles]');
   await page.waitForSelector('#wb-roles:not([hidden]) [data-wb-role]');
   const roles = await page.evaluate(() => [...document.querySelectorAll('[data-wb-role]')].map((b) => b.getAttribute('data-wb-role')));
-  assert.deepEqual(roles, ['owner', 'ideator', 'artist', 'engineer']);
-  await page.click('[data-wb-role="engineer"]');
+  assert.deepEqual(roles, ['patron', 'artist', 'artisan']);
+  await page.click('[data-wb-role="artisan"]');
   await page.waitForSelector('#welcome-boot', { state: 'detached' });
-  assert.deepEqual(await state(page), { welcome: false, picker: false, craft: 'building', asked: '1' });
+  assert.deepEqual(await state(page), { welcome: false, picker: false, craft: 'artisan', asked: '1' });
   assert.equal(new URL(page.url()).pathname, '/');
   await ctx.close();
 });

package/tests/worktree_helper.mjs

@@ -27,7 +27,7 @@ import os from 'node:os';
 import path from 'node:path';
 
 const require = createRequire(import.meta.url);
-const { worktreeNameFor, needsJunction, removalPlan, nodeModulesState, shadowingNodeModules, huskDisposition, unlinkNodeModulesLink } = require('../scripts/bongos/worktree.js');
+const { worktreeNameFor, needsJunction, removalPlan, nodeModulesState, shadowingNodeModules, huskDisposition, unlinkNodeModulesLink, nextStepLines } = require('../scripts/bongos/worktree.js');
 
 const HOUR = 60 * 60 * 1000;
 
@@ -285,6 +285,21 @@ test('in-use outranks every other rule', () => {
     'in use — this session is inside it');
 });
 
+// task 1005185 - feedback bug scripts: on a project that installs the core from npm the
+// worktree has no scripts/ of its own (it is a git-ignored link into node_modules), so the
+// "Next:" hint must name `npx bongos claim`, not a node path that points at nothing.
+test('installed core: the Next hint names npx bongos claim, never a node scripts path', () => {
+  const out = nextStepLines('/p/.claude/worktrees/task-9', { installed: true }).join('\n');
+  eq(/npx bongos claim <task-id>/.test(out), true, 'names npx bongos claim');
+  eq(/node scripts\//.test(out), false, 'no node scripts/ path');
+  eq(out.includes('cd "/p/.claude/worktrees/task-9"'), true, 'still says where to cd');
+});
+
+test('core checkout: the Next hint keeps the node scripts/bongos/claim.js path', () => {
+  const out = nextStepLines('/p/.claude/worktrees/task-9', { installed: false }).join('\n');
+  eq(/node scripts\/bongos\/claim\.js <task-id>/.test(out), true);
+});
+
 console.log('');
 console.log(`worktree_helper: ${passed} passed, ${failed} failed`);
 process.exit(failed > 0 ? 1 : 0);