@bongos/core 1.21.71 → 1.21.73

package/modules/public-landing/public/projects.probes.json

@@ -167,9 +167,9 @@
     { "name": "the review (tasks 1004504, 1004550): Edit opens a row in place, Done confirms it, and Continue is the one confirmation for the rest", "auth": true, "width": 1440, "url": "/projects?view=new",
       "steps": [["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"team\"] [data-row-chg]"],["wait",200],["click","[data-phys-solo=\"many\"]"],["wait",600],["click","#reviewRows .setRow[data-row=\"team\"] [data-row-chg]"],["wait",200]],
       "expect": {"visible":["#panel-review","#reviewRows .setRow[data-row=\"rewards\"]","#reviewRows .setRow.done[data-row=\"team\"]"]} },
-    { "name": "the wizard driver (tasks 1003346 and 1004504): the fork, what, the checks, every review row confirmed (the stub grants repo access, so the new repository is named from the project; the dotless stub host takes a domain the founder owns), the look, then the filing — the done panel with the standup strip and the human steps", "auth": true, "width": 1440, "url": "/projects?view=new",
+    { "name": "the wizard driver (tasks 1003346 and 1004504): the fork, what, the checks, every review row confirmed (the stub grants repo access, so the new repository is named from the project; the dotless stub host takes a domain the founder owns), the look, then the filing — the done panel waits with the cloud hop and its status line (task 1004578), the strip and the locked checklist standing down", "auth": true, "width": 1440, "url": "/projects?view=new",
       "steps": [["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["fill","#f-slug","mercury"],["wait",900],["fill","#f-domain","mercury.example.com"],["wait",200],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["click","#reviewGo"],["wait",500],["click","#doCreate"],["wait",1500]],
-      "expect": {"visible":["#panel-done","#liveProgress .prog","#liveProgress .prog .stages li.now","#humanSteps li"],"hidden":["#panel-look","#panel-review"],"text":[["#done-h","Setting up Mercury"]]} },
+      "expect": {"visible":["#panel-done","#hop","#hopCanvas","#hopStatus","#hopJump"],"hidden":["#panel-look","#panel-review","#liveProgress","#humanSteps"],"text":[["#done-h","Setting up Mercury"],["#hopStatus","Raising the server, database, and address — nothing needed from you."]]} },
     { "name": "the front door at 390: the fork's two doors stack inside one pill", "auth": true, "width": 390, "url": "/projects?view=new",
       "steps": [["wait",600],["click","#termsAck"],["wait",100]],
       "expect": {"visible":["#panel-fork",".doorPill","#wizDemo","#wizStart"]} },

package/modules/public-landing/public/projects.states.json

@@ -57,7 +57,7 @@
     "in-new-review-run": {"auth":true,"url":"/projects?view=new","actions":[["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["fill","#f-desc","A co-op farming game where the seasons never repeat."],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"run\"] [data-row-chg]"],["wait",300],["click","[data-phys=\"framing\"][data-val=\"hybrid\"]"],["wait",600]],"expect":{"visible":["#physSuite"]}},
     "in-new-review-confirmed": {"auth":true,"url":"/projects?view=new","actions":[["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["fill","#f-desc","A co-op farming game where the seasons never repeat."],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["fill","#f-slug","mercury"],["wait",900],["fill","#f-domain","mercury.example.com"],["wait",200],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200]],"expect":{"visible":["#reviewGo","#reviewRows .setRow.done"],"text":[["#reviewGo","Looks right, continue"]]}},
     "in-new-look": {"auth":true,"url":"/projects?view=new","actions":[["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["fill","#f-desc","A co-op farming game where the seasons never repeat."],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["fill","#f-slug","mercury"],["wait",900],["fill","#f-domain","mercury.example.com"],["wait",200],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["click","#reviewGo"],["wait",500]],"expect":{"visible":["#panel-look","#wizLook","#wizRecap","#doCreate"],"hidden":["#panel-review"],"attr":[["#wizRoom","data-screen","look"]]}},
-    "in-new-done": {"auth":true,"url":"/projects?view=new","actions":[["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["fill","#f-desc","A co-op farming game where the seasons never repeat."],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["fill","#f-slug","mercury"],["wait",900],["fill","#f-domain","mercury.example.com"],["wait",200],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["click","#reviewGo"],["wait",500],["click","#doCreate"],["wait",1500]],"expect":{"visible":["#panel-done","#liveProgress .prog","#humanSteps li","#wizInviteLater"],"hidden":["#panel-look","#qWrap","#wizBack","#wizInvite"]}},
+    "in-new-done": {"auth":true,"url":"/projects?view=new","actions":[["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["fill","#f-desc","A co-op farming game where the seasons never repeat."],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["fill","#f-slug","mercury"],["wait",900],["fill","#f-domain","mercury.example.com"],["wait",200],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["click","#reviewGo"],["wait",500],["click","#doCreate"],["wait",1500]],"expect":{"visible":["#panel-done","#hop","#hopCanvas","#hopStatus","#hopJump"],"hidden":["#panel-look","#qWrap","#wizBack","#wizInvite","#liveProgress","#humanSteps","#wizInviteLater","#stepPager"]}},
     "in-new-resume-offer": {"auth":true,"url":"/projects?view=new","actions":[["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["fill","#f-desc","A co-op farming game where the seasons never repeat."],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["fill","#f-slug","mercury"],["wait",900],["fill","#f-domain","mercury.example.com"],["wait",200],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["click","#reviewGo"],["wait",500],["click","#doCreate"],["wait",1500],["click","#projTrig"],["wait",350],["click","#menuProjects [data-nav=\"new\"]"],["wait",500]],"expect":{"visible":["#panel-fork","#wizResume","#wizResumeGo"],"hidden":["#panel-done"],"text":[["#wizResumeName","Mercury"]]}},
     "in-new-look-custom": {"auth":true,"url":"/projects?view=new","actions":[["wait",600],["click","#termsAck"],["wait",100],["click","#wizStart"],["wait",400],["fill","#newName","Mercury"],["click","#typeCards .tpill[data-type=\"game\"]"],["fill","#f-desc","A co-op farming game where the seasons never repeat."],["click","#panel-what button[type=submit]"],["wait",400],["select","#physCountry","US"],["wait",100],["click","[data-phys=\"builder_geography\"][data-val=\"global\"]"],["click","[data-phys=\"minors_on_board\"][data-val=\"false\"]"],["click","[data-phys=\"entity\"][data-val=\"intent-solo\"]"],["click","#physNext"],["wait",700],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["fill","#f-slug","mercury"],["wait",900],["fill","#f-domain","mercury.example.com"],["wait",200],["click","#reviewRows .setRow[data-row=\"address\"] [data-row-chg]"],["wait",200],["click","#reviewGo"],["wait",500],["click","#wizLook-custom"],["wait",200]],"expect":{"visible":["#panel-look","#wizAccent","#wizAccentNote"],"hidden":["#panel-review"]}},
     "out-new": {"auth":false,"url":"/projects?view=new","expect":{"visible":["#panel-gate","#wizSignin"],"hidden":["#qWrap","#panel-fork"]}},

package/package-lock.json

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

package/package.json

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

@@ -9236,5 +9236,17 @@
     {
       "text": "Hosted projects like Will's now get a working Update button in Settings, instead of being told to run a command on a server they don't have access to."
     }
+  ],
+  "1.21.72": [
+    {
+      "id": "1004578",
+      "text": "While a new project is being set up, founders now get a little cloud-hopping game: each cloud is a public project on the platform, in its own planet colour. When the project goes live, clouds and stars fill the screen and fade"
+    }
+  ],
+  "1.21.73": [
+    {
+      "id": "1004625",
+      "text": "The governor city now has its own tab, and in Governing mode it leads the sidebar with every other governing page tucked into one dropdown under it."
+    }
   ]
 }

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

@@ -187,7 +187,7 @@ test('a mode never shows a tab the gate hid, and a later gate pass keeps the mod
   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', 'profile', 'collab', 'roster'], 'what a thetes board member in Governing sees');
+  assert.deepEqual(p.showing(), ['blockers', 'board-room', 'city', 'profile', 'collab', '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');
@@ -202,3 +202,119 @@ test('shell.js applies the mode AFTER its gate loop, and style.css hides what th
   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');
 });
+
+// ---------- the Governing fold (owner, 2026-10-08) ----------
+// Governing leads with the City and folds its other own tabs into one dropdown
+// under it. The fold MOVES nodes, which the parsed sidebar above cannot model, so
+// these cases run the real craft-mode.js against a small working tree: nodes with
+// parents, insertBefore and comments, laid out as shell.js's NAV groups are.
+function treeNode(tag, nodeType = 1) {
+  const attrs = {};
+  const n = {
+    tagName: tag, nodeType, id: '', className: '', dataset: {}, hidden: false, childNodes: [], parentNode: null, _html: '', type: '',
+    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]; },
+    get classList() {
+      const self = this;
+      const list = () => self.className.split(/\s+/).filter(Boolean);
+      return {
+        contains: (c) => list().includes(c),
+        add: (c) => { if (!list().includes(c)) self.className = list().concat(c).join(' '); },
+        remove: (c) => { self.className = list().filter((x) => x !== c).join(' '); },
+        toggle(c, on) { if (on === undefined) on = !this.contains(c); if (on) this.add(c); else this.remove(c); return on; },
+      };
+    },
+    get nextSibling() { const p = this.parentNode; return p ? p.childNodes[p.childNodes.indexOf(this) + 1] || null : null; },
+    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+    appendChild(c) { return this.insertBefore(c, null); },
+    insertBefore(c, ref) {
+      if (c.parentNode) c.parentNode.removeChild(c);
+      const i = ref ? this.childNodes.indexOf(ref) : -1;
+      if (i === -1) this.childNodes.push(c); else this.childNodes.splice(i, 0, c);
+      c.parentNode = this;
+      return c;
+    },
+    removeChild(c) { this.childNodes.splice(this.childNodes.indexOf(c), 1); c.parentNode = null; return c; },
+    walk(fn) { for (const c of this.childNodes) { if (c.nodeType === 1) { fn(c); c.walk(fn); } } },
+    querySelectorAll(sel) { const out = []; this.walk((c) => { if (sel.startsWith('.') && c.classList.contains(sel.slice(1))) out.push(c); }); return out; },
+    querySelector(sel) { return this.querySelectorAll(sel)[0] || null; },
+    addEventListener() {}, focus() {},
+  };
+  return n;
+}
+function bootTree({ mode = null, activeId = null } = {}) {
+  const el = (tag, cls, id) => { const n = treeNode(tag); n.className = cls || ''; n.id = id || ''; return n; };
+  const sidebar = el('NAV', '', 'app-sidebar');
+  // shell.js's NAV, group by group: the unlabeled one holds its items directly,
+  // a labeled one a head and a .nav-items wrapper (renderSidebar's shape).
+  for (const block of SHELL.slice(SHELL.indexOf('var NAV = ['), SHELL.indexOf('// ---------- nav group collapse')).split('{ group: ').slice(1)) {
+    const label = /^'([^']*)'/.exec(block)[1];
+    const group = el('DIV', 'nav-group' + (label ? ' nav-group--collapsible' : ''));
+    let into = group;
+    if (label) {
+      const head = el('BUTTON', 'nav-group__head');
+      head.dataset.group = label.toLowerCase();
+      group.appendChild(head);
+      into = group.appendChild(el('DIV', 'nav-items', 'nav-items-' + label.toLowerCase()));
+    }
+    for (const m of block.matchAll(/\{ id: '([a-z-]+)', label:/g)) {
+      into.appendChild(el('A', 'nav-item' + (m[1] === activeId ? ' nav-item--active' : ''), 'nav-' + m[1]));
+    }
+    sidebar.appendChild(group);
+  }
+  const root = treeNode('HTML');
+  const byId = (id) => { if (sidebar.id === id) return sidebar; let hit = null; sidebar.walk((c) => { if (!hit && c.id === id) hit = c; }); return hit; };
+  const mk = (obj) => ({ getItem: (k) => (k in obj ? obj[k] : null), setItem: (k, v) => { obj[k] = String(v); }, removeItem: (k) => { delete obj[k]; } });
+  const documentObj = {
+    body: treeNode('BODY'), documentElement: root, activeElement: null,
+    getElementById: byId, querySelector: () => null, querySelectorAll: () => [],
+    createElement: (t) => treeNode(t.toUpperCase()), createComment: (t) => Object.assign(treeNode('#comment', 8), { data: t }),
+    addEventListener() {}, removeEventListener() {},
+  };
+  const windowObj = {
+    location: { search: '' }, matchMedia: () => ({ matches: false }),
+    localStorage: mk({}), sessionStorage: mk(mode ? { 'hall-craft': mode } : {}),
+  };
+  const sandbox = { window: windowObj, document: documentObj, console, CustomEvent: class { constructor(t, i) { this.type = t; Object.assign(this, i); } } };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(CRAFT, sandbox, { filename: 'craft-mode.js' });
+  const craft = windowObj.OTBCraftMode;
+  craft.mount();
+  const fold = () => byId('craft-fold');
+  const ids = (n) => n.querySelectorAll('.nav-item').map((a) => a.id.slice(4));
+  const order = () => ids(sidebar);
+  return { craft, sidebar, fold, ids, order, byId };
+}
+
+test('GOVERNING LEADS WITH THE CITY: its other tabs fold into one dropdown right under it', () => {
+  const before = bootTree().order();
+  const p = bootTree({ mode: 'governing' });
+  const fold = p.fold();
+  assert.ok(fold, 'the dropdown exists in Governing');
+  assert.equal(p.byId('nav-city').nextSibling, fold, 'directly under the City tab');
+  const own = p.craft.tabsFor('governing').filter((id) => !p.craft.ALWAYS_TABS.includes(id) && id !== 'city');
+  assert.deepEqual(JSON.parse(JSON.stringify(p.ids(fold))), JSON.parse(JSON.stringify(own)), 'every other Governing tab is in it, in the mode\'s order');
+  assert.ok(fold.classList.contains('nav-group--collapsed'), 'a dropdown starts closed');
+  const head = fold.querySelector('.nav-group__head');
+  assert.equal(head.getAttribute('aria-expanded'), 'false');
+  assert.equal(head.getAttribute('aria-controls'), 'nav-items-craft-fold', 'the head names the region it opens');
+  assert.match(head.innerHTML, /More governing/);
+  assert.ok(head.hasAttribute('data-craft-off') === false, 'its head shows while a tab inside does');
+  assert.ok(p.sidebar.querySelectorAll('.nav-group__head').find((h) => h.dataset.group === 'government').hasAttribute('data-craft-off'),
+    'the emptied Government head hides, so no label sits over nothing');
+  p.craft.choose('building');
+  assert.equal(p.fold(), null, 'leaving Governing removes the dropdown');
+  assert.deepEqual(p.order(), before, 'and puts every tab back exactly where it was');
+  p.craft.choose('governing');
+  p.craft.choose('governing');
+  assert.equal(p.sidebar.querySelectorAll('.craft-fold').length, 1, 'choosing it again builds no second dropdown');
+});
+
+test('the dropdown opens on its own when the page you are on is inside it', () => {
+  const p = bootTree({ mode: 'governing', activeId: 'watch' });
+  assert.ok(!p.fold().classList.contains('nav-group--collapsed'), 'on Watch, the dropdown is open');
+  assert.equal(p.fold().querySelector('.nav-group__head').getAttribute('aria-expanded'), 'true');
+  assert.equal(bootTree({ mode: 'artistry' }).fold(), null, 'no other mode folds anything');
+  assert.equal(bootTree().fold(), null, 'nor does no mode');
+});

package/tests/hall_city.mjs

@@ -271,8 +271,9 @@ test('the page holds only the wordmark, the switch, the city, one button and one
 });
 
 // task 1004544 (owner decision 2026-10-02): the city sits in the hall chrome
-// behind the shell's full-screen switch, the sky's mechanism (task 1004327),
-// and still has no sidebar link.
+// behind the shell's full-screen switch, the sky's mechanism (task 1004327).
+// The owner put the CITY on the sidebar on 2026-10-08 (the Governing mode's
+// lead tab); the street still has no link of its own.
 test('the city sits in the hall chrome, behind the shell\'s full-screen switch', () => {
   const html = read('city.html').replace(/<!--[\s\S]*?-->/g, '');
   assert.match(html, /<body data-page="city"[^>]*\sdata-fullscreen-switch>/, 'the bare attribute: the page lays itself out for full screen');
@@ -285,7 +286,8 @@ test('the city sits in the hall chrome, behind the shell\'s full-screen switch',
   assert.match(css, /html\[data-fullscreen="on"\] \.city-main \{ top: 0; left: 0; \}/);
   assert.match(css, /html\[data-fullscreen="on"\] \.city-top \{ right: 184px; \}/, 'the strip steps clear of the corner exit');
   const shell = read('shell.js');
-  assert.doesNotMatch(shell, /href:\s*'(\/builders)?\/(city|street)'/, 'no sidebar link (owner: leave it off the sidebar)');
+  assert.match(shell, /\{ id: 'city', label: 'City', icon: 'city', href: '\/city', gate: 'perm:board\.vote\.cast' \}/, 'the city is a tab, gated on its page\'s atom');
+  assert.doesNotMatch(shell, /href:\s*'(\/builders)?\/street'/, 'the street has no sidebar link: the way in is the city');
 });
 
 test('motion is CSS only and dies under reduced motion; no page :root; no innerHTML', () => {

package/tests/hall_nav.mjs

@@ -267,7 +267,9 @@ test('sidebar groups read by audience, in order', () => {
   // purpose (task 1003479, and tests/goal_map_page.mjs pinned it); the owner
   // granted the sky that slot on 2026-09-24 (ADR 0227 §11), under Goals because
   // it is the goals seen as one picture.
-  assert.deepEqual(nav[0].items.map((i) => i.id), ['home', 'roadmap', 'goals', 'goal-map', 'work', 'blockers', 'board-room', 'thinking', 'studio'],
+  // 2026-10-08: 'city' — the governor city — joins after the Board Room, on the
+  // same atom and for the same reason (owner call; it leads the Governing mode).
+  assert.deepEqual(nav[0].items.map((i) => i.id), ['home', 'roadmap', 'goals', 'goal-map', 'work', 'blockers', 'board-room', 'city', 'thinking', 'studio'],
     'the unlabeled group is the project itself (task 1002425 order)');
   assert.deepEqual(nav[1].items.map((i) => i.id), ['standing', 'profile'], 'You = your own numbers');
   // task 1003444: 'people' LEFT the group — the owner deleted the hall's

package/tests/hall_street.mjs

@@ -504,7 +504,8 @@ test('the street sits in the hall chrome, behind the shell\'s full-screen switch
   assert.match(css, /\.street-stage \{ position: fixed; top: var\(--topbar-h, 56px\); left: var\(--sidebar-w-rail, 64px\);[^}]*contain: layout paint;/);
   assert.match(css, /html\[data-fullscreen="on"\] \.street-stage \{ top: 0; left: 0; \}/);
   assert.match(css, /html\[data-fullscreen="on"\] \.street-top \{ padding-right: 184px; \}/, 'the strip steps clear of the corner exit');
-  assert.doesNotMatch(read('shell.js'), /href:\s*'(\/builders)?\/(city|street)'/, 'no sidebar link (owner: leave it off the sidebar)');
+  // The city became a tab on 2026-10-08 (owner); the street is still reached through it.
+  assert.doesNotMatch(read('shell.js'), /href:\s*'(\/builders)?\/street'/, 'no sidebar link (owner: leave it off the sidebar)');
 });
 
 test('motion is CSS only and dies under reduced motion; no page :root; no innerHTML', () => {

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-04-lightbulb/);
+    assert.match(HTML, /shell\.js\?v=2026-10-08-city-tab/);
     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 = 'af1c61ca87767b44';
+const SHELL_SHA = '02e600a176c32f6a';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);

package/tests/projects_hub_cloud_hop.mjs

@@ -0,0 +1,303 @@
+// tests/projects_hub_cloud_hop.mjs
+//
+// The create wizard's done panel in two moments (task 1004578, from idea 1001205):
+// WAIT — one status line, a thin bar and the cloud hop, a little game with one
+// cloud per PUBLIC project on the platform — then ARRIVE — the steps only the
+// founder can play, one at a time. The owner set the game's rules on a played
+// prototype, and the nausea ones are the ones a refactor would quietly lose: the
+// clouds stand still, the sky stands still, the view does not follow a jump.
+//
+// EXECUTED by the vm-slice idiom: momentFor/setMoment ride the same region the DNS
+// test runs (renderProgress); the physics (hopStep), the score line (hopScore),
+// the status sync (hopSync) and the pager (stepsPaint) are sliced function by
+// function and run under narrow stubs. Every slice is asserted to exist, so a
+// rename fails loudly instead of testing nothing. vm-born values are compared as
+// primitives or through JSON.
+//
+// Run:  node --test tests/projects_hub_cloud_hop.mjs
+
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+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 LANDING = path.join(ROOT, 'modules', 'public-landing', 'public');
+const HUB = fs.readFileSync(path.join(LANDING, 'projects.html'), 'utf8').replace(/\r\n/g, '\n');
+const SCRIPT = HUB.slice(HUB.lastIndexOf('<script>'), HUB.lastIndexOf('</script>'));
+const STYLE = HUB.slice(HUB.indexOf('<style>'), HUB.indexOf('</style>'));
+const J = (v) => JSON.parse(JSON.stringify(v));
+
+function between(from, to) {
+  const a = SCRIPT.indexOf(from);
+  const b = SCRIPT.indexOf(to, a + 1);
+  assert.ok(a > 0, `slice start must exist: ${from}`);
+  assert.ok(b > a, `slice end must follow it: ${to}`);
+  return SCRIPT.slice(a, b);
+}
+// one wizard-scope function, closed on the first `}` at the wizard's four-space indent
+function fn(name) {
+  const m = SCRIPT.match(new RegExp(`\\n {4}function ${name}\\([^)]*\\) \\{[\\s\\S]*?\\n {4}\\}`));
+  assert.ok(m, `function ${name}() must be findable in projects.html`);
+  return m[0];
+}
+const HOP_CONSTS = (SCRIPT.match(/\n {4}var HOP_GAP = [^\n]*\n/) || [''])[0];
+assert.ok(HOP_CONSTS.includes('HOP_JUMP'), 'the hop constants line must be findable');
+const HOP_REGION = between('/* ══ THE CLOUD HOP (task 1004578)', '/* ── the hub\'s three doors ── */');
+
+// ── the moment ──────────────────────────────────────────────────────────────────
+const PROGRESS = between('var PROG_FLOWS = {', 'function startProgress(');
+const OVERLAY = between('function verifiedAt(inst)', 'function chipMarkup(');
+
+function bootMoment() {
+  const attrs = {};
+  const panel = { setAttribute: (k, v) => { attrs[k] = v; } };
+  const sandbox = {
+    $: (id) => (id === 'panel-done' ? panel : null),
+    esc: (s) => String(s), projectPageLink: (l) => l, relTime: () => 'now', canRestart: () => false,
+    FRESH_MS: 1, LIVE_MOMENT_MS: 1, state: {}, paintInviteGate() {}, lastProgHtml: '',
+  };
+  vm.createContext(sandbox);
+  vm.runInContext(PROGRESS + '\n' + OVERLAY, sandbox);
+  return { sandbox, attrs };
+}
+const NOW = () => new Date().toISOString();
+const live = { status: 'active', domain: 'mercury.cloudbongos.com', dns_resolves: true, last_verified_up: true, last_verified_at: NOW(), open_intent: null };
+
+test('the moment follows the same branches renderProgress speaks', () => {
+  const { sandbox } = bootMoment();
+  const m = (inst) => sandbox.momentFor(inst);
+  assert.equal(m({ status: 'requested' }), 'wait', 'filed: the hop');
+  assert.equal(m({ status: 'provisioning' }), 'wait', 'standing up: the hop');
+  assert.equal(m({ ...live, dns_resolves: false, last_verified_up: null }), 'wait', 'address still being set up: keep playing');
+  assert.equal(m({ ...live, last_verified_up: null }), 'wait', 'standing, not checked yet: keep playing');
+  assert.equal(m({ ...live, last_verified_up: false }), 'wait', 'not answering right now: keep playing');
+  assert.equal(m(live), 'arrive', 'answering on a resolved address: arrive');
+  assert.equal(m({ ...live, open_intent: { action: 'standup', state: 'running' } }), 'arrive',
+    'an intent renderProgress does not speak for (a running standup) falls through to the status');
+  assert.equal(m({ ...live, open_intent: { action: 'provision' } }), 'wait', 'a queued standup is still a wait');
+  assert.equal(m({ status: 'torn_down', open_intent: { action: 'provision' } }), 'wait', 'a queued revive is a wait');
+});
+
+test('a snag, an ending, a settings change or an addressless project keeps the plain panel', () => {
+  const { sandbox } = bootMoment();
+  const m = (inst) => sandbox.momentFor(inst);
+  assert.equal(m({ status: 'error' }), 'plain');
+  assert.equal(m({ status: 'tearing_down' }), 'plain');
+  assert.equal(m({ status: 'torn_down' }), 'plain');
+  assert.equal(m({ ...live, open_intent: { action: 'teardown' } }), 'plain');
+  assert.equal(m({ ...live, open_intent: { action: 'settings-apply', state: 'running' } }), 'plain');
+  assert.equal(m({ ...live, domain: null }), 'plain', 'no address will never answer — nothing to arrive at');
+});
+
+test('renderProgress sets the moment before it writes the strip, and only for a real read', () => {
+  const { sandbox, attrs } = bootMoment();
+  const nodes = { liveProgress: { innerHTML: '', querySelector: () => null }, 'done-h': { textContent: '' }, doneLede: { innerHTML: '' } };
+  sandbox.$ = ((orig) => (id) => nodes[id] || orig(id))(sandbox.$);
+  sandbox.renderProgress({ status: 'provisioning' });
+  assert.equal(attrs['data-moment'], 'wait');
+  sandbox.renderProgress(live);
+  assert.equal(attrs['data-moment'], 'arrive');
+  const body = fn('renderProgress');
+  assert.ok(body.indexOf('setMoment(momentFor(inst))') < body.indexOf('setProgress('), 'the moment is decided first');
+  assert.match(body, /if \(inst\) setMoment\(momentFor\(inst\)\);/, 'a null read never moves the panel');
+});
+
+test('the panel leaves the hop on a stopped watch and starts on it at renderDone', () => {
+  const sp = between('function startProgress(', 'function resetForNewProject(');
+  assert.equal((sp.match(/setMoment\('plain'\);/g) || []).length, 2, 'the ~33-minute hand-off and a gone instance both drop to plain');
+  assert.match(fn('renderDone'), /setMoment\('wait'\);/, 'a fresh done panel opens on the hop');
+  assert.match(fn('resetForNewProject'), /hopReset\(\);/, 'a second project starts with a fresh hop');
+});
+
+// ── the physics — the owner's rules ─────────────────────────────────────────────
+function bootHop({ clouds = 3, reduced = false } = {}) {
+  const score = { textContent: '' };
+  const sandbox = { $: (id) => (id === 'hopScore' ? score : null), REDUCED: reduced, Math };
+  vm.createContext(sandbox);
+  vm.runInContext(HOP_CONSTS + 'var hop = { w: 600, feed: [], clouds: [], best: 0, maxed: false, p: null, cam: 0, camT: 0, L: false, R: false };\n' +
+    fn('hopCloudX') + fn('hopCloudW') + fn('hopScore') + fn('hopStep'), sandbox);
+  const hop = sandbox.hop;
+  hop.clouds.push({ i: 0, base: true, y: 0 });
+  // one fixed column of clouds straight up the middle, so a plain jump lands
+  for (let i = 1; i <= clouds; i++) hop.clouds.push({ i, f: 0.5, cw: 100, y: -i * sandbox.HOP_GAP, name: 'P' + i, acc: 'sea' });
+  hop.p = { x: 300, y: -14, vy: 0, on: hop.clouds[0], face: 1 };
+  hop.cam = hop.camT = -340 * 0.8;
+  return { sandbox, hop, score };
+}
+function run(sb, frames) { for (let i = 0; i < frames; i++) sb.hopStep(1); }
+
+test('a jump lands on the cloud above and the best height counts it', () => {
+  const { sandbox, hop, score } = bootHop();
+  const before = J(hop.clouds.map((c) => [c.f, c.y]));
+  hop.p.vy = -sandbox.HOP_JUMP; hop.p.on = null;
+  run(sandbox, 80);
+  assert.equal(hop.p.on && hop.p.on.i, 1, 'landed on the first project cloud');
+  assert.equal(hop.best, 1);
+  assert.equal(score.textContent, 'Best: 1 of 3 projects');
+  assert.deepEqual(J(hop.clouds.map((c) => [c.f, c.y])), before, 'the clouds never move — moving clouds read as nausea');
+});
+
+test('the view holds still during a jump and glides only after the landing', () => {
+  const { sandbox, hop } = bootHop();
+  const cam0 = hop.cam;
+  hop.p.vy = -sandbox.HOP_JUMP; hop.p.on = null;
+  let airborneMoved = false;
+  for (let i = 0; i < 80 && !hop.p.on; i++) { sandbox.hopStep(1); if (!hop.p.on && Math.abs(hop.cam - cam0) > 0.01) airborneMoved = true; }
+  assert.equal(airborneMoved, false, 'no camera motion while the player is in the air');
+  assert.ok(hop.p.on, 'and it did land');
+  run(sandbox, 60);
+  assert.ok(hop.cam < cam0 - 10, 'once landed higher, the view glides up');
+});
+
+test('a miss falls, and the full-width base cloud always catches', () => {
+  const { sandbox, hop } = bootHop();
+  hop.p.on = hop.clouds[2]; hop.p.y = hop.clouds[2].y - 14; hop.best = 2;
+  hop.p.x = 600 - 10;   // walk off the right edge of a centred cloud
+  run(sandbox, 200);
+  assert.equal(hop.p.on && hop.p.on.base, true, 'it fell past the lower clouds and landed on Your planet');
+  assert.equal(hop.best, 2, 'falling never takes the best height away');
+});
+
+test('steering moves the player, held to the stage', () => {
+  const { sandbox, hop } = bootHop();
+  hop.R = true; run(sandbox, 500);
+  assert.equal(hop.p.x, 590, 'right stops 10px from the edge');
+  hop.R = false; hop.L = true; run(sandbox, 500);
+  assert.equal(hop.p.x, 10, 'and left at 10px');
+});
+
+test('past the last cloud: max projects reached, build more to jump more', () => {
+  const { sandbox, hop, score } = bootHop({ clouds: 1 });
+  hop.p.vy = -sandbox.HOP_JUMP; hop.p.on = null;
+  run(sandbox, 80);
+  assert.equal(hop.maxed, true);
+  assert.equal(score.textContent, 'Max projects reached — build more to jump more');
+  const jump = fn('hopJump');
+  assert.match(jump, /!hop\.maxed/, 'and the jumping stops');
+  assert.match(HOP_REGION, /'Max projects reached'/);
+  assert.match(HOP_REGION, /'Build more to jump more'/);
+});
+
+test('the clouds are the public planets only, in the map\'s colours', () => {
+  const feed = fn('hopLoadFeed');
+  assert.match(feed, /p\.orb === 'planet'/, 'never a private star or a stealth black hole');
+  assert.match(feed, /localeCompare\(String\(b\.origin\)\)/, 'the accent walk runs over the origin-sorted catalog, like assignAccents');
+  assert.match(feed, /ORB_ACCENT_NAMES\.indexOf\(p\.planet_accent\) !== -1 \? p\.planet_accent/, 'the owner\'s pick wins');
+  assert.match(fn('hopBuild'), /hop\.clouds\.length === 1/, 'no public project at all reads as max reached');
+});
+
+// ── motion and the world ────────────────────────────────────────────────────────
+test('the loop never runs under reduced motion; the rest frame is a full still sky', () => {
+  assert.match(fn('hopRunning'), /return !REDUCED && !document\.hidden && hop\.target === 'wait'/, 'the gate, like the map\'s skyActive (C9)');
+  const start = fn('hopStart');
+  assert.ok(start.indexOf('hopRunning()') < start.indexOf('requestAnimationFrame'), 'nothing is scheduled before the gate');
+  assert.match(start, /hopDraw\(performance\.now\(\)\)/, 'a stopped hop draws its still frame');
+  assert.equal((HOP_REGION.match(/requestAnimationFrame\(/g) || []).length, 4,
+    'the start, the frame (playing and curtain) and the curtain\'s kick-off — no other loop');
+  assert.match(fn('hopFrame'), /if \(!hopRunning\(\)\) \{ hopDraw\(now\); return; \}/,
+    'every frame re-asks the gate, so turning reduced motion on stops it');
+  assert.match(fn('hopMoment'), /!REDUCED && hop\.raf/, 'the curtain plays only from a running game');
+  assert.match(STYLE, /\.hop\.isStill \.hopRow\{display:none;\}/, 'reduced motion has nothing to steer');
+});
+
+test('the game reads its colours off the page tokens — no literal but white or black with alpha', () => {
+  const hexes = HOP_REGION.match(/#[0-9a-fA-F]{3,8}\b/g) || [];
+  assert.deepEqual(hexes, [], 'no hex in the hop');
+  // hopCss() is the builder ('rgba(' + a token's channels), not a colour
+  const literals = (HOP_REGION.match(/'rgba?\([^']*'/g) || []).filter((m) => m !== "'rgba('");
+  for (const m of literals) assert.match(m, /^'rgba\(0,0,0,/, `only a black scrim may be literal: ${m}`);
+  assert.match(HOP_REGION, /var HOP_WHITE = \[255, 255, 255\];/, 'white is the one other literal');
+  assert.match(fn('hopColors'), /hopRead\('var\(--' \+ nm \+ '\)'\)/, 'every colour resolves from a token');
+});
+
+// ── the status line and the arrival pager ───────────────────────────────────────
+function el(cls = []) {
+  const set = new Set(cls);
+  const attrs = {};
+  return {
+    classList: { contains: (c) => set.has(c), toggle: (c, on) => (on ? set.add(c) : set.delete(c)), add: (c) => set.add(c), remove: (c) => set.delete(c) },
+    setAttribute: (k, v) => { attrs[k] = v; }, getAttribute: (k) => attrs[k], attrs, hidden: false, textContent: '', style: {},
+  };
+}
+
+test('the status line and the bar read what the strip says', () => {
+  const st = { textContent: '' }, fill = { style: {} };
+  const sandbox = { $: (id) => ({ hopStatus: st, hopBarFill: fill })[id] || null, Math };
+  vm.createContext(sandbox);
+  vm.runInContext(fn('hopSync'), sandbox);
+  const strip = {
+    querySelector: (q) => (q === '.pnote' ? { textContent: 'Raising the server, database, and address — nothing needed from you.' } : q === '.stages li.now' ? {} : null),
+    querySelectorAll: (q) => ({ length: q === '.stages li' ? 3 : 1 }),
+  };
+  sandbox.hopSync(strip);
+  assert.equal(st.textContent, 'Raising the server, database, and address — nothing needed from you.');
+  assert.equal(fill.style.width, '50%', 'one done and one under way of three');
+  assert.match(fn('setProgress'), /hopSync\(el\)/, 'every strip write syncs the line');
+});
+
+function bootSteps(items, signin) {
+  const list = { children: items, querySelector: (q) => items.find((li) => q.includes(li.key) || (q === 'li.cur' && li.classList.contains('cur'))) || null };
+  const panel = el(signin ? ['hopSignin'] : []);
+  const nodes = { 'panel-done': panel, humanSteps: list, hopWhile: el(), stepCount: el(), stepBack: el(), stepNext: el() };
+  const sandbox = { $: (id) => nodes[id] || null, Math, Array };
+  vm.createContext(sandbox);
+  vm.runInContext('var stepIdx = -1, stepAuto = true;' + fn('stepsPaint') + fn('stepGo'), sandbox);
+  return { sandbox, nodes };
+}
+function li(key, cls = []) { const e = el(cls); e.key = key; e.focus = () => {}; return e; }
+
+test('the arrival shows one step at a time, opening on the first not yet done', () => {
+  const items = [li('github-repo', ['sdone']), li('oauth-app'), li('device-flow', ['slocked']), li('enter-hall', ['slocked'])];
+  const { sandbox, nodes } = bootSteps(items);
+  sandbox.stepsPaint(true);
+  assert.deepEqual(items.map((i) => i.classList.contains('cur')), [false, true, false, false]);
+  assert.equal(nodes.stepCount.textContent, 'Step 2 of 4');
+  assert.equal(items[1].attrs['data-n'], '02', 'the step on show carries its own number — a hidden step never counts');
+  assert.equal(nodes.stepBack.hidden, false);
+  assert.equal(nodes.stepNext.hidden, false);
+  // the checklist ticks itself: the step on show finishing moves the founder on
+  items[1].classList.add('sdone');
+  sandbox.stepsPaint();
+  assert.equal(nodes.stepCount.textContent, 'Step 3 of 4');
+  // once they page for themselves, their choice holds
+  sandbox.stepGo(-1);
+  items[2].classList.add('sdone');
+  sandbox.stepsPaint();
+  assert.equal(nodes.stepCount.textContent, 'Step 2 of 4');
+  sandbox.stepGo(1); sandbox.stepGo(1);
+  assert.equal(nodes.stepNext.hidden, true, 'no Continue past the last step');
+});
+
+test('while waiting, the sign-in step is offered only when it can be done', () => {
+  const open = bootSteps([li('github-repo'), li('oauth-app')]);
+  open.sandbox.stepsPaint();
+  assert.equal(open.nodes.hopWhile.hidden, false, 'a domain and a public platform: offer it');
+  const locked = bootSteps([li('github-repo'), li('oauth-app', ['slocked'])]);
+  locked.sandbox.stepsPaint();
+  assert.equal(locked.nodes.hopWhile.hidden, true, 'locked: nothing to offer');
+  const done = bootSteps([li('github-repo'), li('oauth-app', ['sdone'])]);
+  done.sandbox.stepsPaint();
+  assert.equal(done.nodes.hopWhile.hidden, true, 'already wired: nothing to offer');
+  const opened = bootSteps([li('github-repo'), li('oauth-app', ['sdone'])], true);
+  opened.sandbox.stepsPaint();
+  assert.equal(opened.nodes.hopWhile.hidden, false, 'but an open one keeps its door so it can be closed');
+});
+
+// ── the markup and the sheet ────────────────────────────────────────────────────
+test('the wait stands the strip, the locked checklist and the later lines down; the arrival pages', () => {
+  for (const id of ['hop', 'hopStatus', 'hopBarFill', 'hopCanvas', 'hopLeft', 'hopJump', 'hopRight', 'hopScore', 'hopWhile', 'hopSignin', 'stepPager', 'stepCount', 'stepBack', 'stepNext']) {
+    assert.ok(HUB.includes(`id="${id}"`), `#${id} is baked into the panel`);
+  }
+  const panel = HUB.slice(HUB.indexOf('id="panel-done"'), HUB.indexOf('</section>', HUB.indexOf('id="panel-done"')));
+  assert.ok(panel.indexOf('id="liveProgress"') < panel.indexOf('id="hop"') && panel.indexOf('id="hop"') < panel.indexOf('id="wizInvite"'),
+    'the hop sits where the strip was, above the invite');
+  assert.match(panel, /id="hopStatus" role="status" aria-live="polite"/, 'the line is the live region while the strip is hidden');
+  assert.match(STYLE, /#panel-done\[data-moment="wait"\] #liveProgress,/);
+  assert.match(STYLE, /#panel-done\[data-moment="wait"\]:not\(\.hopSignin\) #humanSteps\{display:none;\}/);
+  assert.match(STYLE, /#panel-done\[data-moment="arrive"\] \.humanSteps>li:not\(\.cur\)\{display:none;\}/);
+  assert.match(STYLE, /#panel-done\[data-moment="arrive"\] #liveProgress \.stages\{display:none;\}/, 'the arrival keeps the note with the address, not the dots');
+  assert.match(STYLE, /@media \(prefers-reduced-motion:no-preference\)\{\n {2}#panel-done\[data-moment="arrive"\] \.humanSteps>li\.cur,/, 'the arrival\'s fade-in is motion-gated');
+});