@bongos/core 1.21.29 → 1.21.30

package/modules/hall-ui/public/work.html

@@ -171,9 +171,9 @@
 
 <!-- The app shell (sidebar + top bar + footer). Dependency-free; runs at parse
      time so the chrome exists before the deferred page scripts execute. -->
-<script src="/builders/shell-trail.js?v=2026-10-02-craft"></script>
-<script src="/builders/craft-mode.js?v=2026-10-02-craft"></script>
-<script src="/builders/shell.js?v=2026-10-02-craft"></script>
+<script src="/builders/shell-trail.js?v=2026-10-03-nav"></script>
+<script src="/builders/craft-mode.js?v=2026-10-03-nav"></script>
+<script src="/builders/shell.js?v=2026-10-03-nav"></script>
 <!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
 <script src="/builders/palette.js" defer></script>
 <!-- shared frontend toolkit (window.OTB) — loaded FIRST so work.js can pull from it. -->

package/modules/hall-ui/records/craft-mode.md

@@ -20,3 +20,10 @@ Covers: every shelled hall page (`craft-mode.js`, `shell.js`, `style.css`), and
 ## The carve
 
 `shell.js` sat at exactly 1,500 lines, the fitness ratchet, so the Back link + trail section (tasks 1004430/1004476/1004477) moved verbatim into `shell-trail.js` (`window.OTBShellTrail.make({ esc, nav })`). Behaviour is unchanged; `tests/hall_fullscreen.mjs` loads it before the shell and still drives the trail through the real top bar.
+
+## The nav follows the mode (task 1004493)
+
+- **Each craft has a named tab list**, `MODE_TABS` in `craft-mode.js`, by NAV id. `ALWAYS_TABS` is the owner's list of tabs no mode may hide (2026-10-01: Builders, NAV id `roster`, first), and every mode's list is `ALWAYS_TABS` plus its own. Legacy and no mode have no entry, so they show every tab, as before.
+- **Government shows only in Governing**, and outside that group Governing is the shortest list (Blockers, Board Room). Building is every tab except Government and the Board Room; Artistry is Studio, Goals, Your thinking; Ideating is Sky, Your thinking, Goals. The prototype names rooms that do not exist yet (Store, Page reviews, Treasury); a list names only real NAV items, and `tests/craft_mode_nav.mjs` requires every NAV item to sit in some mode.
+- **The mode only ever takes away, and never through `hidden`.** The access gate owns `hidden`; `applyNav()` marks what the mode leaves out with `[data-craft-off]`, which `style.css` hides. So a mode can never show a tab the gate hid, and switching mode just moves the attribute. A group head goes too once nothing under it shows.
+- **Two callers.** `apply()` runs it on every mode change (live, no reload), and `shell.js` `applyAccess` runs it right after its gate loop, so a later `/me` answer (a promotion, a permission) brings a head back with its tabs. Hidden tabs still open by their URL; nothing is enforced (ADR 0016).

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.29",
+  "version": "1.21.30",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.21.29",
+      "version": "1.21.30",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.29",
+  "version": "1.21.30",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -8930,5 +8930,11 @@
       "id": "1004548",
       "text": "After approving GitHub sign-in, founders go straight back to their setup checklist to wait, and can tick a box to have their project open automatically when it's ready."
     }
+  ],
+  "1.21.30": [
+    {
+      "id": "1004493",
+      "text": "The hall's sidebar now follows the mode you pick. Building shows the everyday tabs, Artistry shows Studio, Goals and Your thinking, Ideating shows the Sky, Your thinking and Goals, and Governing is the shortest list: Blockers,"
+    }
   ]
 }

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.21.29'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.30'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');

package/tests/craft_mode_nav.mjs

