@bongos/core 1.24.79 → 1.24.80

package/tests/hall_fullscreen.mjs

@@ -93,7 +93,8 @@ function boot({ page = 'thinking', optIn = true, store = {}, storageThrows = fal
     addEventListener() {}, dispatchEvent() {},
     get cookie() { return ''; }, set cookie(_v) {},
   };
-  const location = { hostname: 'h', origin: 'https://h', href: 'https://h/' + page + search, pathname: path || '/' + page, hash, search, assign() {}, replace() {} };
+  const assigned = []; // task 1005144: where the page sent the browser (game mode's Escape opens the menu)
+  const location = { hostname: 'h', origin: 'https://h', href: 'https://h/' + page + search, pathname: path || '/' + page, hash, search, assign(u) { assigned.push(u); }, replace() {} };
   // `session` is the TAB's sessionStorage: pass one object to several boots and
   // they are page loads in one tab (the trail, task 1004476).
   const sessionStorage = {
@@ -133,6 +134,7 @@ function boot({ page = 'thinking', optIn = true, store = {}, storageThrows = fal
   const root = documentObj.documentElement;
   return {
     store,
+    assigned,
     game: () => windowObj.OTBShellGame,
     gameStamp: () => root.dataset.game === 'on',
     // The "how to leave" line: showing = the shell created it and it is not hidden.
@@ -518,8 +520,8 @@ test('game mode: every hall page carries the switch — none opts out, and each
 test('game mode: leaving brings the bars back for THIS page only, and never rewrites a page\'s own memory', () => {
   const store = { 'hall-game': 'on', 'hall-fullscreen:thinking': 'on' };
   const goals = boot({ page: 'goals', optIn: false, store });
-  goals.press('Escape');
-  assert.equal(goals.on(), false, 'Escape still leaves');
+  goals.button().click();
+  assert.equal(goals.on(), false, 'the corner button still leaves (Escape opens the options menu, below)');
   assert.equal(store['hall-fullscreen:goals'], undefined, 'nothing remembered for the page');
   assert.equal(boot({ page: 'goals', optIn: false, store }).on(), true, 'the next load opens without bars again');
   const sky = boot({ page: 'thinking', store });
@@ -528,6 +530,28 @@ test('game mode: leaving brings the bars back for THIS page only, and never rewr
   assert.equal(store['hall-fullscreen:thinking'], 'on', 'the sky\'s own choice survives game mode');
 });
 
+// task 1005144 (BONGOS-V3 R04, ADR 0399 §2.4 row 6): in game mode the last Escape is the
+// options menu's. It opens the menu, remembering where it came from, and the bars stay away.
+test('game mode: the last Escape opens the options menu, and the bars stay hidden', () => {
+  const store = { 'hall-game': 'on' };
+  const goals = boot({ page: 'goals', optIn: false, store, hash: '#/goal/7' });
+  goals.press('Escape');
+  assert.equal(goals.on(), true, 'the shell did not take the press');
+  assert.deepEqual(goals.assigned, ['/settings?from=' + encodeURIComponent('/goals#/goal/7')], 'the menu, and the way back');
+  const apex = boot({ page: 'goals', optIn: false, store, path: '/builders/goals' });
+  apex.press('Escape');
+  assert.deepEqual(apex.assigned, ['/builders/settings?from=' + encodeURIComponent('/builders/goals')], 'on the apex too');
+  const used = boot({ page: 'goals', optIn: false, store });
+  used.press('Escape', { pageUses: true });
+  used.press('Escape', { target: { tagName: 'INPUT' } });
+  assert.deepEqual(used.assigned, [], 'a press a page used, or one in a field, never opens it');
+  const plain = boot({ page: 'goals', optIn: false, store: {} });
+  plain.button().click();
+  plain.press('Escape');
+  assert.deepEqual(plain.assigned, [], 'outside game mode Escape is the shell\'s, as before');
+  assert.equal(plain.on(), false, 'and it leaves full screen');
+});
+
 test('game mode: the Escape hand-off is unchanged — a press the page used, or one in a field, does not leave', () => {
   const p = boot({ page: 'goals', optIn: false, store: { 'hall-game': 'on' } });
   p.press('Escape', { pageUses: true });

package/tests/hall_kit_charts.mjs

@@ -379,7 +379,7 @@ test('the migrated pages run for real against the kit and emit its classes', ()
   assert.equal(typeof s.window.OTBHallRender, 'function', 'the renderer factory survived the migration');
   assert.equal(typeof s.window.OTBKit.barSeriesHtml, 'function');
   assert.match(
-    s.window.OTBKit.barSeriesHtml([{ label: 'engineer', value: 3 }]),
+    s.window.OTBKit.barSeriesHtml([{ label: 'artisan', value: 3 }]),
     /class="kit-bars"/,
   );
 });

package/tests/hall_landing_boot.mjs

@@ -72,7 +72,7 @@ async function boot({ meStatus, settle = false }) {
       // 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',
       moduleOn: () => true,

package/tests/hall_my_agents.mjs

@@ -388,48 +388,48 @@ function bootCraft({ session = {} } = {}) {
 }
 const seatOf = (has, title) => ({ known: true, has_position: has, title: has ? title : null });
 
-test('CRAFT: with no seat, Governing is not offered anywhere', () => {
+test('CRAFT: with no seat, Patron (Governing until task 1005141) is not offered anywhere', () => {
   const b = bootCraft();
   b.craft.setPositions(seatOf(false));
-  assert.match(b.craft.switchHtml(), /data-craft-opt="governing"[^>]* hidden>/, 'the switch hides it');
-  b.craft.choose('governing');
+  assert.match(b.craft.switchHtml(), /data-craft-opt="patron"[^>]* hidden>/, 'the switch hides it');
+  b.craft.choose('patron');
   assert.equal(b.root.dataset.craft, undefined, 'and choosing it does nothing');
   b.craft.open();
   const picker = b.body.children[0];
   assert.ok(picker, 'the picker opened');
-  assert.doesNotMatch(picker.innerHTML, /data-craft-pick="governing"/, 'no Governing door');
-  assert.match(picker.innerHTML, /data-doors="3"/, 'three doors, laid out as three');
+  assert.doesNotMatch(picker.innerHTML, /data-craft-pick="patron"/, 'no Patron door');
+  assert.match(picker.innerHTML, /data-doors="2"/, 'two doors, laid out as two');
 });
 
-test('CRAFT: a stored Governing reads as no mode for a builder known to hold no seat', () => {
+test('CRAFT: a stored Patron — even under its pre-rename id, Governing — reads as no mode for a builder known to hold no seat', () => {
   const b = bootCraft({ session: { 'hall-craft': 'governing' } });
-  assert.equal(b.craft.current(), 'governing', 'unknown seats: today\'s behaviour');
+  assert.equal(b.craft.current(), 'patron', 'unknown seats: today\'s behaviour, the old id read as Patron (task 1005141)');
   b.craft.setPositions(seatOf(false));
   assert.equal(b.craft.current(), null);
   assert.equal(b.session['hall-craft'], undefined, 'and the stored choice is dropped');
 });
 
-test('CRAFT: a seat names the Governing mode', () => {
+test('CRAFT: a seat names the Patron mode', () => {
   const b = bootCraft();
   b.craft.setPositions(seatOf(true, 'Treasury Lead'));
   assert.equal(b.craft.seatName(), 'Treasury Lead');
-  assert.match(b.craft.switchHtml(), /data-craft-opt="governing"[^>]*>[\s\S]*?Treasury Lead<\/span>/);
-  b.craft.choose('governing');
-  assert.equal(b.root.dataset.craft, 'governing');
+  assert.match(b.craft.switchHtml(), /data-craft-opt="patron"[^>]*>[\s\S]*?Treasury Lead<\/span>/);
+  b.craft.choose('patron');
+  assert.equal(b.root.dataset.craft, 'patron');
   b.craft.open();
   assert.match(b.body.children[0].innerHTML, /craft-door__name">Treasury Lead</);
-  assert.match(b.body.children[0].innerHTML, /data-doors="4"/);
+  assert.match(b.body.children[0].innerHTML, /data-doors="3"/);
 });
 
-test('CRAFT: unknown seats are today\'s picker — four doors and a free Governing', () => {
+test('CRAFT: unknown seats are today\'s picker — three doors and a free Patron', () => {
   const b = bootCraft();
   b.craft.setPositions(null);
   assert.equal(b.craft.seatName(), null);
   assert.doesNotMatch(b.craft.switchHtml(), / hidden>/);
-  assert.match(b.craft.switchHtml(), />Governing<\/span>/);
+  assert.match(b.craft.switchHtml(), />Patron<\/span>/);
   b.craft.setPositions({ known: false, has_position: false });
-  b.craft.choose('governing');
-  assert.equal(b.root.dataset.craft, 'governing', 'an unknown answer never takes the mode away');
+  b.craft.choose('patron');
+  assert.equal(b.root.dataset.craft, 'patron', 'an unknown answer never takes the mode away');
 });
 
 // ---------------------------------------------------------------------------

package/tests/hall_nav.mjs

@@ -301,7 +301,8 @@ test('sidebar groups read by audience, in order', () => {
   // how your own Claude works for you, the personal half of "the city steers
   // everyone, My agents steers yours". Its subject is the viewer's own agents.
   // task 1005050: 'standing' (Accomplishments) left — your numbers are the one Profile page.
-  assert.deepEqual(nav[3].items.map((i) => i.id), ['profile', 'my-agents'], 'You = your own numbers and your own agents');
+  // task 1005144 (ADR 0401): 'my-agents' LEFT for the one options menu (the profile chip).
+  assert.deepEqual(nav[3].items.map((i) => i.id), ['profile'], 'You = your own numbers');
   // task 1003444: 'people' LEFT the group — the owner deleted the hall's
   // cross-project directory (ADR 0337 D5); its home is the hub, and /people
   // redirects to /roster. Builders is the hall's directory now.
@@ -324,7 +325,7 @@ test('sidebar groups read by audience, in order', () => {
   // Economy and Diagrams explained what the Primer explains; they are its chapters
   // now, so Docs is the Primer and the four references that are not a document.
   assert.deepEqual(nav[6].items.map((i) => i.id),
-    ['primer', 'commands', 'atlas', 'modules', 'apidocs'], 'Docs = reference material');
+    ['primer', 'commands', 'atlas', 'apidocs'], 'Docs = reference material (Modules is an options menu entry since task 1005144)');
   // 'government' (the Permissions tab, BV1.R113) is the group's one archon-gated item.
   // 'project-settings' joins the Government group at the metic floor (task 1003280,
   // goal 1000072) — it sits before 'government', which is the one archon-only item.
@@ -342,7 +343,12 @@ test('sidebar groups read by audience, in order', () => {
   // idea 1001310). The settings are an owner-only Settings tab on /market-watch now.
   // 'gate' (Autobongos) and 'sessions' LEFT the group in task 1005049 (owner decision
   // 2026-11-03, idea 1001315): they are tabs on Watch, and /gate + /sessions redirect there.
-  assert.deepEqual(nav[5].items.map((i) => i.id), ['watch', 'project-settings', 'money', 'deploy', 'government']);
+  // task 1005144 (ADR 0401): 'project-settings' and 'government' (Permissions) LEFT for the
+  // one options menu; their URLs open it (serve-internal.js RETIRED_TO_OPTIONS).
+  assert.deepEqual(nav[5].items.map((i) => i.id), ['watch', 'money', 'deploy']);
+  for (const gone of ['/my-agents', '/project-settings', '/government', '/modules']) {
+    assert.ok(!nav.flatMap((g) => g.items).some((i) => i.href === gone), `no item points at ${gone}, an options menu entry now`);
+  }
   assert.ok(!nav.flatMap((g) => g.items).some((i) => i.href === '/gate' || i.href === '/sessions'), 'no item points at a page that became a Watch tab');
   // task 1005045: and no label is left twice anywhere in the sidebar, so the next pair
   // fails here instead of in front of the owner.
@@ -792,7 +798,7 @@ test('no glyph path data reads as an IP address to the release leak scan', () =>
 // block (task 1004713). These drive the real shell and the real gov-positions.js.
 
 const tick = () => new Promise((resolve) => setImmediate(resolve));
-const GOVERNING = ['city', 'board-room', 'watch', 'project-settings', 'money', 'deploy', 'government'];
+const GOVERNING = ['city', 'board-room', 'watch', 'money', 'deploy'];
 const lead = (building, title) => ({ kind: 'lead', seat: 'lead:' + building, building, title });
 const block = (held) => ({ held, title: held.length ? held[0].title : null, has_position: held.length > 0 });
 
@@ -821,7 +827,7 @@ test('POSITION: a Lead keeps every governing surface, and the seat names it', as
   const b = await seated({ builder: { id: '424242', rank: 'thetes' }, positions: block([lead('planning', 'Planning Lead')]) });
   assert.equal(b.shell.positions().title, 'Planning Lead');
   // a thetes Lead: the seat opens the governing tabs their rank and permissions allow
-  for (const id of ['board-room', 'city', 'my-agents']) assert.equal(b.navHidden(id), false, `${id} shows`);
+  for (const id of ['board-room', 'city', 'profile']) assert.equal(b.navHidden(id), false, `${id} shows`);
 });
 
 test('POSITION: the fixture viewer holds what the fixture /me says', async () => {
@@ -833,10 +839,10 @@ test('POSITION: the fixture viewer holds what the fixture /me says', async () =>
 
 test('POSITION: a builder with no seat sees no governing surface, and only those go', async () => {
   // an archon the server says holds no seat: rank, craft and permissions do not make one
-  const b = await seated({ builder: { id: '424242', rank: 'archon', preferred_disciplines: ['engineer'] }, positions: block([]) });
+  const b = await seated({ builder: { id: '424242', rank: 'archon', preferred_disciplines: ['artisan'] }, positions: block([]) });
   assert.equal(b.shell.positions().has_position, false);
-  for (const id of ['board-room', 'city', 'watch', 'project-settings', 'government']) assert.equal(b.navHidden(id), true, `${id} hides`);
-  for (const id of ['home', 'work', 'goals', 'my-agents', 'profile', 'primer']) assert.equal(b.navHidden(id), false, `${id} still shows`);
+  for (const id of ['board-room', 'city', 'watch', 'money']) assert.equal(b.navHidden(id), true, `${id} hides`);
+  for (const id of ['home', 'work', 'goals', 'profile', 'primer']) assert.equal(b.navHidden(id), false, `${id} still shows`);
 });
 
 test('POSITION: unknown is today\'s nav — a /me with no positions block hides nothing', async () => {
@@ -859,18 +865,19 @@ test('POSITION: ?as=nobody views the hall with no seat, and can only hide', asyn
   const b = await seated({ builder: me.builder, positions: me.positions, search: '?as=nobody' });
   assert.equal(b.shell.positions().as, 'nobody');
   for (const id of GOVERNING) assert.equal(b.navHidden(id), true, `${id} hides for the stand-in`);
-  assert.equal(b.navHidden('my-agents'), false);
+  assert.equal(b.navHidden('profile'), false);
   // a xenos stand-in stays a xenos: the pretend rank never rises above the real one
   const x = await seated({ builder: { id: '9', rank: 'xenos' }, positions: block([lead('planning', 'Planning Lead')]), search: '?as=nobody' });
   assert.equal(x.navHidden('goal-map'), true, 'a member page stays hidden from a real xenos');
 });
 
-test('My agents draws its own glyph and lands on a real page', () => {
-  const item = parseNav(boot().sidebarHtml).flatMap((g) => g.items).find((i) => i.id === 'my-agents');
-  assert.ok(item, 'the item renders');
-  assert.equal(item.href, '/my-agents');
-  assert.equal(item.gate, 'signed');
-  assert.ok(hrefResolves(item), 'my-agents.html exists');
+// task 1005144 (ADR 0401): My agents, Project settings, Permissions and Modules are entries
+// in the one options menu, reached by the profile chip, which now says so.
+test('the settings pages left the sidebar for the options menu, and the profile chip names it', () => {
+  const html = boot().sidebarHtml;
+  const ids = parseNav(html).flatMap((g) => g.items).map((i) => i.id);
+  for (const gone of ['my-agents', 'project-settings', 'government', 'modules']) assert.ok(!ids.includes(gone), `${gone} is not a nav item`);
+  assert.ok(html.includes('<a class="shell-user" id="shell-user" href="/settings" title="Options" aria-label="Options"'), 'the chip opens the menu and says so');
 });
 
 // task 1005050 (owner decision 2026-11-03, idea 1001315): Accomplishments

package/tests/hall_options_menu.mjs

@@ -0,0 +1,247 @@
+// tests/hall_options_menu.mjs — the ONE options menu (task 1005144, BONGOS-V3 R04,
+// goal 1000141, criterion game-opens-not-navigates; ADR 0401).
+//
+// Every setting and configuration is reached from one vertical, grouped menu with a
+// search box at the top: the Settings page. The screens that were pages of their own
+// (My agents, Project settings, Modules, Permissions, Market Watch's settings and rules)
+// open INSIDE it, in a frame asking for the old address with ?embed=1, and a plain visit
+// to an old address is sent to the menu with that screen open. These run the real
+// options-menu.js (its pure half), the real shell-game.js in a DOM stub, and read the
+// server's redirect map, so a menu entry, its old URL and its frame cannot drift apart.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+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 = createRequire(import.meta.url)(path.join(HALL, 'options-menu.js'));
+const SERVE = fs.readFileSync(path.join(ROOT, 'src', 'bongos', 'serve-internal.js'), 'utf8');
+
+const ids = (menu) => menu.flatMap((g) => g.items.map((i) => i.id));
+const signed = (rank) => ({ authed: true, rank });
+
+test('the menu holds every settings surface: Settings\' own groups and the six screens that were pages', () => {
+  const all = Menu.entries();
+  const embeds = all.filter((e) => e.embed).map((e) => e.embed).sort();
+  assert.deepEqual(embeds, ['/government', '/market-watch', '/market-watch-rules', '/modules', '/my-agents', '/project-settings']);
+  for (const e of all.filter((x) => x.embed)) {
+    assert.ok(fs.existsSync(path.join(HALL, e.embed.slice(1) + '.html')), `${e.embed}.html exists for the frame`);
+  }
+  // every native entry is a real group on the Settings page, and every group has an entry
+  const html = read('settings.html');
+  const groups = new Set([...html.matchAll(/data-group="([a-z-]+)"/g)].map((m) => m[1]));
+  const natives = all.filter((e) => e.native).map((e) => e.id);
+  for (const id of natives) assert.ok(groups.has(id), `#${id} is a Settings group`);
+  for (const g of groups) assert.ok(natives.includes(g), `the ${g} group is reachable from the menu`);
+  // ids are unique, so one address opens one thing
+  assert.equal(new Set(all.map((e) => e.id)).size, all.length);
+});
+
+test('the proof\'s three settings are all in the one menu: a sound, a CLI token and a module toggle', () => {
+  const menu = Menu.visibleMenu(signed('archon'));
+  const hit = (q) => Menu.search(q, menu)[0];
+  assert.equal(hit('sound').id, 'sound');
+  assert.deepEqual([hit('cli token').id, hit('cli token').anchor], ['access', 'cli']);
+  assert.equal(hit('module toggle').id, 'modules');
+});
+
+test('who sees what: the same rank keys the sidebar used, and module and contribution gates', () => {
+  const xenos = ids(Menu.visibleMenu(signed('xenos')));
+  assert.ok(xenos.includes('account') && xenos.includes('my-agents') && xenos.includes('access') && xenos.includes('market-watch-rules'));
+  for (const id of ['modules', 'project-settings', 'permissions', 'market-watch']) assert.ok(!xenos.includes(id), `a xenos does not see ${id}`);
+  const thetes = ids(Menu.visibleMenu(signed('thetes')));
+  assert.ok(thetes.includes('modules') && !thetes.includes('project-settings'), 'Modules from member, as its sidebar item was');
+  const metic = ids(Menu.visibleMenu(signed('metic')));
+  assert.ok(metic.includes('project-settings') && metic.includes('permissions') && !metic.includes('market-watch'));
+  const archon = ids(Menu.visibleMenu(signed('archon')));
+  assert.ok(archon.includes('market-watch'), 'Market Watch settings: the owner, as its tab was');
+  assert.deepEqual(ids(Menu.visibleMenu({ authed: false, rank: 'archon' })), [], 'signed out: nothing');
+  const off = ids(Menu.visibleMenu(signed('archon'), { moduleOn: (k) => k !== 'market-watch' }));
+  assert.ok(!off.includes('market-watch') && !off.includes('market-watch-rules'), 'a module that is off has no entries');
+  assert.ok(!archon.includes('extensions'), 'Extensions only when a module contributed a panel');
+  assert.ok(ids(Menu.visibleMenu(signed('archon'), { contributed: true })).includes('extensions'));
+  // a group with nothing in it is not drawn
+  for (const g of Menu.visibleMenu(signed('xenos'))) assert.ok(g.items.length > 0, `${g.head} has entries`);
+});
+
+test('the search: every word must match, label hits first, and a sub-place says where it is', () => {
+  const menu = Menu.visibleMenu(signed('archon'));
+  assert.deepEqual(Menu.search('', menu), []);
+  assert.deepEqual(Menu.search('zzzz', menu), []);
+  const talk = Menu.search('talks', menu)[0];
+  assert.deepEqual([talk.id, talk.anchor, talk.where], ['my-agents', 'talk', 'Your agents']);
+  assert.equal(Menu.search('PERMISSIONS', menu)[0].id, 'permissions', 'case does not matter');
+  // Enter opens the first line, so the first line must be the place meant
+  assert.equal(Menu.search('token', menu)[0].label, 'CLI access', 'the exact place above the group that holds it');
+  assert.equal(Menu.search('access', menu)[0].label, 'Access and keys', 'but a label hit on the group still leads');
+  assert.equal(Menu.search('danger zone', menu)[0].id, 'project-settings', 'a word only the entry\'s words carry still finds it');
+  // a viewer never finds what they cannot open
+  assert.ok(!Menu.search('permissions', Menu.visibleMenu(signed('xenos'))).some((h) => h.id === 'permissions'));
+});
+
+test('what an address opens: ?open=<entry> with its #anchor, a bare #<entry>, and nothing else', () => {
+  assert.deepEqual(Menu.target('?open=my-agents', '#talk'), { id: 'my-agents', anchor: 'talk' });
+  assert.deepEqual(Menu.target('?open=market-watch', ''), { id: 'market-watch', anchor: 'settings' }, 'an entry\'s own anchor');
+  assert.deepEqual(Menu.target('', '#sound'), { id: 'sound', anchor: null });
+  assert.equal(Menu.target('', '#cli'), null, 'a panel anchor is the page\'s own to land');
+  assert.equal(Menu.target('?open=nope', ''), null);
+  assert.equal(Menu.frameSrc(Menu.entry('my-agents'), 'talk', ''), '/my-agents?embed=1#talk');
+  assert.equal(Menu.frameSrc(Menu.entry('permissions'), null, '/builders'), '/builders/government?embed=1');
+  assert.equal(Menu.frameSrc(Menu.entry('sound'), null, ''), null, 'a native group has no frame');
+});
+
+test('closing goes back only to a same-site path', () => {
+  assert.equal(Menu.closeTo('?from=' + encodeURIComponent('/goals#/goal/7')), '/goals#/goal/7');
+  for (const bad of ['//evil.example/x', 'https://evil.example', '/\\evil', '']) {
+    assert.equal(Menu.closeTo('?from=' + encodeURIComponent(bad)), null, `${bad || 'nothing'} is not a way back`);
+  }
+});
+
+test('the server sends every old address to its entry, lets the frame through, and the two maps agree', () => {
+  const m = SERVE.match(/const RETIRED_TO_OPTIONS = Object\.freeze\((\{[\s\S]*?\})\);/);
+  assert.ok(m, 'the server map is a literal');
+  const server = vm.runInNewContext('(' + m[1] + ')');
+  const client = Object.fromEntries(Object.entries(Menu.RETIRED).map(([p, id]) => [p.slice(1), id]));
+  assert.deepEqual({ ...server }, client, 'serve-internal.js RETIRED_TO_OPTIONS and options-menu.js RETIRED are one map');
+  for (const id of Object.values(client)) assert.ok(Menu.entry(id), `${id} is a menu entry`);
+  const reDecl = 'const RETIRED_OPTIONS_RE = ';
+  const i = SERVE.indexOf(reDecl);
+  const rx = vm.runInNewContext(SERVE.slice(i + reDecl.length, SERVE.indexOf(';', i)));
+  for (const p of Object.keys(server)) {
+    for (const v of [`/builders/${p}`, `/builders/${p}/`, `/builders/${p}.html`]) assert.ok(rx.test(v), `${v} is redirected`);
+  }
+  for (const p of ['/builders/settings', '/builders/market-watch', '/builders/modulesx', '/modules/x/public/a.js']) assert.ok(!rx.test(p), `${p} is not`);
+  const block = SERVE.slice(i, SERVE.indexOf('});', i));
+  assert.match(block, /if \(embed === '1' && m\[1\] !== 'market-watch-settings'\) return next\(\);/, 'the frame passes through to the page and its own gate');
+  assert.match(block, /\/settings\?open=\$\{RETIRED_TO_OPTIONS\[m\[1\]\]\}/);
+  // it runs BEFORE the page gates, which still guard the framed request
+  assert.ok(i < SERVE.indexOf('PROJECT_SETTINGS_PAGE_RE.test(norm)'), 'ahead of the page-gate dispatch');
+  assert.match(SERVE, /GOVERNMENT_PAGE_RE\.test\(norm\)\) \{\s*return gdsAuth\.requireGovernmentPage/, 'the Permissions frame keeps its page gate');
+});
+
+test('the Settings page IS the menu: one search over the groups, loaded before settings.js', () => {
+  const html = read('settings.html');
+  assert.match(html, /<nav class="opt-rail" id="settings-rail" aria-label="Options"><\/nav>/);
+  assert.ok(html.indexOf('options-menu.js') > 0 && html.indexOf('options-menu.js') < html.indexOf('/builders/settings.js'));
+  assert.match(html, /<title>Options — /);
+  const js = read('settings.js');
+  assert.match(js, /menu\.mount\(\{/, 'settings.js hands the menu the viewer');
+  assert.doesNotMatch(js, /makeSectionRail/, 'the old rail is gone, not drawn beside the menu');
+  const css = read('settings.css');
+  assert.match(css, /\.settings-groups > \.opt-embed\.opt-embed--on \{ display: block; \}/, 'one framed screen shows at a time');
+});
+
+// ---- shell-game.js: the embedded page and game mode's Escape --------------------
+
+function bootGame({ search = '', framed = true, game = false, path: p = '/my-agents' } = {}) {
+  const docListeners = {};
+  const winListeners = {};
+  const timers = [];
+  const assigned = [];
+  const root = { dataset: {} };
+  const bodyAttrs = {};
+  const parent = { OTBOptions: { escapes: 0, escape() { this.escapes += 1; } } };
+  const win = {
+    location: { pathname: p, search, hash: '', origin: 'https://h', href: 'https://h' + p + search, assign(u) { assigned.push(u); } },
+    localStorage: { getItem: (k) => (k === 'hall-game' && game ? 'on' : null), setItem() {} },
+    sessionStorage: { getItem: () => null, setItem() {} },
+    addEventListener(t, fn) { (winListeners[t] ||= []).push(fn); },
+    setTimeout(fn) { timers.push(fn); },
+  };
+  win.parent = framed ? parent : win;
+  const document = {
+    documentElement: root,
+    body: { setAttribute(k, v) { bodyAttrs[k] = v; } },
+    addEventListener(t, fn) { (docListeners[t] ||= []).push(fn); },
+  };
+  const ctx = vm.createContext({ window: win, document, URLSearchParams, URL });
+  vm.runInContext(read('shell-game.js'), ctx);
+  return {
+    root, bodyAttrs, parent, assigned, game: win.OTBShellGame,
+    press(key, target = { tagName: 'DIV' }) {
+      const ev = { key, target, defaultPrevented: false, preventDefault() { this.defaultPrevented = true; } };
+      for (const fn of winListeners.keydown || []) fn(ev);
+      while (timers.length) timers.shift()();
+      return ev;
+    },
+    click(href, target = null) {
+      const attrs = { href };
+      if (target) attrs.target = target;
+      const a = { getAttribute: (k) => (k in attrs ? attrs[k] : null), setAttribute: (k, v) => { attrs[k] = v; } };
+      for (const fn of docListeners.click || []) fn({ target: { closest: () => a } });
+      return attrs.target || null;
+    },
+  };
+}
+
+test('EMBEDDED: only a framed ?embed=1 page drops its chrome, and the switch is off', () => {
+  const framed = bootGame({ search: '?embed=1' });
+  assert.equal(framed.root.dataset.embed, 'on');
+  assert.equal(framed.bodyAttrs['data-fullscreen-switch'], 'off', 'no corner button, no Escape-to-leave');
+  assert.equal(framed.game.embedded(), true);
+  const alone = bootGame({ search: '?embed=1', framed: false });
+  assert.equal(alone.root.dataset.embed, undefined, 'the same URL opened on its own keeps its chrome');
+  assert.equal(bootGame({ search: '' }).root.dataset.embed, undefined);
+  const css = read('style.css');
+  assert.match(css, /html\[data-embed="on"\] \.app-sidebar,\s*html\[data-embed="on"\] \.app-scrim,\s*html\[data-embed="on"\] \.app-foot,\s*html\[data-embed="on"\] \.app-topbar \{ display: none; \}/);
+});
+
+test('EMBEDDED: an Escape nobody used goes to the menu; a link to another page leaves the frame', () => {
+  const p = bootGame({ search: '?embed=1' });
+  p.press('Escape');
+  assert.equal(p.parent.OTBOptions.escapes, 1, 'the menu got it');
+  p.press('Escape', { tagName: 'INPUT' });
+  assert.equal(p.parent.OTBOptions.escapes, 1, 'a field keeps its own Escape');
+  assert.equal(p.click('/task/42'), '_top', 'another page opens in the whole window');
+  assert.equal(p.click('#talk'), null, 'a place in the same page stays in the frame');
+  assert.equal(p.click('/goals', '_blank'), '_blank', 'a link that names its own target keeps it');
+});
+
+test('GAME MODE: on the menu itself the last Escape closes it; outside game mode it is not the menu\'s', () => {
+  // the menu page registers window.OTBOptions; shell-game hands it the press
+  const menu = bootGame({ game: true, framed: false, path: '/settings' });
+  menu.parent.OTBOptions.escapes = 0;
+  const ev = menu.press('Escape');
+  assert.equal(ev.defaultPrevented, true, 'marked used, so the shell does not also bring the bars back');
+  assert.deepEqual(menu.assigned, ['/settings?from=%2Fsettings'], 'with no menu script loaded it opens the menu page');
+  const off = bootGame({ game: false, framed: false, path: '/goals' });
+  off.press('Escape');
+  assert.deepEqual(off.assigned, [], 'outside game mode the press stays the shell\'s');
+});
+
+test('options-menu.js gives the menu its Escape: close in game mode, nothing outside it', () => {
+  const src = read('options-menu.js');
+  assert.match(src, /function escape\(\) \{\s*var game = window\.OTBShellGame;\s*if \(game && game\.on && game\.on\(\)\) close\(\);/);
+  assert.match(src, /root\.OTBOptions = \{/, 'the menu registers itself where shell-game.js looks');
+});
+
+// In game mode an Escape nobody used opens the options menu, so a pop-up that closes on
+// Escape must say it used the press (ADR 0399 §2.4 row 5). These seven closed something and
+// let the press fall through: before task 1005144 that also brought the bars back (the city
+// card was task 1005188); after it, it would also have left the page for the menu.
+test('every pop-up that closes on Escape spends the press, so the menu never opens from under it', () => {
+  const spent = {
+    'atlas.js': /ev\.key === 'Escape' && popup\.classList\.contains\('show'\)\) \{ ev\.preventDefault\(\); closePopup\(\);/,
+    'city.js': /if \(e\.key === 'Escape'\) \{ if \(e\.preventDefault\) e\.preventDefault\(\); closeCard\(\);/,
+    'home-gallery.js': /if \(isFs\(\) \|\| reading\.length\) e\.preventDefault\(\);/,
+    'task-detail.js': /e\.key === 'Escape' && document\.getElementById\('deeplink-card'\)\) \{ e\.preventDefault\(\); clearLink\(\);/,
+    'tweak-editor.js': /\$\('tw-openwrap'\)\.classList\.contains\('is-open'\)\) ev\.preventDefault\(\);/,
+    'update-pill.js': /state\.card && !state\.card\.hidden\) \{ e\.preventDefault\(\); closeCard\(\);/,
+    'diagram-viewer.js': /&& fullscreen\) \{ e\.preventDefault\(\); toggleFullscreen\(fullscreen\);/,
+  };
+  for (const [f, re] of Object.entries(spent)) assert.match(read(f), re, `${f} spends the Escape it used`);
+  // and a framed screen never asks for a craft: the menu page around it does
+  assert.match(read('craft-mode.js'), /if \(window\.OTBShellGame && window\.OTBShellGame\.embedded && window\.OTBShellGame\.embedded\(\)\) return;/);
+});
+
+test('the start screen\'s Options is the menu, and its first tip says what Escape does now', () => {
+  const src = read('shell-game.js');
+  assert.match(src, /\{ id: 'options', label: 'Options', href: '\/settings' \}/, 'Options opens the one options menu');
+  assert.match(src, /'Escape opens the options menu, where every setting lives\.'/);
+  assert.doesNotMatch(src, /Escape brings the navigation back/, 'no tip promises what Escape no longer does');
+});

package/tests/hall_oversight_world.mjs

@@ -206,7 +206,7 @@ async function bootWatchLedger(overrides = {}) {
   };
   sandbox.globalThis = sandbox;
   vm.createContext(sandbox);
-  for (const f of ['dom-utils.js', 'hall-kit.js', 'watch.js']) {
+  for (const f of ['dom-utils.js', 'hall-kit.js', 'watch-repo-invite.js', 'watch.js']) {
     vm.runInContext(read(f), sandbox, { filename: f });
   }
   // load() is async: let every section's promise settle before reading the DOM.

package/tests/hall_palette.mjs

@@ -156,11 +156,10 @@ test('Government section anchors exist in government.js makeTabs', () => {
   const ids = [...read('government.js').matchAll(/\{ id: '([a-z-]+)', label: '[^']*', panel:/g)].map((m) => m[1]);
   assert.ok(ids.length === 2, `sanity: found the two government tabs (${ids})`);
   assert.ok(!ids.includes('board-room'), 'the Board Room is a page, not a tab (ADR 0266)');
-  const declared = declaredHrefs((x) => x.startsWith('/government#'));
-  assert.ok(declared.length === 2, 'palette declares the two Government sections');
-  for (const h of declared) {
-    assert.ok(ids.includes(h.split('#')[1]), `${h} must be a real government.js tab id`);
-  }
+  // task 1005144: Permissions and the Constitution are an options menu entry, rank-gated
+  // in the menu, so the palette declares no /government row — one offered to every
+  // signed-in reader would land a sub-Metic one on a menu without that entry.
+  assert.equal(declaredHrefs((x) => x.startsWith('/government')).length, 0, 'no palette row points at the old page');
 });
 
 test('Settings panel anchors exist in settings.js RAIL_GROUPS', () => {
@@ -182,8 +181,8 @@ test('My agents anchors are ones my-agents.js lands, and the moved Settings pane
   const block = (src.match(/const ANCHORS = \{([\s\S]*?)\n  \};/) || [, ''])[1];
   const keys = [...block.matchAll(/^\s*([a-z-]+): \{/gm)].map((m) => m[1]);
   assert.ok(keys.length >= 5, `sanity: my-agents.js ANCHORS (${keys})`);
-  const declared = declaredHrefs((x) => x.startsWith('/my-agents#'));
-  assert.ok(declared.length >= 5, 'the palette offers the agent settings where they live now');
+  const declared = declaredHrefs((x) => x.startsWith('/settings?open=my-agents#'));
+  assert.ok(declared.length >= 5, 'the palette offers the agent settings where they live now (the options menu, task 1005144)');
   for (const h of declared) assert.ok(keys.includes(h.split('#')[1]), `${h} must be a my-agents.js anchor`);
   assert.equal(declaredHrefs((x) => /\/settings#(interaction|wandering|rendering|voices|specialities)/.test(x)).length, 0,
     'no palette row points at a Settings panel that left');
@@ -207,10 +206,10 @@ test('pages come from the sidebar, and a gated-off nav item is not a destination
 test('section groups appear only when their owning nav item is visible', () => {
   const all = bootPalette({ navItems: NAV_FIXTURE }).compute('');
   assert.ok(all.some((r) => r.group === 'Profile'), 'Profile sections offered when nav-profile shows');
-  assert.ok(all.some((r) => r.group === 'Settings'), 'Settings panels offered when the profile chip shows');
+  assert.ok(all.some((r) => r.group === 'Options'), 'Options (the one menu, task 1005144) offered when the profile chip shows');
 
   const gatedOut = bootPalette({ navItems: NAV_FIXTURE, visibleIds: [] }).compute('');
-  assert.ok(!gatedOut.some((r) => ['Profile', 'Tasks', 'Settings'].includes(r.group)),
+  assert.ok(!gatedOut.some((r) => ['Profile', 'Tasks', 'Options'].includes(r.group)),
     'no sub-destinations when their owners are hidden');
 });
 

package/tests/hall_profile_world.mjs

@@ -164,7 +164,7 @@ function bootCharts() {
       // 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: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
@@ -308,7 +308,7 @@ function bootRender({ rows, status = 200, analytics = null, earnings = [] }) {
       // 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: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
@@ -328,7 +328,7 @@ function bootRender({ rows, status = 200, analytics = null, earnings = [] }) {
   return { C: sandbox.window.OTBProfileCharts, api, requests, mount, controls };
 }
 
-const ship = (d, extra = {}) => ({ shipped_at: `${d}T10:00:00Z`, discipline: 'engineer', credits_awarded: 10, credits_reward: 12, ...extra });
+const ship = (d, extra = {}) => ({ shipped_at: `${d}T10:00:00Z`, discipline: 'artisan', credits_awarded: 10, credits_reward: 12, ...extra });
 // an earnings row: what the ledger paid on one day, for one kind of credit
 const pay = (d, credits, kind = 'session') => ({ day: d, kind, credits });
 

package/tests/hall_record_world.mjs

@@ -395,7 +395,7 @@ function renderTask(task, { lastClaim = null, viewer = null, goal = null, goalsL
       // 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',
       // task 1004038 — the kind axis asks the same question. Stubbed for the
@@ -446,7 +446,7 @@ const settle = () => new Promise((r) => setTimeout(r, 0));
 
 const BASE_TASK = {
   id: '1003305', title: 'A record in the world', status: 'shipped', version_id: 'BONGOS-V1',
-  kind: 'feature', discipline: 'engineer', priority: 1, requires_rank: 'metic',
+  kind: 'feature', discipline: 'artisan', priority: 1, requires_rank: 'metic',
   credits_reward: 60, est_minutes: 240, actual_minutes: 37,
   created_at: '2026-08-28T00:00:00Z', description: 'the description', touches: ['a.js', 'b.js'],
   dependencies: [], dependents: [],

package/tests/hall_settings_world.mjs

@@ -222,7 +222,8 @@ test('every old link to those sections lands on My agents', () => {
   // settings.js asks before it draws anything, and on every later hash
   const html = read('settings.html');
   assert.ok(html.indexOf('settings-moved.js') > 0 && html.indexOf('settings-moved.js') < html.indexOf('/builders/settings.js'), 'loaded before settings.js');
-  assert.match(settingsJs, /location\.replace\(/, 'a replace, so Back does not bounce through Settings');
+  // task 1005144: My agents is an options menu entry now, so a moved link opens it in place.
+  assert.match(settingsJs, /OTBOptions\.activate\('my-agents', anchor\)/, 'opened in the menu, no page load');
   assert.doesNotMatch(settingsJs, /'(interaction|wandering|rendering|voices)': '[a-z-]+-scroll'/, 'no PANEL_ANCHORS entry for a section that left');
 });