@bongos/core 1.21.27 → 1.21.29

package/modules/public-landing/public/projects.html

@@ -423,6 +423,10 @@ h1[tabindex="-1"]:focus:not(:focus-visible){outline:none;}
 .samePath{font-size:13px;font-weight:400;color:var(--ink-faint);margin-top:18px;}
 .samePath a{display:inline-block;padding:3px 0;min-height:24px;line-height:18px;}
 #liveProgress{margin-top:4px;}
+/* the sign-in wait inside its step + the "open it when ready" tick (task 1004548) */
+.humanSteps .prog{margin-top:14px;}
+.autoOpen{display:flex;align-items:flex-start;gap:10px;margin-top:14px;font-size:14px;line-height:1.45;color:var(--ink-soft);cursor:pointer;min-height:24px;}
+.autoOpen input{width:18px;height:18px;margin:1px 0 0;flex:0 0 auto;accent-color:var(--accent);cursor:pointer;}
 
 /* ── the standup strip (task 2083), drawn as the lifecycle rail (DESIGN.md):
    three hairlines, a 7px dot, one lit step — no plate, no connector, no
@@ -6557,6 +6561,35 @@ summary{min-height:24px;padding:3px 0;}
         '<p>The platform team places the generated credentials; this step ticks itself once they land.</p></details>';
     }
 
+    /* "Open it when it's ready" (task 1004548). The founder now waits for sign-in on
+       this checklist instead of on the callback page, so the auto-open lives here: a
+       tick, on unless they untick it (remembered per browser), that opens the project
+       the moment it answers AND sign-in is wired. Armed only by a wait this page has
+       actually watched, so revisiting a long-finished checklist never jumps away. */
+    var AUTO_OPEN_KEY = 'cb-open-when-ready';
+    var autoOpenArmed = false;
+    var autoOpened = false;
+    function autoOpenPref() {
+      try { return localStorage.getItem(AUTO_OPEN_KEY) !== '0'; } catch (e) { return true; }
+    }
+    function autoOpenTick() {
+      return '<label class="autoOpen"><input type="checkbox" data-action="auto-open"' + (autoOpenPref() ? ' checked' : '') + '>' +
+        '<span>Open my project automatically when it’s ready</span></label>';
+    }
+    function maybeAutoOpen() {
+      var domain = resolvedDomain();
+      if (autoOpened || !autoOpenArmed || !domain || !autoOpenPref()) return;
+      if (live.manifest !== 'done' || live.instStatus !== 'active' || !live.addrReady) return;
+      autoOpened = true;
+      var url = 'https://' + domain;
+      /* a new tab keeps this checklist (two steps follow sign-in); a browser that
+         blocks an unprompted tab gets this one sent instead — the founder asked */
+      var w = null;
+      try { w = window.open(url, '_blank'); } catch (e) {}
+      if (w) { try { w.opener = null; } catch (e) {} }
+      else window.location.assign(url);
+    }
+
     /* oauth-app — the ADR 0133 one-click GitHub-App manifest flow is the primary path
        (gap 3 / idea 1000676); locked until a domain exists (the App needs the real
        callback host — the server refuses domainless with domain_required). */