@@ -0,0 +1,202 @@
+// tests/craft_mode_nav.mjs — the hall nav follows the craft mode (task 1004493,
+// goal 1000095 WA6).
+//
+// Each craft mode shows only the tabs its craft needs; Legacy mode and no mode
+// show every tab, exactly as before. The owner's rule (2026-10-01): some tabs
+// stay in EVERY mode, Builders first among them, written down as ONE shared list
+// that each mode's list adds to. These cases boot the REAL shell-trail.js +
+// craft-mode.js + shell.js and read the sidebar the shell actually rendered, so a
+// tab id that drifts from NAV, or a gate pass that runs after the mode and
+// re-shows a tab, reds here.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node: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 SHELL = read('shell.js');
+const TRAIL = read('shell-trail.js');
+const CRAFT = read('craft-mode.js');
+
+// Every NAV id, and the Government group's, read from shell.js itself.
+const NAV_IDS = [...SHELL.matchAll(/\{ id: '([a-z-]+)', label:/g)].map((m) => m[1]);
+const GOV_BLOCK = SHELL.slice(SHELL.indexOf("{ group: 'Government'"));
+const GOV_IDS = [...GOV_BLOCK.slice(0, GOV_BLOCK.indexOf('] }')).matchAll(/\{ id: '([a-z-]+)'/g)].map((m) => m[1]);
+
+// A small element. Elements parsed from the sidebar's markup are built ONCE, so
+// what the gate loop writes (hidden) is what the mode pass reads back.
+function makeEl(tag) {
+  const attrs = {};
+  return {
+    tagName: tag, id: '', dataset: {}, style: {}, hidden: false, children: [], _html: '',
+    classList: { _s: new Set(), add(c) { this._s.add(c); }, remove(c) { this._s.delete(c); }, toggle(c, on) { if (on === undefined) on = !this._s.has(c); if (on) this._s.add(c); else this._s.delete(c); return on; }, contains(c) { return this._s.has(c); } },
+    setAttribute(k, v) { attrs[k] = String(v); }, getAttribute(k) { return k in attrs ? attrs[k] : null; },
+    hasAttribute(k) { return k in attrs; }, removeAttribute(k) { delete attrs[k]; },
+    addEventListener() {}, appendChild(c) { this.children.push(c); return c; }, removeChild() {}, insertBefore(c) { return c; },
+    focus() {}, closest() { return null; }, querySelector() { return null; }, querySelectorAll() { return []; },
+  };
+}
+// The rendered sidebar as groups of { head, items }.
+function parseSidebar(html) {
+  return html.split('<div class="nav-group').slice(1).map((chunk) => {
+    const group = makeEl('DIV');
+    const tag = (m, t) => {
+      const el = makeEl(t);
+      for (const a of m.matchAll(/([a-z-]+)="([^"]*)"/g)) {
+        if (a[1] === 'id') el.id = a[2];
+        else if (a[1].startsWith('data-')) el.dataset[a[1].slice(5)] = a[2];
+      }
+      el.hidden = /\shidden[\s>]/.test(m);
+      return el;
+    };
+    const headM = chunk.match(/<button type="button" class="nav-group__head"[^>]*>/);
+    const head = headM ? tag(headM[0], 'BUTTON') : null;
+    const items = [...chunk.matchAll(/<a class="nav-item"[^>]*>/g)].map((m) => tag(m[0], 'A'));
+    group.querySelector = (sel) => (sel === '.nav-group__head' ? head : null);
+    group.querySelectorAll = (sel) => (sel === '.nav-item' ? items : []);
+    return { el: group, head, items };
+  });
+}
+
+function boot({ session = {}, perms = { 'board.vote.cast': true } } = {}) {
+  const root = makeEl('HTML');
+  const topbar = makeEl('DIV');
+  const sidebar = makeEl('NAV');
+  const body = makeEl('BODY');
+  body.dataset.page = 'work';
+  let groups = null;
+  const parsed = () => (groups ||= parseSidebar(sidebar._html));
+  Object.defineProperty(sidebar, 'innerHTML', { set(v) { sidebar._html = String(v); groups = null; }, get() { return sidebar._html; } });
+  sidebar.querySelectorAll = (sel) => {
+    if (sel === '.nav-item') return parsed().flatMap((g) => g.items);
+    if (sel === '.nav-group') return parsed().map((g) => g.el);
+    return [];
+  };
+  const gated = () => parsed().flatMap((g) => (g.head ? [g.head, ...g.items] : g.items));
+  const els = { 'app-topbar': topbar, 'app-sidebar': sidebar };
+  const documentObj = {
+    body, referrer: '', documentElement: root, activeElement: null,
+    getElementById: (id) => els[id] || null,
+    querySelector: () => null,
+    querySelectorAll: (sel) => (sel === '#app-sidebar [data-gate]' ? gated() : []),
+    createElement: (t) => makeEl(t.toUpperCase()),
+    addEventListener() {}, removeEventListener() {}, dispatchEvent() { return true; },
+    get cookie() { return ''; }, set cookie(_v) {},
+  };
+  const location = { hostname: 'h', origin: 'https://h', href: 'https://h/work', pathname: '/work', hash: '', search: '', assign() {}, replace() {}, reload() {} };
+  const mk = (obj) => ({ getItem: (k) => (k in obj ? obj[k] : null), setItem: (k, v) => { obj[k] = String(v); }, removeItem: (k) => { delete obj[k]; } });
+  const windowObj = {
+    __BRANDING__: {}, __MODULES__: { enabled: { provisioning: true } },
+    BongosClient: { createClient: () => ({ request: () => new Promise(() => {}) }) },
+    matchMedia: () => ({ matches: false, addEventListener() {} }),
+    localStorage: mk({}), sessionStorage: mk(session), location,
+    clearTimeout() {}, setTimeout() { return 0; }, requestAnimationFrame() {}, scrollTo() {},
+    addEventListener() {}, dispatchEvent() { return true; },
+  };
+  const sandbox = {
+    window: windowObj, document: documentObj, location, console, URL, URLSearchParams, queueMicrotask,
+    setTimeout() { return 0; }, clearTimeout() {},
+    Event: class { constructor(t) { this.type = t; } },
+    CustomEvent: class { constructor(t, i) { this.type = t; Object.assign(this, i); } },
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(TRAIL, sandbox, { filename: 'shell-trail.js' });
+  vm.runInContext(CRAFT, sandbox, { filename: 'craft-mode.js' });
+  vm.runInContext(SHELL, sandbox, { filename: 'shell.js' });
+  const shell = windowObj.OTBShell;
+  const craft = windowObj.OTBCraftMode;
+  const byId = (id) => parsed().flatMap((g) => g.items).find((a) => a.id === 'nav-' + id);
+  return {
+    craft, root,
+    signIn: (rank = 'archon') => shell.applyAccess({ authed: true, rank, permissions: perms, builder: { id: 7, rank } }),
+    // The tabs a reader can see: the gate let them through AND the mode kept them.
+    showing: () => parsed().flatMap((g) => g.items).filter((a) => !a.hidden && !a.hasAttribute('data-craft-off')).map((a) => a.id.slice(4)),
+    headShowing: (group) => {
+      const g = parsed().find((x) => x.head && x.head.dataset.group === group);
+      return !!g && !g.head.hidden && !g.head.hasAttribute('data-craft-off');
+    },
+    byId,
+  };
+}
+
+const CRAFTS = ['building', 'artistry', 'ideating', 'governing'];
+
+test('THE ALWAYS-PRESENT LIST: one shared list, Builders first, inside every mode', () => {
+  const { craft } = boot();
+  assert.equal(craft.ALWAYS_TABS[0], 'roster', 'Builders (NAV id roster) heads the list (owner, 2026-10-01)');
+  for (const m of CRAFTS) {
+    const tabs = craft.tabsFor(m);
+    assert.ok(Array.isArray(tabs), `${m} has a named tab list`);
+    for (const id of craft.ALWAYS_TABS) assert.ok(tabs.includes(id), `${m} keeps ${id}`);
+  }
+  assert.match(CRAFT, /return own \? ALWAYS_TABS\.concat\(own\) : null;/, 'each list is ALWAYS_TABS plus its own, not a copy of it');
+});
+
+test('every tab a mode names is a real NAV item, and every NAV item lives in some mode', () => {
+  const { craft } = boot();
+  assert.ok(NAV_IDS.length >= 25, `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`);
+  for (const id of NAV_IDS) assert.ok(named.has(id), `${id} is reachable from some mode's nav`);
+});
+
+test('Government shows only in Governing, and Governing is the shortest list', () => {
+  const { craft } = boot();
+  assert.ok(GOV_IDS.length >= 5, `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}`);
+  }
+  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');
+});
+
+test('NO MODE AND LEGACY ARE TODAY\'S NAV: every tab the gate allows, nothing marked', () => {
+  const none = boot();
+  none.signIn();
+  const all = none.showing();
+  assert.deepEqual(all, NAV_IDS, 'an archon with no mode sees every tab');
+  const legacy = boot({ session: { 'hall-craft': 'legacy' } });
+  legacy.signIn();
+  assert.deepEqual(legacy.showing(), all, 'Legacy mode shows exactly the same');
+  assert.equal(legacy.craft.tabsFor('legacy'), null);
+});
+
+test('each mode shows its own tabs, and switching updates the nav live', () => {
+  const p = boot();
+  p.signIn();
+  for (const m of CRAFTS) {
+    p.craft.choose(m);
+    assert.equal(p.root.dataset.craft, m);
+    assert.deepEqual(new Set(p.showing()), new Set(p.craft.tabsFor(m)), `${m} shows exactly its list`);
+    assert.ok(p.showing().includes('roster'), `Builders stays in ${m}`);
+    assert.equal(p.headShowing('government'), m === 'governing', `the Government head shows only where its tabs do (${m})`);
+  }
+  p.craft.choose('legacy');
+  assert.deepEqual(p.showing(), NAV_IDS, 'back to Legacy, every tab returns 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' } });
+  p.signIn('thetes');
+  assert.ok(!p.showing().includes('watch'), 'a thetes in Governing does not get the metic-floored Watch tab');
+  assert.ok(!p.headShowing('government'), 'nor its group head');
+  assert.deepEqual(p.showing(), ['blockers', 'board-room', 'roster'], 'what a thetes board member in Governing 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('government'), 'and its group head comes back with it, which only a mode pass after the gate can know');
+  assert.ok(!p.showing().includes('work'), 'and the gate pass did not bring back a tab the mode left out');
+});
+
+test('shell.js applies the mode AFTER its gate loop, and style.css hides what the mode leaves out', () => {
+  const body = SHELL.slice(SHELL.indexOf('function applyAccess('));
+  const gate = body.indexOf('el.hidden = !ok;');
+  const mode = body.indexOf('CRAFT.applyNav()');
+  assert.ok(gate > 0 && mode > gate, 'applyNav runs after the gate loop settles `hidden`');
+  assert.match(read('style.css'), /#app-sidebar \[data-craft-off\] \{ display: none !important; \}/);
+  assert.doesNotMatch(CRAFT, /\.hidden\s*=/, 'the mode never writes `hidden`, which the gate owns');
+});

package/tests/hall_tweak_editor.mjs

@@ -635,7 +635,7 @@ try {
     assert.match(HTML, /<body data-page="tweak-editor"[^>]*data-fullscreen-switch/);
     assert.equal((HTML.match(/<h1\b/g) || []).length, 1);
     assert.ok(HTML.indexOf('tweak-editor-lib.js') < HTML.indexOf('tweak-editor.js?'), 'the lib loads first');
-    assert.match(HTML, /shell\.js\?v=2026-10-02-craft/);
+    assert.match(HTML, /shell\.js\?v=2026-10-03-nav/);
     assert.equal(/fonts\.googleapis\.com\/css/.test(HTML), false);
     for (const id of ['tw-bar', 'tw-counter', 'tw-open', 'tw-open-more', 'tw-divider', 'tw-openwrap', 'tw-open-menu', 'tw-open-tab', 'tw-open-split', 'tw-frame', 'tw-frame-view', 'tw-split-close', 'tw-download', 'tw-upload', 'tw-file', 'tw-submit', 'tw-paper', 'tw-doc', 'tw-notice', 'tw-done', 'tw-take', 'tw-pick', 'tw-picks', 'tw-refused', 'tw-refused-title', 'tw-refused-list', 'tw-refused-next', 'tw-refused-download', 'tw-refused-close']) {
       assert.ok(new RegExp(`id="${id}"`).test(HTML), `#${id} is in the markup`);

package/tests/nav_permission_atoms.mjs

@@ -87,7 +87,7 @@ test('the hall-preview fixture carries every atom /me resolves', () => {
 // the file and left the query alone, so a returning browser kept the cached copy —
 // a fix that reaches nobody looks identical to a fix that does not work.
 
-const SHELL_SHA = '8932abeda77f250a';
+const SHELL_SHA = 'af1c61ca87767b44';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);