@bongos/core 1.25.29 → 1.25.31

package/modules/government/docket.js

@@ -631,6 +631,12 @@ async function attachAsks(matters, readAsks, timeoutMs) {
 // task 1004705) and the docket says `routed: true`. null routes nothing.
 async function buildDocket({ viewer, permissions, contributions = registeredContributions(), now = Date.now(), timeoutMs = SOURCE_TIMEOUT_MS, decisions = null, government = null, readAsks = null, readFlags = null, seats = null } = {}) {
   const held = new Set(permissions || []);
+  // `decisions`, `government` and `seats` may arrive as promises (docketFor starts
+  // those reads alongside the sources, task 1005310); they are awaited once the
+  // sources have answered. The handler is attached here, before anything waits, so
+  // a failure is never an unhandled rejection while the sources are reading.
+  const governmentReads = Promise.all([decisions, government, seats]);
+  governmentReads.catch(() => {});
   const ctx = Object.freeze({
     builderId: String(viewer.id),
     rank: viewer.rank || null,
@@ -681,8 +687,11 @@ async function buildDocket({ viewer, permissions, contributions = registeredCont
   const order = declared.map((d) => d.source);
   sourceStatus.sort((a, b) => order.indexOf(a.source) - order.indexOf(b.source));
   matters.sort(compareMatters);
-  await attachAsks(matters, readAsks, timeoutMs);
-  await attachFlags(matters, readFlags, timeoutMs);
+  // Asks and reword flags are two independent reads on the same matters, each
+  // writing its own field: read together (task 1005310), alongside the
+  // government reads started above.
+  await Promise.all([attachAsks(matters, readAsks, timeoutMs), attachFlags(matters, readFlags, timeoutMs)]);
+  [decisions, government, seats] = await governmentReads;
   // THE DIRECTION DESK (task 1004705): who each matter waits on, from real seats.
   const yours = seats ? routing.routeAll(matters, ctx.builderId, seats, now) : null;
 
@@ -872,16 +881,38 @@ async function findMatterFor(builder, matterId) {
 
 // The route's entry point: resolve the viewer's permissions server-side (fresh,
 // uncached — ADR 0016), then build.
-async function docketFor(builder) {
+//
+// ONE BUILD PER VIEWER AT A TIME (task 1005310). The street asks for the docket
+// and for GET /government/counts in the same breath, and counts is built from
+// this same docket, so every street load built it twice, side by side, and each
+// slowed the other. A second ask for the SAME viewer that arrives while a build
+// is running shares that build; the moment it finishes nothing is kept, so the
+// next ask builds afresh. Nothing is cached: no answer is older than the request
+// that receives it, and permissions are still resolved inside every build.
+const building = new Map();
+function docketFor(builder) {
+  const key = String(builder && builder.id);
+  const running = building.get(key);
+  if (running) return running;
+  const p = buildDocketFor(builder).finally(() => { building.delete(key); });
+  building.set(key, p);
+  return p;
+}
+async function buildDocketFor(builder) {
   const permissions = await resolver.resolveBuilderPermissions(builder.id);
   // The table is read per request, uncached (ADR 0016). A failed read leaves
   // every building's decision null; it never fails the city.
-  const decisions = await board.decisionRulesView().catch((err) => {
+  // The government reads (decision rules → the government → its seats) run
+  // ALONGSIDE the sources (task 1005310): buildDocket waits for them only once
+  // its sources have answered. Every step below catches its own failure.
+  const decisions = board.decisionRulesView().catch((err) => {
     log.warn({ err: err && err.message }, 'governor docket: decision rules unreadable');
     return null;
   });
-  const government = permissions.includes(GOVERNMENT_GATE.permission) ? await loadGovernment({ decisions }) : null;
-  const seats = government ? await loadSeats(government) : null;
+  const government = permissions.includes(GOVERNMENT_GATE.permission)
+    ? decisions.then((d) => loadGovernment({ decisions: d }))
+    : Promise.resolve(null);
+  const seats = government.then((g) => (g ? loadSeats(g) : null));
   return buildDocket({ viewer: builder, permissions, decisions, government, readAsks: asksDb.asksFor, readFlags: asksDb.unclearFor, seats });
 }
 

package/modules/hall-ui/public/city.js

@@ -56,7 +56,7 @@
     leads: '/api/bongos/government/leads',
     // the pots each goal draws from, the reserve, the spend cap (task 1004712)
     treasury: '/api/bongos/government/treasury',
-    claims: '/api/bongos/tasks/claimable?limit=1',
+    claims: '/api/bongos/tasks/claimable?view=claims',
     tasks: '/api/bongos/tasks?status=active&limit=200',
     cost: '/api/bongos/public/cost-summary',
     roster: '/api/bongos/builders/roster',

package/modules/hall-ui/public/craft-mode.js

@@ -265,6 +265,10 @@
     return false;
   }
   function homeHref(mode) {
+    // In game mode the street is not a place (shell-game.js would send it back
+    // home), so the patron's home there is Home itself (task 1005307).
+    var g = window.OTBShellGame;
+    if (g && typeof g.on === 'function' && g.on() === true) return '/';
     var street = mode === 'patron' && window.GovCity && window.GovCity.STREET_HREF;
     return street || '/';
   }

package/modules/hall-ui/public/gov-feeds.js

@@ -42,8 +42,8 @@
     presets: '/government/presets',
     goals: '/goals',
     rollups: '/goals/rollups',
-    // the active claims ride on the claimable feed; one claimable row is plenty
-    claims: '/tasks/claimable?limit=1',
+    // the open claims alone (?view=claims, task 1005310): the claimable feed is not built
+    claims: '/tasks/claimable?view=claims',
     tasks: '/tasks?status=active&limit=200',
     cost: '/public/cost-summary',
     roster: '/builders/roster',

package/modules/hall-ui/public/home-city.js

@@ -355,9 +355,17 @@
   }
 
   // ---- the governor's Home is the street; tests swap the hop for a recorder ----
+  // Classic view only (task 1005307): in game mode the street is not a place, so
+  // shell-game.js sends it straight back here — hopping from Home made an endless
+  // reload loop. The game's patron stays on the city and walks on from the visor.
+  // shell-game.js is the one answer: a page without it is never in game mode.
+  function gameOn() {
+    const g = window.OTBShellGame;
+    return !!(g && typeof g.on === 'function' && g.on() === true);
+  }
   function streetHop() {
     const href = window.GovCity && window.GovCity.STREET_HREF;
-    if (document.documentElement.dataset.craft !== 'patron' || !href) return false;
+    if (document.documentElement.dataset.craft !== 'patron' || !href || gameOn()) return false;
     (window.OTBHomeStreetHop || ((h) => window.location.assign(h)))(href);
     return true;
   }

package/modules/lifecycle/routes/tasks.js

@@ -219,7 +219,7 @@ module.exports = function buildTasksRouter() {
     // RETURNED feed, never the query — lifecycle/CLAUDE.md has the why.
     const claimNeeds = parseNeedsFilter(req.query.needs); if (claimNeeds && claimNeeds.bad) return badNeedsFilter(res); // task 1004950
     const claimLimit = posInt(req.query.limit, 'bad_limit', 1000);
-    if (claimLimit && claimLimit.bad) return res.fail('bad_limit', { status: 400, message: 'limit must be a positive integer (max 1000).' });
+    if (claimLimit && claimLimit.bad) return res.fail('bad_limit', { status: 400, message: 'limit must be a positive integer (max 1000).' }); if (req.query.view === 'claims') return res.json({ active_claims: await db.listActiveClaims() }); // open claims only, no claimable feed: the street needs just these (task 1005310)
     const [feed, active] = await Promise.all([
       db.listClaimableTasks({
         versionId: version || null, builderId: req.builder.id,

package/package-lock.json

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

package/package.json

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

@@ -11949,5 +11949,17 @@
       "id": "1005299",
       "text": "The city's sky clock no longer says \"hour 24\" in the last three minutes before midnight, and its check no longer fails at random late at night."
     }
+  ],
+  "1.25.30": [
+    {
+      "id": "1005307",
+      "text": "Choosing Patron in game mode no longer reloads the hall endlessly; it settles on the city."
+    }
+  ],
+  "1.25.31": [
+    {
+      "id": "1005310",
+      "text": "The governor's street asks the server for less and gets its answers sooner."
+    }
   ]
 }

package/src/module-api.js

@@ -81,7 +81,7 @@ const { sleep } = require('./sleep');
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.25.29'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.25.31'; // 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_home.mjs

@@ -31,7 +31,7 @@ function el() {
 }
 
 // One page: `page` is body[data-page], `active` the nav item the shell marked.
-function boot({ page, active = null, govCity = false }) {
+function boot({ page, active = null, govCity = false, game = false }) {
   const hops = [];
   const body = el();
   body.setAttribute('data-page', page);
@@ -55,6 +55,7 @@ function boot({ page, active = null, govCity = false }) {
     location: { search: '' },
   };
   if (govCity) window.GovCity = { STREET_HREF: '/builders/street' };
+  if (game) window.OTBShellGame = { on: () => true };
   window.window = window;
   vm.runInNewContext(CRAFT, { window, document, CustomEvent: function () {}, Promise, console });
   return { CM: window.OTBCraftMode, hops };
@@ -83,6 +84,16 @@ test('choosing Patron on another craft\'s page lands on the street', () => {
   assert.equal(boot({ page: 'studio' }).CM.homeHref('patron'), '/');
 });
 
+// task 1005307: in game mode the street is not a place (shell-game.js sends it back
+// Home, and Home sent a patron to the street again: an endless reload loop), so a
+// stranded page goes straight Home.
+test('in game mode, choosing Patron on another craft\'s page goes Home, never the street', () => {
+  const { CM, hops } = boot({ page: 'studio', active: 'studio', govCity: true, game: true });
+  assert.equal(CM.homeHref('patron'), '/');
+  CM.choose('patron');
+  assert.deepEqual(hops, ['/']);
+});
+
 test('a page the chosen craft also shows stays put', () => {
   // goals is in Artisan and Artist alike
   const { CM, hops } = boot({ page: 'goals', active: 'goals' });

package/tests/docket_load_speed.mjs

@@ -0,0 +1,99 @@
+// tests/docket_load_speed.mjs — the governor's street loads faster (task 1005310).
+//
+// Measured on the live hub: the street asked for GET /government/docket and
+// GET /government/counts together, counts rebuilt the same docket, and each build
+// waited for the government reads before it even started its sources. Three
+// properties now hold, and each is driven here against the real docket.js:
+//   1. two asks for the SAME viewer while a build runs share that one build, and
+//      nothing is kept once it finishes (no cache: the next ask builds afresh);
+//   2. the sources start reading before the government reads have answered;
+//   3. a government read that fails is never an unhandled rejection while the
+//      sources are still reading, and the docket still answers or fails as before.
+// And the street's claims read (GET /tasks/claimable?view=claims) answers only the
+// open claims, without building the claimable feed.
+import { strict as assert } from 'node:assert';
+import { test, after } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const require = createRequire(import.meta.url);
+const api = require(path.join(ROOT, 'src', 'module-api.js'));
+const docket = require(path.join(ROOT, 'modules', 'government', 'docket.js'));
+const board = require(path.join(ROOT, 'modules', 'government', 'board.js'));
+const resolver = require(path.join(ROOT, 'modules', 'government', 'resolver.js'));
+const read = (p) => fs.readFileSync(path.join(ROOT, p), 'utf8');
+
+const REAL = { perms: resolver.resolveBuilderPermissions, rules: board.decisionRulesView };
+after(() => { resolver.resolveBuilderPermissions = REAL.perms; board.decisionRulesView = REAL.rules; });
+
+const order = [];
+let permReads = 0;
+// The docket's own atom only: no government gate, so no government tables are read.
+resolver.resolveBuilderPermissions = async () => { permReads += 1; return ['board.vote.cast']; };
+board.decisionRulesView = () => new Promise((r) => setTimeout(() => { order.push('decisions'); r(null); }, 40));
+api.contribute(docket.CONTRIBUTION_POINT, {
+  source: 'blockers', building: 'planning', gate: { anyBuilder: true },
+  read: async () => { order.push('source'); return []; },
+});
+
+test('two asks for one viewer while a build runs share it; the next ask builds afresh', async () => {
+  permReads = 0;
+  const viewer = { id: 7001, rank: 'metic' };
+  const [a, b] = await Promise.all([docket.docketFor(viewer), docket.docketFor({ ...viewer })]);
+  assert.equal(permReads, 1, 'one build for both asks');
+  assert.equal(a, b, 'both asks receive the same answer');
+  await docket.docketFor(viewer);
+  assert.equal(permReads, 2, 'a finished build is not kept: the next ask builds again');
+  await Promise.all([docket.docketFor({ id: 7002 }), docket.docketFor({ id: 7003 })]);
+  assert.equal(permReads, 4, 'different viewers never share a build');
+});
+
+test('the sources start reading before the government reads answer', async () => {
+  order.length = 0;
+  await docket.docketFor({ id: 7004, rank: 'metic' });
+  assert.deepEqual(order, ['source', 'decisions']);
+});
+
+const VIEWER = { id: 42, rank: 'metic' };
+const NOW = Date.parse('2026-11-14T12:00:00Z');
+const slowSource = (ms) => ({
+  sources: new Map([['blockers', { source: 'blockers', building: 'planning', gate: { anyBuilder: true },
+    read: () => new Promise((r) => setTimeout(() => r([{ id: 1, title: 'Pick a host', state: 'needs', rule: 'decide' }]), ms)) }]]),
+  readings: new Map(), floors: new Map(), histories: new Map(), desks: new Map(),
+});
+
+test('a government read handed in as a promise answers exactly as its value does', async () => {
+  const plain = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: slowSource(1), now: NOW, decisions: [], government: null, seats: null });
+  const later = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: slowSource(1), now: NOW,
+    decisions: Promise.resolve([]), government: Promise.resolve(null), seats: Promise.resolve(null) });
+  assert.deepEqual(later, plain);
+});
+
+test('a failed government read is never an unhandled rejection while the sources read', async () => {
+  const unhandled = [];
+  const onUnhandled = (e) => unhandled.push(e);
+  process.on('unhandledRejection', onUnhandled);
+  try {
+    const boom = new Error('government unreadable');
+    await assert.rejects(docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: slowSource(30), now: NOW,
+      decisions: Promise.resolve(null), government: Promise.reject(boom), seats: Promise.resolve(null) }), /government unreadable/);
+    await new Promise((r) => setTimeout(r, 20));
+    assert.deepEqual(unhandled, []);
+  } finally {
+    process.off('unhandledRejection', onUnhandled);
+  }
+});
+
+test('the claims read answers the open claims without building the claimable feed', () => {
+  const src = read('modules/lifecycle/routes/tasks.js');
+  const at = src.indexOf("req.query.view === 'claims'");
+  assert.ok(at > 0, 'GET /tasks/claimable has a claims-only view');
+  assert.ok(at < src.indexOf('db.listClaimableTasks({', at - 2000), 'it answers before the claimable feed is built');
+  assert.match(src.slice(at, at + 200), /active_claims: await db\.listActiveClaims\(\)/);
+  for (const f of ['modules/hall-ui/public/gov-feeds.js', 'modules/hall-ui/public/city.js']) {
+    assert.match(read(f), /tasks\/claimable\?view=claims/, `${f} asks for the claims alone`);
+  }
+});

package/tests/hall_city_living.mjs

@@ -488,7 +488,7 @@ async function bootLiving({ asks = false, answer = null } = {}) {
   const feeds = {
     '/api/bongos/government/docket': asks ? withAsks(docketRouted()) : docketRouted(), '/api/bongos/goals': fx('goals'), '/api/bongos/goals/rollups': fx('goals__rollups'),
     '/api/bongos/government/leads': leadsRead(), '/api/bongos/government/treasury': fx('government__treasury'),
-    '/api/bongos/government/constitution': fx('government__constitution'), '/api/bongos/tasks/claimable?limit=1': fx('tasks__claimable'),
+    '/api/bongos/government/constitution': fx('government__constitution'), '/api/bongos/tasks/claimable?view=claims': fx('tasks__claimable'),
     '/api/bongos/tasks?status=active&limit=200': fx('tasks__status-active'), '/api/bongos/public/cost-summary': fx('public__cost-summary'),
     '/api/bongos/builders/roster': fx('builders__roster'), '/api/bongos/me': fx('me'), '/api/bongos/blockers?limit=100': fx('blockers'),
     '/api/bongos/autonomy/fence': fx('autonomy__fence'), '/api/bongos/moving': fx('moving'),

package/tests/hall_gov_counts.mjs

@@ -172,7 +172,7 @@ test('in the harness COUNT_FEEDS, with the docket the page already read, give th
   assert.equal(L.countsOf(m, s).on_others, L.countsOf(m).on_others - 1);
   // and nothing the shell reads is a task list
   assert.ok(!F.COUNT_FEEDS.includes('tasks') && !F.COUNT_FEEDS.includes('goals'), 'the tally reads no task or goal list');
-  assert.match(F.FEEDS.claims, /limit=1\b/, 'the claims ride the claimable feed at one row');
+  assert.match(F.FEEDS.claims, /[?&]view=claims\b/, 'the claims ride the claims-only view of the claimable route (task 1005310)');
 });
 
 // ── 3. every surface prints the same numbers ────────────────────────────────

package/tests/hall_gov_real_site.mjs

@@ -197,7 +197,7 @@ const FEED = {
   '/api/bongos/government/docket': 'government__docket', '/api/bongos/government/counts': 'government__counts', '/api/bongos/goals': 'goals', '/api/bongos/goals/rollups': 'goals__rollups',
   '/api/bongos/me': 'me', '/api/bongos/builders/roster': 'builders__roster', '/api/bongos/blockers': 'blockers',
   '/api/bongos/public/cost-summary': 'public__cost-summary', '/api/bongos/tasks/claimable': 'tasks__claimable',
-  '/api/bongos/tasks/claimable?limit=1': 'tasks__claimable', '/api/bongos/tasks?status=active&limit=200': 'tasks__status-active',
+  '/api/bongos/tasks/claimable?view=claims': 'tasks__claimable', '/api/bongos/tasks?status=active&limit=200': 'tasks__status-active',
   '/api/bongos/blockers?limit=100': 'blockers', '/api/bongos/moving': 'moving', '/api/bongos/autonomy/fence': 'autonomy__fence',
   '/api/bongos/government/constitution': 'government__constitution',
   // the hub's law book, as the route answers it (no law passed yet)

package/tests/hall_street_deck.mjs

@@ -411,7 +411,7 @@ const FEED = {
   '/api/bongos/me': 'me', '/api/bongos/builders/roster': 'builders__roster',
   '/api/bongos/blockers': 'blockers', '/api/bongos/public/cost-summary': 'public__cost-summary',
   // the living model's reads, as gov-feeds.js names them (one read each per page)
-  '/api/bongos/tasks/claimable?limit=1': 'tasks__claimable', '/api/bongos/tasks?status=active&limit=200': 'tasks__status-active',
+  '/api/bongos/tasks/claimable?view=claims': 'tasks__claimable', '/api/bongos/tasks?status=active&limit=200': 'tasks__status-active',
   '/api/bongos/blockers?limit=100': 'blockers', '/api/bongos/moving': 'moving', '/api/bongos/autonomy/fence': 'autonomy__fence',
   '/api/bongos/government/constitution': 'government__constitution', '/api/bongos/government/leads': 'government__leads',
 };

package/tests/hall_street_depth.mjs

@@ -471,7 +471,7 @@ async function bootPage({ withLiving = true } = {}) {
   const F = {
     '/api/bongos/government/docket': docketRouted(), '/api/bongos/goals': fx('goals'), '/api/bongos/goals/rollups': fx('goals__rollups'),
     '/api/bongos/government/leads': leadsRead(),
-    '/api/bongos/tasks/claimable?limit=1': fx('tasks__claimable'), '/api/bongos/tasks?status=active': fx('tasks__status-active'),
+    '/api/bongos/tasks/claimable?view=claims': fx('tasks__claimable'), '/api/bongos/tasks?status=active': fx('tasks__status-active'),
     '/api/bongos/public/cost-summary': fx('public__cost-summary'), '/api/bongos/builders/roster': fx('builders__roster'), '/api/bongos/me': fx('me'),
     // the living model's reads, as gov-feeds.js names them
     '/api/bongos/tasks?status=active&limit=200': fx('tasks__status-active'), '/api/bongos/blockers?limit=100': fx('blockers'),
@@ -493,7 +493,7 @@ test('the page draws the living street: the skyline, a pod per claim, the plates
   const p = await bootPage();
   const all = (id) => walk(p.byId.get(id));
   const cls = (id, c) => all(id).filter((e) => (e.className || '').split(' ').includes(c));
-  for (const u of ['/api/bongos/tasks/claimable?limit=1', '/api/bongos/government/leads']) assert.ok(p.calls.includes(u), u);
+  for (const u of ['/api/bongos/tasks/claimable?view=claims', '/api/bongos/government/leads']) assert.ok(p.calls.includes(u), u);
   assert.ok(!p.calls.some((u) => /governor-overlay/.test(u)), 'no overlay is read');
   assert.equal(p.calls.filter((u) => u === '/api/bongos/me').length, 1, 'the living feeds are read once');
   assert.equal(cls('streetDepthNear', 'street-depth-sil__face').length, 1);

package/tests/home_city_widget.mjs

@@ -48,12 +48,13 @@ const stubs = (status, craft) => `
   window.OTBCraftMode = { iconHtml: (k, cls) => '<svg class="' + cls + '" data-icon="' + k + '"></svg>', choose: (m) => window.__chosen.push(m), current: () => window.__craft };
   window.OTB = { contributeHallWidget(w) { window.__widget = w; } };`;
 
-async function boot({ status = 200, width = 1280, still = true, craft = null } = {}) {
+async function boot({ status = 200, width = 1280, still = true, craft = null, game = false } = {}) {
   const ctx = await browser.newContext({ viewport: { width, height: 900 }, reducedMotion: still ? 'reduce' : 'no-preference' });
   const page = await ctx.newPage();
   await page.clock.install();
   await page.setContent(`<!doctype html><html><head><style>${CSS}</style></head><body><section id="home-city" class="scroll home-city" hidden></section></body></html>`);
   await page.addScriptTag({ content: stubs(status, craft) });
+  if (game) await page.addScriptTag({ content: 'window.OTBShellGame = { on: () => true };' });
   await page.addScriptTag({ content: GOV });
   await page.addScriptTag({ content: DRAW });
   await page.addScriptTag({ content: WIDGET });
@@ -184,6 +185,16 @@ test('the governor\'s Home is the street: Patron on Home goes there, opened or c
   await ctx.close();
 });
 
+// task 1005307: in game mode the street is not a place — shell-game.js sends it back to
+// Home — so hopping there from Home was an endless reload loop. The game's patron stays.
+test('in game mode the patron stays on Home: no hop to the street, opened or chosen', { skip }, async () => {
+  const { ctx, page } = await boot({ craft: 'patron', game: true });
+  await page.waitForFunction(() => document.querySelectorAll('.hc-rung').length > 0);
+  const flipped = await page.evaluate(() => { document.dispatchEvent(new CustomEvent('otb:craft', { detail: { mode: 'patron' } })); return window.__hops.slice(); });
+  await ctx.close();
+  assert.deepEqual(flipped, [], 'Home with Patron in game mode builds the city and never leaves for the street');
+});
+
 test('a refused read leaves the section hidden: never an empty plate', { skip }, async () => {
   const { ctx, page } = await boot({ status: 401 });
   await page.evaluate(() => new Promise((r) => setTimeout(r, 0)));