@@ -6572,7 +6605,12 @@ summary{min-height:24px;padding:3px 0;}
         return '<li class="slocked" data-onboard-step="oauth-app"><b>Wire GitHub sign-in</b><p>This platform is running on a local address, and GitHub refuses app setups it can’t reach over the public internet — so the one-click flow can’t complete here. On a publicly-addressed platform this is one click.</p>' + manualOauthDetails() + '</li>';
       }
       if (live.manifest === 'done') {
-        return '<li class="sdone" data-onboard-step="oauth-app"><b>GitHub sign-in is wired</b><p>Credentials placed and verified — sign-in on <code style="font-family:var(--font-mono)">' + esc(domain) + '</code> is live.</p></li>';
+        /* the wait ends HERE now, not on the callback page (task 1004548): once the
+           project answers too, the step carries the door itself */
+        var open = live.instStatus === 'active' && live.addrReady;
+        return '<li class="sdone" data-onboard-step="oauth-app"><b>GitHub sign-in is wired</b><p>Credentials placed and verified — sign-in on <code style="font-family:var(--font-mono)">' + esc(domain) + '</code> is live.' +
+          (open ? '' : ' The door below opens once your project is answering.') + '</p>' +
+          (open ? '<a class="ghbtn" href="https://' + esc(domain) + '" target="_blank" rel="noopener">Open ' + esc(domain) + ' →</a>' : '') + '</li>';
       }
       if (live.manifest === 'error' || live.manifest === 'expired') {
         /* a plain sentence first; the raw route text folds under Technical
@@ -6589,10 +6627,14 @@ summary{min-height:24px;padding:3px 0;}
       if (live.manifest === 'code_received') {
         /* GitHub's half is done — say so, rather than keep telling the founder
            to approve an app they just approved */
-        return '<li data-onboard-step="oauth-app"><b>Wire GitHub sign-in</b><p>GitHub’s part is done. The platform is placing the credentials on your project now — this step ticks itself.</p></li>';
+        autoOpenArmed = true;
+        return '<li data-onboard-step="oauth-app"><b>Wire GitHub sign-in</b><p>GitHub’s part is done. The platform is placing the credentials on your project now — this usually takes a few minutes, and this step ticks itself.</p>' +
+          progressMarkup(1, 1, 'Placing credentials and checking sign-in works…', '', 'signin') + autoOpenTick() + '</li>';
       }
       if (live.manifest) {   /* pending — GitHub holds the manifest, nobody has approved it yet */
+        autoOpenArmed = true;
         return '<li data-onboard-step="oauth-app"><b>Wire GitHub sign-in</b><p>Waiting on GitHub — approve the app in the tab that opened. Once approved, the platform places the credentials and verifies sign-in on its own; this step ticks itself.</p>' +
+          progressMarkup(0, 0, 'Waiting for your approval on GitHub…', '', 'signin') + autoOpenTick() +
           (manifestStale ? '<button type="button" class="linklike" data-action="manifest-start">Didn’t get to GitHub? Start the setup again</button>' : '') + '</li>';
       }
       return '<li data-onboard-step="oauth-app"><b>Wire GitHub sign-in — one click</b><p>Approve a pre-filled GitHub App and the platform wires sign-in by itself: no keys to copy, and the secret never leaves the server side.</p>' +
@@ -6678,6 +6720,7 @@ summary{min-height:24px;padding:3px 0;}
         if (html === lastStepsHtml) return;   /* change-only re-render — polls never clobber open UI */
         lastStepsHtml = html;
         $('humanSteps').innerHTML = html;
+        maybeAutoOpen();
       });
     }
 
@@ -6730,6 +6773,12 @@ summary{min-height:24px;padding:3px 0;}
       });
     });
 
+    $('humanSteps').addEventListener('change', function (ev) {
+      var box = ev.target.closest && ev.target.closest('[data-action="auto-open"]');
+      if (!box) return;
+      try { localStorage.setItem(AUTO_OPEN_KEY, box.checked ? '1' : '0'); } catch (e) {}
+    });
+
     /* ── C8: the wizard's polls run only on stage, exactly like the sky.
        Off-view or hidden-tab, a due tick parks itself instead of fetching;
        enter() and the visibility flip resume whatever was parked. ── */
@@ -6754,6 +6803,13 @@ summary{min-height:24px;padding:3px 0;}
     var manifestPending = false;
     var manifestStartedAt = 0;     /* when the founder was sent to GitHub */
     var manifestStale = false;     /* ~90s with no approval → offer to start again */
+    /* the GitHub hand-back (task 1004548): the callback page returns the founder here
+       with the attempt's one-time state in the fragment (#ghstate=…), so a checklist
+       that page opened — not only the tab that started the setup — keeps watching the
+       same attempt. Read once at load, before the router's replaceState drops it. */
+    var handbackState = (function () {
+      try { var m = /[#&]ghstate=([0-9a-f]{16,128})/i.exec(location.hash || ''); return m ? m[1] : null; } catch (e) { return null; }
+    })();
     /* the manifest leg survives a reload: token + last status ride the CREATED
        record, so enter() re-seeds the step instead of re-offering "Set up
        GitHub sign-in" for an app the founder already approved (task 1003232) */
@@ -6846,7 +6902,9 @@ summary{min-height:24px;padding:3px 0;}
       standup: { names: ['Request filed', 'Standing it up', 'Live'], cls: '' },
       revive: { names: ['Revive queued', 'Standing it up', 'Back live'], cls: '' },
       teardown: { names: ['Teardown queued', 'Winding down', 'Torn down'], cls: 'flowDown' },
-      settings: { names: ['Change saved', 'Restarting to apply it', 'Applied'], cls: '' }
+      settings: { names: ['Change saved', 'Restarting to apply it', 'Applied'], cls: '' },
+      /* the GitHub sign-in wait, drawn inside its checklist step (task 1004548) */
+      signin: { names: ['Approve on GitHub', 'Placing credentials', 'Ready to sign in'], cls: '' }
     };
     /* No live-region attributes here: this strip is destroyed and rebuilt on
        every 5s tick, and a live region that is itself replaced never announces.
@@ -7171,6 +7229,13 @@ summary{min-height:24px;padding:3px 0;}
       /* restore the opt-out too — without it resolvedDomain() re-derives the
          assigned address and the done panel promises one that doesn't exist */
       state.noAddress = !!created.noaddr;
+      /* a hand-back from the callback page names the attempt GitHub just approved */
+      if (handbackState) {
+        created.manifest_state = handbackState;
+        if (created.manifest !== 'done') created.manifest = 'code_received';
+        rememberManifest(handbackState, created.manifest);
+        handbackState = null;
+      }
       /* the manifest leg's last known truth, kept across a reload */
       if (created.manifest) { live.manifest = created.manifest; live.appSlug = created.app_slug || null; }
       if (created.manifest_state && created.manifest !== 'done' && created.manifest !== 'error' && created.manifest !== 'expired') {

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.27",
+  "version": "1.21.29",
   "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

@@ -8918,5 +8918,17 @@
       "id": "1004476",
       "text": "In the builders' hall, a page you reach through several clicks now shows the whole way back at the top, like Goals > goal 12 > task 340, and each step is a link. Clicking an earlier step takes you straight there; the sidebar s"
     }
+  ],
+  "1.21.28": [
+    {
+      "id": "1004492",
+      "text": "The Builders Hall now asks what you are doing when you arrive: Building, Artistry, Ideating or Governing, or Legacy mode for the hall exactly as it was. It asks once per session (or never again, if you untick the box), artists"
+    }
+  ],
+  "1.21.29": [
+    {
+      "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."
+    }
   ]
 }

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.27'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.29'; // 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.mjs

@@ -1,141 +1,296 @@
-// tests/craft_mode.mjs — the claimed craft's pack pointer is INJECTED, not
-// printed (task 1002992).
+// tests/craft_mode.mjs — the hall's craft mode picker (task 1004492, goal 1000095 WA6).
 //
-// Four altitudes: the server helper over the real registry, the /me wiring, the
-// Conductor's worktree-scoped relay, and claim.js — which now prints one role line
-// but must still land a ui claim's module-owned skills (the regression this task
-// was most likely to ship). The hook itself is run end to end, against the
-// helper's real output, in tests/conductor_main_e2e.mjs.
-//
-// Run:  node tests/craft_mode.mjs
-
-import { strict as assert } from 'node:assert';
-import { createRequire } from 'node:module';
+// On entering the hall a picker asks once per session "What are you doing
+// now?" (Building, Artistry, Ideating, Governing, or Legacy mode); the answer is
+// html[data-craft], and a switch in the top bar changes it without a reload.
+// These cases boot the REAL shell-trail.js + craft-mode.js + shell.js in a DOM
+// stub, in the order every hall page loads them, and drive them the way a
+// reader does: sign in, pick a door, reload, start a new session, press the
+// switch. The criterion's own disqualifier comes first: a hall with no mode
+// chosen must render exactly as the hall did before craft modes existed.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
+import vm from 'node:vm';
 import { fileURLToPath } from 'node:url';
-import { makeRunner } from './helpers.mjs';
 
-const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const craft = require('../src/bongos/craft-mode.js');
-const conductor = require('../.claude/hooks/conductor.js');
-const { test, summary } = makeRunner();
+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');
 
-const REGISTRY = path.join(ROOT, 'scripts', 'gds', 'discipline-modes.json');
-const MODES = craft.readModes();
+// A tiny element: attributes, a dataset, children by markup. An element built
+// from markup answers the selectors the craft code asks with a regex over that
+// markup, so a door or a checkbox the code forgot to render cannot be found.
+function makeEl(tag, html = '') {
+  const attrs = {}, listeners = {};
+  const el = {
+    tagName: tag, id: '', className: '', dataset: {}, style: {}, textContent: '', hidden: false, title: '',
+    _html: html, children: [], parentNode: null,
+    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(t, fn) { (listeners[t] ||= []).push(fn); },
+    fire(t, ev) { for (const fn of listeners[t] || []) fn(ev); },
+    appendChild(c) { c.parentNode = el; el.children.push(c); return c; },
+    removeChild(c) { el.children = el.children.filter((x) => x !== c); c.parentNode = null; },
+    insertBefore(c) { return el.appendChild(c); },
+    focus() { focused.el = el; },
+    closest() { return null; },
+    querySelector(sel) { return el.querySelectorAll(sel)[0] || null; },
+    querySelectorAll(sel) { return fromMarkup(el, sel); },
+    set innerHTML(v) { el._html = String(v); el._kids = null; }, get innerHTML() { return el._html; },
+  };
+  return el;
+}
+const focused = { el: null };
+// Buttons and inputs parsed out of an element's markup, built once so a state
+// written to one (aria-pressed, checked) is the state read back later.
+function kids(el) {
+  if (el._kids) return el._kids;
+  el._kids = [...el._html.matchAll(/<(button|input)\b([^>]*)>/g)].map((m) => {
+    const k = makeEl(m[1].toUpperCase());
+    for (const a of m[2].matchAll(/([a-z-]+)(?:="([^"]*)")?/g)) {
+      if (a[1] === 'class') k.className = a[2]; else k.setAttribute(a[1], a[2] == null ? '' : a[2]);
+    }
+    k.checked = k.hasAttribute('checked');
+    k.closest = () => k;
+    return k;
+  });
+  return el._kids;
+}
+function fromMarkup(el, sel) {
+  const all = kids(el);
+  let m;
+  if ((m = /^\[([a-z-]+)\]$/.exec(sel))) return all.filter((k) => k.hasAttribute(m[1]));
+  if ((m = /^#craft-switch \[([a-z-]+)\]$/.exec(sel))) return all.filter((k) => k.hasAttribute(m[1]));
+  if ((m = /^\.([a-z-]+)$/.exec(sel))) return all.filter((k) => k.className.split(/\s+/).includes(m[1]));
+  if (sel === 'button, input') return all;
+  return [];
+}
 
-// ---- the helper, over the ONE registry ---------------------------------------
-await test('the server reads the same registry file claim.js and fitness read', () => {
-  assert.deepEqual(MODES, JSON.parse(fs.readFileSync(REGISTRY, 'utf8')).modes);
-});
+// One page load. `session` is the tab's sessionStorage and `store` the
+// browser's localStorage: pass the same objects to a second boot and it is a
+// reload; a fresh `session` with the same `store` is a new browser session.
+function boot({ craft = true, session = {}, store = {}, throws = false, optOut = false, narrow = false } = {}) {
+  const events = [];
+  const root = makeEl('HTML');
+  const topbar = makeEl('DIV');
+  const sidebar = makeEl('NAV');
+  const body = makeEl('BODY');
+  body.dataset.page = 'work';
+  if (optOut) body.setAttribute('data-craft-mode', 'off');
+  const els = { 'app-topbar': topbar, 'app-sidebar': sidebar };
+  const docListeners = {};
+  const documentObj = {
+    body, referrer: '', documentElement: root, activeElement: null,
+    getElementById(id) {
+      if (els[id]) return els[id];
+      if (id === 'craft-switch') {
+        if (!topbar._html.includes('id="craft-switch"')) return null;
+        const sw = els[id] = makeEl('DIV', topbar._html.match(/<div class="craft-switch[\s\S]*?<\/div>/)[0]);
+        return sw;
+      }
+      if (/^(fullscreen-toggle|theme-toggle|zoom-toggle|topbar-menu|topbar-title|topbar-jump|topbar-back|founding-band|fullscreen-hint|skip-link|app-foot|app-scrim|shell-signin|shell-user|logout-link|craft-picker)$/.test(id)) {
+        if (id === 'craft-picker') return body.children.find((c) => c.id === 'craft-picker') || null;
+        return topbar._html.includes(`id="${id}"`) ? (els[id] = els[id] || makeEl('X')) : null;
+      }
+      return null;
+    },
+    querySelector: () => null,
+    querySelectorAll: (sel) => (sel.startsWith('#craft-switch') && els['craft-switch'] ? els['craft-switch'].querySelectorAll(sel) : []),
+    createElement: (t) => makeEl(t.toUpperCase()),
+    addEventListener(t, fn) { (docListeners[t] ||= []).push(fn); },
+    removeEventListener(t, fn) { docListeners[t] = (docListeners[t] || []).filter((f) => f !== fn); },
+    dispatchEvent(ev) { events.push(ev); return true; },
+    get cookie() { return ''; }, set cookie(_v) {},
+  };
+  const location = { hostname: 'h', origin: 'https://h', href: 'https://h/work', pathname: '/work', hash: '', search: '', reloads: 0, assign() { this.reloads++; }, replace() { this.reloads++; }, reload() { this.reloads++; } };
+  const mk = (obj) => ({
+    getItem: (k) => { if (throws) throw new Error('SecurityError'); return k in obj ? obj[k] : null; },
+    setItem: (k, v) => { if (throws) throw new Error('SecurityError'); obj[k] = String(v); },
+    removeItem: (k) => { if (throws) throw new Error('SecurityError'); delete obj[k]; },
+  });
+  const windowObj = {
+    __BRANDING__: {}, __MODULES__: { enabled: {} },
+    BongosClient: { createClient: () => ({ request: () => new Promise(() => {}) }) },
+    matchMedia: (q) => ({ matches: narrow && /max-width: 640px/.test(q), addEventListener() {} }),
+    localStorage: mk(store), 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' });
+  if (craft) vm.runInContext(CRAFT, sandbox, { filename: 'craft-mode.js' });
+  vm.runInContext(SHELL, sandbox, { filename: 'shell.js' });
+  const shell = windowObj.OTBShell;
+  const picker = () => body.children.find((c) => c.id === 'craft-picker') || null;
+  const sw = () => documentObj.getElementById('craft-switch');
+  return {
+    root, topbar, sidebar, body, session, store, location, events,
+    mode: () => root.dataset.craft,
+    picker,
+    signIn: (builder = { id: 7, rank: 'thetes' }) => shell.applyAccess({ authed: true, rank: builder.rank, builder }),
+    signOut: () => shell.applyAccess({ authed: false }),
+    // Press a picker button: a door, Legacy, or the close button.
+    pick(attr, value, { askAgain = true } = {}) {
+      const p = picker();
+      const box = p.querySelector('[data-craft-again]');
+      if (box) box.checked = askAgain;
+      const btn = p.querySelectorAll(`[${attr}]`).find((b) => value == null || b.getAttribute(attr) === value);
+      assert.ok(btn, `the picker renders a [${attr}${value ? '=' + value : ''}] button`);
+      p.fire('click', { target: btn });
+    },
+    press(mode) {
+      const btn = sw().querySelectorAll('[data-craft-opt]').find((b) => b.getAttribute('data-craft-opt') === mode);
+      assert.ok(btn, `the switch renders a ${mode} option`);
+      sw().fire('click', { target: btn });
+    },
+    pressed: () => sw().querySelectorAll('[data-craft-opt]').filter((b) => b.getAttribute('aria-pressed') === 'true').map((b) => b.getAttribute('data-craft-opt')),
+    escape() { for (const fn of docListeners.keydown || []) fn({ key: 'Escape', preventDefault() {} }); },
+  };
+}
 
-await test('every registry craft yields a contract naming its pack or skill, with its directive', () => {
-  const names = Object.keys(MODES);
-  assert.ok(names.length >= 3, 'the registry was read at all');
-  for (const d of names) {
-    const m = craft.describeCraftMode(d, MODES);
-    assert.ok(m && m.inject, `${d} injects`);
-    assert.equal(m.discipline, d);
-    const pointer = MODES[d].pack || `/${MODES[d].skill}`;
-    assert.ok(m.contract.includes(pointer), `${d} names ${pointer}`);
-    assert.ok(m.contract.includes(MODES[d].directive.slice(0, 40)), `${d} carries its directive`);
-  }
-  assert.match(craft.describeCraftMode('engineer', MODES).contract, /read docs\/packs\/engineer\.md/);
-  assert.match(craft.describeCraftMode('ui', MODES).contract, /— \/design/, 'a skill is a command to invoke, not a file to read');
-});
+const MODES = ['building', 'artistry', 'ideating', 'governing', 'legacy'];
+const noSwitch = (html) => html.replace(/<div class="craft-switch[\s\S]*?<\/div>/, '');
 
-await test('fail-open: no craft, an unknown craft, or an unreadable registry yields nothing', () => {
-  assert.equal(craft.describeCraftMode(null, MODES), null);
-  assert.equal(craft.describeCraftMode('governor', MODES), null);
-  assert.equal(craft.describeCraftMode('engineer', null), null);
-  assert.deepEqual(craft.readModes(path.join(os.tmpdir(), 'no-such-registry.json')), {});
-  const bad = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'craft-')), 'modes.json');
-  fs.writeFileSync(bad, '{ not json');
-  assert.deepEqual(craft.readModes(bad), {});
+test('NO MODE IS THE HALL AS TODAY: with no mode chosen, nothing but the switch differs from a hall without craft modes', () => {
+  const before = boot({ craft: false });
+  const after = boot({ craft: true });
+  assert.equal(after.mode(), undefined, 'no html[data-craft]');
+  assert.deepEqual({ ...after.root.dataset }, { ...before.root.dataset }, 'the root carries exactly the attributes it did');
+  assert.equal(after.sidebar.innerHTML, before.sidebar.innerHTML, 'the sidebar is byte-identical');
+  assert.equal(noSwitch(after.topbar.innerHTML), before.topbar.innerHTML, 'the top bar differs by the switch alone');
+  assert.ok(after.topbar.innerHTML.includes('id="craft-switch"'), 'and the switch is there to choose one');
+  assert.equal(after.picker(), null, 'nobody is asked before a signed-in builder is known');
 });
 
-await test('the default registry is read once per process; an explicit file is read fresh', () => {
-  assert.equal(craft.readModes(), craft.readModes(), 'GET /me does not re-read and re-parse per request');
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'craft-'));
-  const f = path.join(dir, 'modes.json');
-  fs.writeFileSync(f, JSON.stringify({ modes: { a: { directive: 'x' } } }));
-  assert.deepEqual(Object.keys(craft.readModes(f)), ['a']);
-  fs.writeFileSync(f, JSON.stringify({ modes: { b: { directive: 'y' } } }));
-  assert.deepEqual(Object.keys(craft.readModes(f)), ['b'], 'claim.js always sees the file as it is now');
+test('a signed-in builder is asked ONCE per session, and a reload does not ask again', () => {
+  const session = {};
+  const p = boot({ session });
+  p.signIn();
+  assert.ok(p.picker(), 'the picker opens');
+  const html = p.picker().innerHTML;
+  assert.match(html, /role="dialog" aria-modal="true"/);
+  assert.match(html, /What are you doing now\?/);
+  for (const m of ['building', 'artistry', 'ideating', 'governing']) assert.match(html, new RegExp(`data-craft-pick="${m}"`), `a ${m} door`);
+  assert.match(html, /data-craft-pick="legacy"[^>]*>Legacy mode/, 'Legacy mode is the fifth choice (owner, 2026-10-01)');
+  p.escape();
+  assert.equal(p.picker(), null, 'Escape closes it without choosing');
+  assert.equal(p.mode(), undefined, 'and leaves the hall with no mode');
+  const reload = boot({ session });
+  reload.signIn();
+  assert.equal(reload.picker(), null, 'the same session is not asked twice');
 });
 
-// ---- /me carries it on each claim ---------------------------------------------
-await test('GET /me puts each claim\'s craft_mode on the claim, from the helper', () => {
-  const me = fs.readFileSync(path.join(ROOT, 'src/bongos/routes/me.js'), 'utf8');
-  assert.match(me, /require\('\.\.\/craft-mode'\)/);
-  assert.match(me, /craft_mode: describeCraftMode\(c\.discipline, craftModes\)/);
-  assert.doesNotMatch(me, /"modes"\s*:/, 'no second copy of the registry in the route');
+test('a visitor who is not signed in is never asked', () => {
+  const p = boot();
+  p.signOut();
+  assert.equal(p.picker(), null);
 });
 
-// ---- the Conductor relays THIS worktree's craft only ---------------------------
-const claim = (id, discipline) => ({ task_id: String(id), title: 't', touches: [], worktree_name: `task-${id}`, discipline, craft_mode: craft.describeCraftMode(discipline, MODES) });
-const craftIds = (out) => out.filter((a) => String(a.id).startsWith('craft:')).map((a) => a.id);
+test('choosing a door sets html[data-craft] for every page of the session, and says so on document', () => {
+  const session = {}, store = {};
+  const p = boot({ session, store });
+  p.signIn();
+  p.pick('data-craft-pick', 'ideating');
+  assert.equal(p.picker(), null, 'the picker closes');
+  assert.equal(p.mode(), 'ideating');
+  assert.ok(p.events.some((e) => e.type === 'otb:craft' && e.detail.mode === 'ideating'), 'otb:craft fires with the mode');
+  assert.deepEqual(p.pressed(), ['ideating'], 'the switch lights the chosen mode');
+  const next = boot({ session, store });
+  assert.equal(next.mode(), 'ideating', 'the next page of the session reads it before /me answers');
+  assert.equal(store['hall-craft-keep'], undefined, '"Ask me again next session" was ticked, so nothing outlives the session');
+  const tomorrow = boot({ store });
+  tomorrow.signIn();
+  assert.equal(tomorrow.mode(), undefined, 'a new session starts with no mode');
+  assert.ok(tomorrow.picker(), 'and asks again');
+});
 
-await test('the claim bound to this worktree gets its craft; the other tree\'s does not', () => {
-  const claims = [claim(1, 'engineer'), claim(2, 'ideator')];
-  assert.deepEqual(craftIds(conductor.evaluateTriggers({ activeClaims: claims, worktree: 'task-1' })), ['craft:engineer']);
-  assert.deepEqual(craftIds(conductor.evaluateTriggers({ activeClaims: claims, worktree: 'task-2' })), ['craft:ideator']);
+test('unticking "Ask me again next session" keeps the mode for later sessions', () => {
+  const store = {};
+  const p = boot({ store });
+  p.signIn();
+  p.pick('data-craft-pick', 'governing', { askAgain: false });
+  assert.equal(store['hall-craft-keep'], 'governing');
+  const tomorrow = boot({ store });
+  tomorrow.signIn();
+  assert.equal(tomorrow.mode(), 'governing', 'the kept mode applies');
+  assert.equal(tomorrow.picker(), null, 'and nobody is asked');
 });
 
-await test('no bound claim, no session, or no registry entry: nothing is injected', () => {
-  const claims = [claim(1, 'engineer')];
-  assert.deepEqual(craftIds(conductor.evaluateTriggers({ activeClaims: claims, worktree: 'task-9' })), [], 'an unrelated tree');
-  assert.deepEqual(craftIds(conductor.evaluateTriggers({ activeClaims: claims, worktree: null })), [], 'not in a worktree');
-  assert.deepEqual(craftIds(conductor.evaluateTriggers({ activeClaims: null, worktree: 'task-1' })), [], 'no session / no network');
-  assert.deepEqual(craftIds(conductor.evaluateTriggers({ activeClaims: [{ ...claim(1, 'governor') }], worktree: 'task-1' })), [], 'a craft with no entry');
-  assert.deepEqual(craftIds(conductor.evaluateTriggers({ activeClaims: [{ ...claim(1, 'engineer'), craft_mode: { inject: true, contract: '' } }], worktree: 'task-1' })), [], 'an empty contract');
+test('THE HEADER SWITCH changes the mode without a reload, and offers all five', () => {
+  const p = boot();
+  const opts = [...p.topbar.innerHTML.matchAll(/data-craft-opt="([a-z]+)"/g)].map((m) => m[1]);
+  assert.deepEqual(opts, MODES, 'the four crafts, then Legacy');
+  p.press('artistry');
+  assert.equal(p.mode(), 'artistry');
+  p.press('legacy');
+  assert.equal(p.mode(), 'legacy', 'anyone can go back to the old view at any time');
+  assert.deepEqual(p.pressed(), ['legacy']);
+  assert.equal(p.location.reloads, 0, 'no navigation happened');
+  assert.equal(p.session['hall-craft'], 'legacy', 'and the session remembers it');
 });
 
-// ---- claim.js: one role line, and the ui skills still land ---------------------
-const claimCli = require('../scripts/gds/claim.js');
-const materialize = require('../scripts/gds/claude-materialize.js');
+test('on a phone the switch shows only the current mode, and tapping it opens the picker', () => {
+  const session = { 'hall-craft': 'building' };
+  const p = boot({ session, narrow: true });
+  p.press('building');
+  assert.ok(p.picker(), 'the current mode opens the picker');
+  assert.equal(p.mode(), 'building', 'without changing the mode');
+});
 
-function capture(fn) {
-  const lines = [];
-  const orig = console.log;
-  console.log = (...a) => { lines.push(a.join(' ')); };
-  try { fn(); } finally { console.log = orig; }
-  return lines.filter((l) => l !== '');
-}
+test('artists start on Artistry: the door is pre-selected and the picker says why', () => {
+  const p = boot();
+  p.signIn({ id: 3, rank: 'thetes', main_discipline: 'artist', preferred_disciplines: ['engineer', 'artist'] });
+  const html = p.picker().innerHTML;
+  assert.match(html, /craft-door--artistry craft-door--pre"/);
+  assert.match(html, /Artists start on Artistry\./);
+  const eng = boot();
+  eng.signIn({ id: 4, rank: 'thetes', main_discipline: 'engineer', preferred_disciplines: ['artist'] });
+  assert.doesNotMatch(eng.picker().innerHTML, /craft-door--pre/, 'a main role that is not artist pre-selects nothing');
+  const unset = boot();
+  unset.signIn({ id: 5, rank: 'thetes', main_discipline: null, preferred_disciplines: ['artist'] });
+  assert.match(unset.picker().innerHTML, /craft-door--artistry craft-door--pre"/, 'with no main role, the first craft decides');
+});
 
-await test('claim.js prints exactly one role line and no directive block', () => {
-  const lines = capture(() => claimCli.printRoleLine({ discipline: 'engineer' }));
-  assert.deepEqual(lines, ['▶ Engineering session — read docs/packs/engineer.md']);
-  const src = fs.readFileSync(path.join(ROOT, 'scripts/gds/claim.js'), 'utf8');
-  assert.doesNotMatch(src, /mode\.directive\}/, 'the directive is no longer printed');
-  assert.doesNotMatch(src, /Your pack:/);
+test('storage that throws is never asked and never wears a mode', () => {
+  const p = boot({ throws: true });
+  p.signIn();
+  assert.equal(p.picker(), null, 'it could not remember being asked, so it would ask on every page');
+  assert.equal(p.mode(), undefined);
 });
 
-await test('claiming a ui task STILL materialises its module-owned skills', () => {
-  const saved = { into: materialize.materializeModuleSkillsIntoCore, root: materialize.isCoreCheckoutRoot };
-  const calls = [];
-  materialize.isCoreCheckoutRoot = () => true;
-  materialize.materializeModuleSkillsIntoCore = (opts) => { calls.push(opts); return { materialized: ['impeccable', 'minimalist-ui'] }; };
-  try {
-    const lines = capture(() => claimCli.printRoleLine({ discipline: 'ui' }));
-    assert.equal(calls.length, 1, 'the ui claim landed its skills');
-    assert.equal(lines[0], '▶ UI design session — /design');
-    assert.match(lines[1], /2 module-owned skill\(s\)/);
-    calls.length = 0;
-    capture(() => claimCli.printRoleLine({ discipline: 'engineer' }));
-    assert.equal(calls.length, 0, 'a craft that did not opt in lands nothing');
-  } finally {
-    materialize.materializeModuleSkillsIntoCore = saved.into;
-    materialize.isCoreCheckoutRoot = saved.root;
-  }
+test('a page can opt out with <body data-craft-mode="off">', () => {
+  const p = boot({ optOut: true, session: { 'hall-craft': 'artistry' } });
+  p.signIn();
+  assert.doesNotMatch(p.topbar.innerHTML, /craft-switch/, 'no switch');
+  assert.equal(p.picker(), null, 'no picker');
+  assert.equal(p.mode(), undefined, 'no mode');
 });
 
-await test('claim.js fails open: no craft or an unknown craft prints nothing and never throws', () => {
-  assert.deepEqual(capture(() => claimCli.printRoleLine({})), []);
-  assert.deepEqual(capture(() => claimCli.printRoleLine({ discipline: 'governor' })), []);
-  assert.deepEqual(capture(() => claimCli.printRoleLine(null)), []);
+test('a stored value that is not a mode is ignored, not trusted', () => {
+  const p = boot({ session: { 'hall-craft': '"><img src=x>' }, store: { 'hall-craft-keep': 'admin' } });
+  assert.equal(p.mode(), undefined);
 });
 
-summary();
+test('every hall page loads shell-trail.js and craft-mode.js right before shell.js, deferred alike', () => {
+  const pages = fs.readdirSync(HALL).filter((f) => f.endsWith('.html') && read(f).includes('/builders/shell.js'));
+  assert.ok(pages.length >= 30, `found ${pages.length} hall pages`);
+  for (const f of pages) {
+    const tags = [...read(f).matchAll(/<script src="\/builders\/([a-z-]+)\.js[^"]*"( defer)?><\/script>/g)].map((m) => [m[1], !!m[2]]);
+    const at = tags.findIndex((t) => t[0] === 'shell');
+    assert.deepEqual(tags.slice(at - 2, at + 1).map((t) => t[0]), ['shell-trail', 'craft-mode', 'shell'], f);
+    assert.equal(new Set(tags.slice(at - 2, at + 1).map((t) => t[1])).size, 1, `${f}: all three load the same way`);
+  }
+});